Results 1  10
of
12
Eekelen, M.: Size analysis of algebraic data types
 Selected revised papers of the 9th international symposium on Trends in Functional Programming (TFP’08
, 2009
"... The following full text is a preprint version which may differ from the publisher's version. ..."
Abstract

Cited by 10 (4 self)
 Add to MetaCart
(Show Context)
The following full text is a preprint version which may differ from the publisher's version.
A SizeAware Type System with Algebraic Data Types  With proofs of soundness and decidability
, 2008
"... We present a sizeaware type system for a firstorder functional language with algebraic data types, where types are annotated with polynomials over size variables. We define how to generate typing rules for each data type, provided its user defined size function meets certain requirements. As an e ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
We present a sizeaware type system for a firstorder functional language with algebraic data types, where types are annotated with polynomials over size variables. We define how to generate typing rules for each data type, provided its user defined size function meets certain requirements. As an example, a program for balancing binary trees is type checked. The type system is shown to be sound with respect to the operational semantics in the class of shapely functions. Type checking is shown to be undecidable, however, decidability for a large subset of programs is guaranteed.
Hereditary substitutions for simple types, formalized
 In Proceedings of the third ACM SIGPLAN workshop on Mathematically structured functional programming, MSFP ’10
, 2010
"... We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive wh ..."
Abstract

Cited by 2 (0 self)
 Add to MetaCart
(Show Context)
We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive which is recognized by Agda’s termination checker. Using Agda as an interactive theorem prover we establish that our normalization function precisely identifies βηequivalent terms and hence can be used to decide βηequality. An interesting feature of this approach is that it is clear from the construction that βηequality is primitive recursive.
Normalization by hereditary substitutions
"... We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive wh ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive which is recognized by Agda’s termination checker. Using Agda as an interactive theorem prover we establish that our normalization function precisely identifies βηequivalent terms and hence can be used to decide βηequality. An interesting feature of this approach is that it is clear from the construction that βηequality is primitive recursive.
Type checking and normalisation
, 2008
"... This thesis is about MartinLöf’s intuitionistic theory of types (type theory). Type theory is at the same time a formal system for mathematical proof and a dependently typed programming language. Dependent types are types which depend on data and therefore to type check dependently typed program ..."
Abstract
 Add to MetaCart
(Show Context)
This thesis is about MartinLöf’s intuitionistic theory of types (type theory). Type theory is at the same time a formal system for mathematical proof and a dependently typed programming language. Dependent types are types which depend on data and therefore to type check dependently typed programming we need to perform computation (normalisation) in types. Implementations of type theory (usually some kind of automatic theorem prover or interpreter) have at their heart a type checker. Implementations of type checkers for type theory have at their heart a normaliser. In this thesis I consider type checking as it might form the basis of an implementation of type theory in the functional language Haskell and then normalisation in the more rigorous setting of the dependently typed languages Epigram and Agda. I investigate a method of proving normalisation called BigStep Normalisation (BSN). I apply BSN to a number of calculi of increasing sophistication and provide machine checked proofs of meta theoretic properties. i To Anne and Robin. ii
Chapter 3 Size Analysis of Algebraic Data Types
"... Abstract: We present a sizeaware type system for a firstorder functional language with algebraic data types, where types are annotated with polynomials over size variables. We define how to generate typing rules for each data type, provided its user defined size function meets certain requiremen ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract: We present a sizeaware type system for a firstorder functional language with algebraic data types, where types are annotated with polynomials over size variables. We define how to generate typing rules for each data type, provided its user defined size function meets certain requirements. As an example, a program for balancing binary trees is type checked. The type system is shown to be sound with respect to the operational semantics in the class of shapely functions. Type checking is shown to be undecidable, however, decidability for a large subset of programs is guaranteed. Embedded systems or server applications often have limited resources available. Therefore, it can be important to know in advance how much time or memory a computation is going to take, for instance, to determine how much memory should at least be put in a system to enable all desired operations. This helps to prevent
Under consideration for publication in J. Functional Programming 1 FUNCTIONAL PEARLS αconversion is easy
"... We present a new and simple account of αconversion suitable for formal reasoning. Our main tool is to define αconversion as a a structural congruence parametrized by a partial bijection on free variables. We show a number of basic properties of substitution. e.g. that substitution is monadic which ..."
Abstract
 Add to MetaCart
(Show Context)
We present a new and simple account of αconversion suitable for formal reasoning. Our main tool is to define αconversion as a a structural congruence parametrized by a partial bijection on free variables. We show a number of basic properties of substitution. e.g. that substitution is monadic which entails all the usual substitution laws. Finally, we relate αequivalence classes to de Bruijn terms. 1
Author manuscript, published in "Mathematically Structured Functional Programming 2010 (2010)" Hereditary Substitutions for Simple Types, Formalized
, 2012
"... We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive wh ..."
Abstract
 Add to MetaCart
(Show Context)
We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive which is recognized by Agda’s termination checker. Using Agda as an interactive theorem prover we establish that our normalization function precisely identifies βηequivalent terms and hence can be used to decide βηequality. An interesting feature of this approach is that it is clear from the construction that βηequality is primitive recursive.
Decidability of equality for a simply typed calculus using hereditary substitutions in Agda
"... Affiliation address email address Most interactive theorem provers based on Type Theory automatically check termination of function definitions, and thus restrict to structurally terminating ones. It follows that implementing a full normalizer for the λcalculus in an interactive theorem prover, a ..."
Abstract
 Add to MetaCart
(Show Context)
Affiliation address email address Most interactive theorem provers based on Type Theory automatically check termination of function definitions, and thus restrict to structurally terminating ones. It follows that implementing a full normalizer for the λcalculus in an interactive theorem prover, and thus establishing formal properties on it, is a difficult issue. Relying on hereditary substitutions, that are structurally terminating, we present an implementation of a normalizer for a simply typed λcalculus in Agda, and prove using normalization the decidability of the βηequality in this calculus. We are motivated by a formal verification of implementations of normalizers in the longer term.