Results 1  10
of
10
The maximality of the typed lambda calculus and of cartesian closed categories
 Publ. Inst. Math. (N.S
"... From the analogue of Böhm’s Theorem proved for the typed lambda calculus, without product types and with them, it is inferred that every cartesian closed category that satisfies an equality between arrows not satisfied in free cartesian closed categories must be a preorder. A new proof is given here ..."
Abstract

Cited by 18 (1 self)
 Add to MetaCart
From the analogue of Böhm’s Theorem proved for the typed lambda calculus, without product types and with them, it is inferred that every cartesian closed category that satisfies an equality between arrows not satisfied in free cartesian closed categories must be a preorder. A new proof is given here of these results, which were obtained previously by Richard Statman and Alex K. Simpson.
Memoization in typedirected partial evaluation
 PROCEEDINGS OF THE 2002 ACM SIGPLAN/SIGSOFT CONFERENCE ON GENERATIVE PROGRAMMING AND COMPONENT ENGINEERING, NUMBER 2487 IN LECTURE NOTES IN COMPUTER SCIENCE
, 2002
"... We use a code generator—typedirected partial evaluation— to verify conversions between isomorphic types, or more precisely to verify that a composite function is the identity function at some complicated type. A typed functional language such as ML provides a natural support to express the function ..."
Abstract

Cited by 14 (6 self)
 Add to MetaCart
We use a code generator—typedirected partial evaluation— to verify conversions between isomorphic types, or more precisely to verify that a composite function is the identity function at some complicated type. A typed functional language such as ML provides a natural support to express the functions and typedirected partial evaluation provides a convenient setting to obtain the normal form of their composition. However, offtheshelf typedirected partial evaluation turns out to yield gigantic normal forms. We identify that this gigantism is due to redundancies, and that these redundancies originate in the handling of sums, which uses delimited continuations. We successfully eliminate these redundancies by extending typedirected partial evaluation with memoization capabilities. The result only works for pure functional programs, but it provides an unexpected use of code generation and it yields ordersofmagnitude improvements both in time and in space for type isomorphisms.
Efficient Type Matching
, 2001
"... Palsberg and Zhao [14] presented an O(n²) time algorithm for matching two recursive types. In this paper, we present an O(n log n) algorithm for the same problem. Our algorithm works by reducing the type matching problem to the wellunderstood problem of finding a sizestable partition of a graph. ..."
Abstract

Cited by 10 (3 self)
 Add to MetaCart
Palsberg and Zhao [14] presented an O(n²) time algorithm for matching two recursive types. In this paper, we present an O(n log n) algorithm for the same problem. Our algorithm works by reducing the type matching problem to the wellunderstood problem of finding a sizestable partition of a graph. Our result may help improve systems, such as Polyspin and Mockingbird, that are designed to facilitate interoperability of software components. We also discuss possible applications of our algorithm to Java. Issues related to subtyping of recursive types are also discussed.
A labelselective lambdacalculus with optional arguments and its compilation method
 RIMS Preprint 1041, Research Instit. for Mathematical Sciences, Kyoto Univ
, 1995
"... The use of labels for argument passing has proved to be a useful extension to programming languages, particularly when we introduce optional arguments. We propose here an adaptation of such a system, as can be found in Common LISP, to stronglytyped curried functional languages. For this we extend M ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
The use of labels for argument passing has proved to be a useful extension to programming languages, particularly when we introduce optional arguments. We propose here an adaptation of such a system, as can be found in Common LISP, to stronglytyped curried functional languages. For this we extend MLstyle polymorphic typing to labeled arguments, outoforder application, and optional arguments. We also provide a compilation method towards polymorphic lambdacalculus, which is proved syntactically sound for free reduction, and semantically correct for callbyname semantics. We implemented it, and showed the overhead caused by using this extension to be negligible when outoforder parameter passing is used, and null when it is not. Topics: language design, compilation methods, type theory. 1
Subtyping Recursive Types modulo Associative Commutative Products
 Seventh International Conference on Typed Lambda Calculi and Applications (TLCA ’05
, 2003
"... We study subtyping of recursive types in the presence of associative and commutative productsthat is, subtyping modulo a restricted form of type isomorphisms. We show that this relation, which we claim is useful in practice, is a composition of the usual subtyping relation with the recently propo ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
We study subtyping of recursive types in the presence of associative and commutative productsthat is, subtyping modulo a restricted form of type isomorphisms. We show that this relation, which we claim is useful in practice, is a composition of the usual subtyping relation with the recently proposed notion of equality up to associativity and commutativity of products, and we propose an efficient decision algorithm for it. We also provide an automatic way of constructing coercions between related types.
Keeping sums under control
, 2004
"... In a recent paper [31], I presented with Marcelo Fiore and Roberto Di Cosmo a new normalisation tool for the λcalculus with sum types, based on the technique of normalisation by evaluation, and more precisely on techniques developped by Olivier Danvy for partial evaluation, using control operators. ..."
Abstract
 Add to MetaCart
In a recent paper [31], I presented with Marcelo Fiore and Roberto Di Cosmo a new normalisation tool for the λcalculus with sum types, based on the technique of normalisation by evaluation, and more precisely on techniques developped by Olivier Danvy for partial evaluation, using control operators. The main characteristic of this tool is that it produces a result in a canonical form we introduced. That is to say: two βηequivalent terms will be normalised into (almost) identical terms. It was not the case with the traditional algorithm, which could even lead to an explosion of the size of code. This canonical form is an ηlong βnormal form with constraints, which capture the definition of ηlong normal form for the λcalculus without sums, and reduces drastically the ηconversion possibilities for sums. The present paper recall the definition of these normal forms and the normalisation algorithm, and shows how it is possible to use these tools to solve a problem of characterization of type isomorphisms. Indeed, the canonical form allowed to find the complicated counterexamples we exhibited in another work [6], that proves that type isomorphisms in the λcalculus with sums are not finitely axiomatisable. What’s more, when proving that these terms are isomorphisms, the new partial evaluation algorithm avoids an explosion of the size of the term that arises with the old one.
Cn(log 2 (n)).
, 1996
"... is permitted for educational or research use on condition that this copyright notice is included in any copy. See back inner page for a list of recent publications in the BRICS Report Series. Copies may be obtained by contacting: BRICS ..."
Abstract
 Add to MetaCart
is permitted for educational or research use on condition that this copyright notice is included in any copy. See back inner page for a list of recent publications in the BRICS Report Series. Copies may be obtained by contacting: BRICS
Pidgin: Types for safe and natural multilanguage interoperation Qualifying Exam Research Report, May 2008
"... Bridging code between different languages usually requires the use of foreign function interfaces (FFIs). While FFIs and tools that generate bindings between different peering languages exist, using them often produces code that remains lowlevel, unsafe, and unnatural. This paper presents Pidgin, a ..."
Abstract
 Add to MetaCart
Bridging code between different languages usually requires the use of foreign function interfaces (FFIs). While FFIs and tools that generate bindings between different peering languages exist, using them often produces code that remains lowlevel, unsafe, and unnatural. This paper presents Pidgin, a formal language with unifying type system that allows us to model and reason about interoperability between multiple interoperating programming languages. This language extends the simply typed λ calculus with language contexts, a foreign embed term, opaque foreign value packing and unpacking terms, and handle types. We then prove its soundness. We then present a sketch of a tool based upon the Pidgin language. It generates typesafe glue code using existing parts of the Java and OCaml FFIs. We focus on creating safe, highlevel, and natural interfaces that need only rely upon the target language’s native typechecker. 1.
Non determinism through type isomorphism
"... We define an equivalence relation on propositions and a proof system where equivalent propositions have the same proofs. The system obtained this way resembles several known nondeterministic and algebraic lambdacalculi. 1 ..."
Abstract
 Add to MetaCart
We define an equivalence relation on propositions and a proof system where equivalent propositions have the same proofs. The system obtained this way resembles several known nondeterministic and algebraic lambdacalculi. 1
DOI: 10.1017/S0960129508006816 AN INSERTION OPERATOR PRESERVING INFINITE REDUCTION SEQUENCES
, 2013
"... ABSTRACT. A common way to show the termination of the union of two abstract reduction systems, provided both systems terminate, is to prove they enjoy a specific property (some sort of “commutation ” for instance). This specific property is actually used to show that, for the union not to terminate, ..."
Abstract
 Add to MetaCart
ABSTRACT. A common way to show the termination of the union of two abstract reduction systems, provided both systems terminate, is to prove they enjoy a specific property (some sort of “commutation ” for instance). This specific property is actually used to show that, for the union not to terminate, one out of both systems must itself be nonterminating, which leads to a contradiction. Unfortunately, the property may be impossible to prove because some of the objects that are reduced do not enjoy an adequate form. The purpose of this article is then threefold. It first introduces an operator enabling to insert a reduction step on such an object, and therefore to change its shape, while still preserving the ability to use the property. Of course, some new properties should be verified. Secondly, as an instance of our technique, the operator is applied to relax a wellknown lemma stating the termination of the union of two termination abstract reduction systems. Finally, this last lemma is applied in a peculiar and in a more general way to show the termination of some lambdacalculi with inductive types augmented with specific reductions dealing with: (1) copies of inductive types; and (2) with the representation of symmetric groups. 1.