Results 1  10
of
29
Theorems for free!
 FUNCTIONAL PROGRAMMING LANGUAGES AND COMPUTER ARCHITECTURE
, 1989
"... From the type of a polymorphic function we can derive a theorem that it satisfies. Every function of the same type satisfies the same theorem. This provides a free source of useful theorems, courtesy of Reynolds' abstraction theorem for the polymorphic lambda calculus. ..."
Abstract

Cited by 380 (8 self)
 Add to MetaCart
From the type of a polymorphic function we can derive a theorem that it satisfies. Every function of the same type satisfies the same theorem. This provides a free source of useful theorems, courtesy of Reynolds' abstraction theorem for the polymorphic lambda calculus.
Linear Types Can Change the World!
 PROGRAMMING CONCEPTS AND METHODS
, 1990
"... The linear logic of J.Y. Girard suggests a new type system for functional languages, one which supports operations that "change the world". Values belonging to a linear type must be used exactly once: like the world, they cannot be duplicated or destroyed. Such values require no refere ..."
Abstract

Cited by 146 (9 self)
 Add to MetaCart
The linear logic of J.Y. Girard suggests a new type system for functional languages, one which supports operations that "change the world". Values belonging to a linear type must be used exactly once: like the world, they cannot be duplicated or destroyed. Such values require no reference counting or garbage collection, and safely admit destructive array update. Linear types extend Schmidt's notion of single threading; provide an alternative to Hudak and Bloss' update analysis; and offer a practical complement to Lafont and Holmström's elegant linear languages.
Type classes in Haskell
 ACM Transactions on Programming Languages and Systems
, 1996
"... This paper de nes a set of type inference rules for resolving overloading introduced by type classes. Programs including type classes are transformed into ones which may be typed by the HindleyMilner inference rules. In contrast to other work on type classes, the rules presented here relate directl ..."
Abstract

Cited by 136 (7 self)
 Add to MetaCart
This paper de nes a set of type inference rules for resolving overloading introduced by type classes. Programs including type classes are transformed into ones which may be typed by the HindleyMilner inference rules. In contrast to other work on type classes, the rules presented here relate directly to user programs. An innovative aspect of this work is the use of secondorder lambda calculus to record type information in the program. 1.
A syntax for linear logic
 Presented at Conference on Mathematical Foundations of Programming Language Semantics
, 1993
"... Abstract. This tutorial paper provides an introduction to intuitionistic logic and linear logic, and shows how they correspond to type systems for functional languages via the notion of ‘Propositions as Types’. The presentation of linear logic is simplified by basing it on the Logic of Unity. An app ..."
Abstract

Cited by 89 (7 self)
 Add to MetaCart
(Show Context)
Abstract. This tutorial paper provides an introduction to intuitionistic logic and linear logic, and shows how they correspond to type systems for functional languages via the notion of ‘Propositions as Types’. The presentation of linear logic is simplified by basing it on the Logic of Unity. An application to the array update problem is briefly discussed. 1
On Girard’s “Candidats de Réductibilité
 Logic and Computer Science
, 1990
"... Abstract: We attempt to elucidate the conditions required on Girard’s candidates of reducibility (in French, “candidats de reductibilité”) in order to establish certain properties of various typed lambda calculi, such as strong normalization and ChurchRosser property. We present two generalizations ..."
Abstract

Cited by 40 (5 self)
 Add to MetaCart
(Show Context)
Abstract: We attempt to elucidate the conditions required on Girard’s candidates of reducibility (in French, “candidats de reductibilité”) in order to establish certain properties of various typed lambda calculi, such as strong normalization and ChurchRosser property. We present two generalizations of the candidates of reducibility, an untyped version in the line of Tait and Mitchell, and a typed version which is an adaptation of Girard’s original method. As an application of this general result, we give two proofs of strong normalization for the secondorder polymorphic lambda calculus under ⌘reduction (and thus underreduction). We present two sets of conditions for the typed version of the candidates. The first set consists of conditions similar to those used by Stenlund (basically the typed version of Tait’s conditions), and the second set consists of Girard’s original conditions. We also compare these conditions, and prove that Girard’s conditions are stronger than Tait’s conditions. We give a new proof of the ChurchRosser theorem for bothreduction and ⌘reduction, using the modified version of Girard’s method. We also compare various proofs that have appeared in the literature (see section 11). We conclude by sketching the extension of the above results to Girard’s higherorder polymorphic calculus F!, and in appendix 1, to F! with product types. i 1
Free Theorems in the Presence of seq
, 2004
"... Parametric polymorphism constrains the behavior of pure functional programs in a way that allows the derivation of interesting theorems about them solely from their types, i.e., virtually for free. Unfortunately, the standard parametricity theorem fails for nonstrict languages supporting a polymorph ..."
Abstract

Cited by 38 (12 self)
 Add to MetaCart
Parametric polymorphism constrains the behavior of pure functional programs in a way that allows the derivation of interesting theorems about them solely from their types, i.e., virtually for free. Unfortunately, the standard parametricity theorem fails for nonstrict languages supporting a polymorphic strict evaluation primitive like Haskell's $\mathit{seq}$. Contrary to the folklore surrounding $\mathit{seq}$ and parametricity, we show that not even quantifying only over strict and bottomreflecting relations in the $\forall$clause of the underlying logical relation  and thus restricting the choice of functions with which such relations are instantiated to obtain free theorems to strict and total ones  is sufficient to recover from this failure. By addressing the subtle issues that arise when propagating up the type hierarchy restrictions imposed on a logical relation in order to accommodate the strictness primitive, we provide a parametricity theorem for the subset of Haskell corresponding to a GirardReynoldsstyle calculus with fixpoints, algebraic datatypes, and $\mathit{seq}$. A crucial ingredient of our approach is the use of an asymmetric logical relation, which leads to ``inequational'' versions of free theorems enriched by preconditions guaranteeing their validity in the described setting. Besides the potential to obtain corresponding preconditions for standard equational free theorems by combining some new inequational ones, the latter also have value in their own right, as is exemplified with a careful analysis of $\mathit{seq}$'s impact on familiar program transformations.
Translating Dependency into Parametricity
 In: ACM International Conference on Functional Programming
"... Abadi et al. introduced the dependency core calculus (DCC) as a unifying framework to study many important program analyses such as binding time, information flow, slicing, and function call tracking. DCC uses a lattice of monads and a nonstandard typing rule for their associated bind operations to ..."
Abstract

Cited by 35 (3 self)
 Add to MetaCart
(Show Context)
Abadi et al. introduced the dependency core calculus (DCC) as a unifying framework to study many important program analyses such as binding time, information flow, slicing, and function call tracking. DCC uses a lattice of monads and a nonstandard typing rule for their associated bind operations to describe the dependency of computations in a program. Abadi et al. proved a noninterference theorem that establishes the correctness of DCC’s type system and thus the correctness of the type systems for the analyses above. In this paper, we study the relationship between DCC and the GirardReynolds polymorphic lambda calculus (System F). We encode the recursionfree fragment of DCC into F via a typedirected translation. Our main theoretical result is that, following from the correctness of the translation, the parametricity theorem for F implies the noninterference theorem for DCC. In addition, the translation provides insights into DCC’s type system and suggests implementation strategies of dependency calculi in polymorphic languages.
The Gentle Art of Levitation
"... We present a closed dependent type theory whose inductive types are given not by a scheme for generative declarations, but by encoding in a universe. Each inductive datatype arises by interpreting its description—a firstclass value in a datatype of descriptions. Moreover, the latter itself has a de ..."
Abstract

Cited by 31 (8 self)
 Add to MetaCart
(Show Context)
We present a closed dependent type theory whose inductive types are given not by a scheme for generative declarations, but by encoding in a universe. Each inductive datatype arises by interpreting its description—a firstclass value in a datatype of descriptions. Moreover, the latter itself has a description. Datatypegeneric programming thus becomes ordinary programming. We show some of the resulting generic operations and deploy them in particular, useful ways on the datatype of datatype descriptions itself. Surprisingly this apparently selfsupporting setup is achievable without paradox or infinite regress. 1.
Adding algebraic rewriting to the untyped lambda calculus
 Information and Computation
, 1992
"... We investigate the system obtained by adding an algebraic rewriting system R to an untyped lambda calculus in which terms are formed using the function symbols from R as constants. On certain classes of terms, called here "stable", we prove that the resulting calculus is confluent if R is ..."
Abstract

Cited by 31 (0 self)
 Add to MetaCart
(Show Context)
We investigate the system obtained by adding an algebraic rewriting system R to an untyped lambda calculus in which terms are formed using the function symbols from R as constants. On certain classes of terms, called here "stable", we prove that the resulting calculus is confluent if R is confluent, and terminating if R is terminating. The termination result has the corresponding theorems for several typed calculi as corollaries. The proof of the confluence result suggests a general method for proving confluence of typed β reduction plus rewriting; we sketch the application to the polymorphic lambda calculus.