Results 11  20
of
47
A modular typechecking algorithm for type theory with singleton types and proof irrelevance
 IN TLCA’09, VOLUME 5608 OF LNCS
, 2009
"... ..."
(Show Context)
Greedy Bidirectional Polymorphism
, 2009
"... Bidirectional typechecking has become popular in advanced type systems because it works in many situations where inference is undecidable. In this paper, I show how to cleanly handle parametric polymorphism in a bidirectional setting. The key contribution is a bidirectional type system for a subset ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
Bidirectional typechecking has become popular in advanced type systems because it works in many situations where inference is undecidable. In this paper, I show how to cleanly handle parametric polymorphism in a bidirectional setting. The key contribution is a bidirectional type system for a subset of ML that supports firstclass (higherrank and even impredicative) polymorphism, and is complete for predicative polymorphism (including MLstyle polymorphism and higherrank polymorphism). The system’s power comes from bidirectionality combined with a “greedy ” method of finding polymorphic instances inspired by Cardelli’s early work on System F<:. This work demonstrates that bidirectionality is a good foundation for traditionally vexing features like firstclass polymorphism.
Constructor subtyping in the Calculus of Inductive Constructions
 Proceedings of FOSSACS'00, LNCS 1784
, 2000
"... The Calculus of Inductive Constructions (CIC) is a powerful type system, featuring dependent types and inductive definitions, that forms the basis of proofassistant systems such as Coq and Lego. We extend CIC with constructor subtyping, a basic form of subtyping in which an inductive type &sigm ..."
Abstract

Cited by 6 (0 self)
 Add to MetaCart
(Show Context)
The Calculus of Inductive Constructions (CIC) is a powerful type system, featuring dependent types and inductive definitions, that forms the basis of proofassistant systems such as Coq and Lego. We extend CIC with constructor subtyping, a basic form of subtyping in which an inductive type &sigma; is viewed as a subtype of another inductive type &tau; if &tau; has more elements than &sigma;. It is shown that the calculus is wellbehaved and provides a suitable basis for formalizing natural semantics in proofdevelopment systems.
A general method to prove the normalization theorem for first and second order typed λcalculi
 Mathematical Structures in Computer Science
, 1999
"... and second order typed λcalculi ..."
Scrapping your Inefficient Engine: using Partial Evaluation to Improve DomainSpecific Language Implementation
"... Partial evaluation aims to improve the efficiency of a program by specialising it with respect to some known inputs. In theory, it is a natural match to language implementation, in that partially evaluating an interpreter with respect to a specific source program yields an efficient translation of t ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
(Show Context)
Partial evaluation aims to improve the efficiency of a program by specialising it with respect to some known inputs. In theory, it is a natural match to language implementation, in that partially evaluating an interpreter with respect to a specific source program yields an efficient translation of that program. In practice, however, there can be difficulties — we must consider e.g. bindingtime improvements, function calls, recursion, code duplication, and how to deal with sideeffects. These difficulties limit the practical benefits of partial evaluation and have limited its widespread adoption. In this paper, we show that partial evaluation can be an effective and, unusually, straightforward technique for the efficient implementation of domainspecific languages. We achieve this by exploiting dependent types and by following some simple rules in the definition of the interpreter. We present experimental evidence that partial evaluation of programs in domainspecific languages yields efficient residual programs whose performance is competitive with their Java and C equivalents and which are also, through the use of dependent types, verifiably resourcesafe. Using our technique, it follows that a verifiably correct and resourcesafe program can also be an efficient program. 1.
Typed Applicative Structures and Normalization by Evaluation for System F ω
"... Abstract. We present a normalizationbyevaluation (NbE) algorithm for System F ω with βηequality, the simplest impredicative type theory with computation on the type level. Values are kept abstract and requirements on values are kept to a minimum, allowing many different implementations of the alg ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
(Show Context)
Abstract. We present a normalizationbyevaluation (NbE) algorithm for System F ω with βηequality, the simplest impredicative type theory with computation on the type level. Values are kept abstract and requirements on values are kept to a minimum, allowing many different implementations of the algorithm. The algorithm is verified through a general model construction using typed applicative structures, called type and object structures. Both soundness and completeness of NbE are conceived as an instance of a single fundamental theorem.
Dependent Record Types, Subtyping and Proof Reutilization
"... . We present an example of formalization of systems of algebras using an extension of MartinLof's theory of types with record types and subtyping. This extension has been presented in [5]. In this paper we intend to illustrate all the features of the extended theory that we consider relevant f ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
. We present an example of formalization of systems of algebras using an extension of MartinLof's theory of types with record types and subtyping. This extension has been presented in [5]. In this paper we intend to illustrate all the features of the extended theory that we consider relevant for the task of formalizing algebraic constructions. We also provide code of the formalization as accepted by a type checker that has been implemented. 1. Introduction We shall use an extension of MartinLof's theory of logical types [14] with dependent record types and subtyping as the formal language in which constructions concerning systems of algebras are going to be represented. The original formulation of MartinLof's theory of types, from now on referred to as the logical framework, has been presented in [15, 7]. The system of types that this calculus embodies are the type Set (the type of inductively defined sets), dependent function types and for each set A, the type of the elements of A...
On the Algebraic Foundation of Proof Assistants for Intuitionistic Type Theory
, 2008
"... An algebraic presentation of MartinLöf’s intuitionistic type theory is given which is based on the notion of a category with families with extra structure. We then present a typechecking algorithm for the normal forms of this theory, and sketch how it gives rise to an initial category with familie ..."
Abstract

Cited by 4 (3 self)
 Add to MetaCart
An algebraic presentation of MartinLöf’s intuitionistic type theory is given which is based on the notion of a category with families with extra structure. We then present a typechecking algorithm for the normal forms of this theory, and sketch how it gives rise to an initial category with families with extra structure. In this way we obtain a purely algebraic formulation of the correctness of the typechecking algorithm which provides the core of proof assistants for intuitionistic type theory.
ΠΣ: A Core Language for Dependently Typed Programming
 ICFP
, 2008
"... We introduce ΠΣ, a core language for dependently typed programming. Our intention is that ΠΣ should play the role extensions of System F are playing for conventional functional languages with polymorphism, like Haskell. The core language incorporates mutual dependent recursive definitions, Type: Typ ..."
Abstract

Cited by 2 (2 self)
 Add to MetaCart
We introduce ΠΣ, a core language for dependently typed programming. Our intention is that ΠΣ should play the role extensions of System F are playing for conventional functional languages with polymorphism, like Haskell. The core language incorporates mutual dependent recursive definitions, Type: Type, Π and Σtypes, finite sets of labels and explicit constraints. We show that standard constructions in dependently typed programming can be easily encoded in our language. We address some important issues: having an equality checker which unfolds recursion only when needed, avoiding looping when typechecking sensible programs; the simplification of type checking for eliminators like case by using equational constraints, allowing the flexible use of case expressions within dependently typed programming and the representation of dependent datatypes using explicit constraints.
Simply Easy! An Implementation of a Dependently Typed Lambda Calculus
, 2007
"... We present an implementation in Haskell of a dependentlytyped lambda calculus that can be used as the core of a programming language. We show that a dependentlytyped lambda calculus is no more difficult to implement than other typed lambda calculi. In fact, our implementation is almost as easy as ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
We present an implementation in Haskell of a dependentlytyped lambda calculus that can be used as the core of a programming language. We show that a dependentlytyped lambda calculus is no more difficult to implement than other typed lambda calculi. In fact, our implementation is almost as easy as an implementation of the simply typed lambda calculus, which we emphasize by discussing the modifications necessary to go from one to the other. We explain how to add data types and write simple programs in the core language, and discuss the steps necessary to build a fullfledged programming language on top of our simple core.