Implementing mathematics with the Nuprl proof development system
Implementing mathematics with the Nuprl proof development system
Higher-order modules and the phase distinction
POPL '90 Proceedings of the 17th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A framework for defining logics
Journal of the ACM (JACM)
Compiling polymorphism using intensional type analysis
POPL '95 Proceedings of the 22nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Eliminating array bound checking through dependent types
PLDI '98 Proceedings of the ACM SIGPLAN 1998 conference on Programming language design and implementation
Cayenne—a language with dependent types
ICFP '98 Proceedings of the third ACM SIGPLAN international conference on Functional programming
Dependent types in practical programming
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the fourth ACM SIGPLAN international conference on Functional programming
Guarded recursive datatype constructors
POPL '03 Proceedings of the 30th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Notions of Computation Determine Monads
FoSSaCS '02 Proceedings of the 5th International Conference on Foundations of Software Science and Computation Structures
PTCS '01 Proceedings of the International Seminar on Proof Theory in Computer Science
Intensionality, Extensionality, and Proof Irrelevance in Modal Type Theory
LICS '01 Proceedings of the 16th Annual IEEE Symposium on Logic in Computer Science
Proceedings of the 31st ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Locus Solum: From the rules of logic to the logic of rules
Mathematical Structures in Computer Science
Journal of Functional Programming
Interactive Theorem Proving and Program Development
Interactive Theorem Proving and Program Development
OOPSLA '04 Companion to the 19th annual ACM SIGPLAN conference on Object-oriented programming systems, languages, and applications
A type system for certified binaries
ACM Transactions on Programming Languages and Systems (TOPLAS)
Proceedings of the 2005 ACM SIGPLAN conference on Programming language design and implementation
Combining programming with theorem proving
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
A language-based approach to functionally correct imperative programming
Proceedings of the tenth ACM SIGPLAN international conference on Functional programming
Journal of Logic and Computation
Conference record of the 33rd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Simple unification-based type inference for GADTs
Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
Polymorphism and separation in hoare type theory
Proceedings of the eleventh ACM SIGPLAN international conference on Functional programming
Concoqtion: indexed types now!
Proceedings of the 2007 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation
Program-ing finger trees in Coq
ICFP '07 Proceedings of the 12th ACM SIGPLAN international conference on Functional programming
Haskell '07 Proceedings of the ACM SIGPLAN workshop on Haskell workshop
PLPV '07 Proceedings of the 2007 workshop on Programming languages meets program verification
Focusing and higher-order abstract syntax
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A Bidirectional Refinement Type System for LF
Electronic Notes in Theoretical Computer Science (ENTCS)
Focusing on Binding and Computation
LICS '08 Proceedings of the 2008 23rd Annual IEEE Symposium on Logic in Computer Science
TLCA'01 Proceedings of the 5th international conference on Typed lambda calculi and applications
Dependent types for low-level programming
ESOP'07 Proceedings of the 16th European conference on Programming
Practical programming with higher-order encodings and dependent types
ESOP'08/ETAPS'08 Proceedings of the Theory and practice of software, 17th European conference on Programming languages and systems
Dependntly typed programming with domain-specific logics
Dependntly typed programming with domain-specific logics
Focusing and polarization in intuitionistic logic
CSL'07/EACSL'07 Proceedings of the 21st international conference, and Proceedings of the 16th annuall conference on Computer Science Logic
A Pronominal Approach to Binding and Computation
TLCA '09 Proceedings of the 9th International Conference on Typed Lambda Calculi and Applications
TLDI '12 Proceedings of the 8th ACM SIGPLAN workshop on Types in language design and implementation
Combining proofs and programs in a dependently typed language
Proceedings of the 41st ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages
Hi-index | 0.00 |
This paper is part of a line of work on using the logical techniques of polarity and focusing to design a dependent programming language, with particular emphasis on programming with deductive systems such as programming languages and proof theories. Polarity emphasizes the distinction between positive types, which classify data, and negative types, which classify computation. In previous work, we showed how to use Zeilberger's higher-order formulation of focusing to integrate a positive function space for representing variable binding, an essential tool for specifying logical systems, with a standard negative computational function space. However, our previous work considers only a simply-typed language. The central technical contribution of the present paper is to extend higher-order focusing with a form of dependency that we call positively dependent types: We allow dependency on positive data, but not negative computation. Additionally, we present the syntax of dependent pair and function types using an iterated inductive definition, mapping positive data to types, which gives an account of type-level computation. We construct our language inside the dependently typed programming language Agda 2, making essential use of coinductive types and induction-recursion.