Abstract. We use a code generator—type-directed 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 type-directed partial evaluation provides a convenient setting to obtain the normal form of their composition. However, off-the-shelf type-directed 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 type-directed 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 orders-of-magnitude improvements both in time and in space for type isomorphisms. 1

We study subtyping of recursive types in the presence of associative and commutative products---that 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.

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.

Fiore and Hur [18] recently introduced a novel methodology—henceforth referred to as Sol—for the Synthesis of equational and rewriting logics from mathematical models. In [18], Sol was successfully applied to rationally reconstruct the traditional equational logic for universal algebra of Birkhoff [3] and its multi-sorted version [26], and also to synthesise a new version of the Nominal Algebra of Gabbay and Mathijssen [41] and the Nominal Equational Logic of Clouston and Pitts [8] for reasoning about languages with name-binding operators. Based on these case studies and further preliminary investigations, we contend that Sol can make an impact in the problem of engineering logics for modern computational languages. For example, our proposed research on secondorder equational logic will provide foundations for designing a second-order extension of the Maude system [37], a first-order semantic and logical framework used in formal software engineering for specification and programming. Our research strategy can be visualised as follows: (I)