In Part I [5], we proposed an approach to formally describe and compare functional languages implementations. We focused on call-by-value and described well-known compilers for strict languages. Here, we complete our exploration of the design space of implementations by studying call-by-name, call-by-need and graph reduction. We express the whole compilation process as a succession of program transformations in a common framework. At each step, different transformations model fundamental choices or optimizations. We describe and compare the diverse alternatives for the compilation of the call-byname strategy in both environment and graph-based models. The different options for the compilation of b-reduction described in [5] can be applied here as well. Instead, we describe other possibilities specific to graph reduction. Call-by-need is nothing but call-by-name with redex sharing and update. We present how sharing can be expressed in our framework and we describe different...

: We introduce a unified framework to describe, relate, compare and classify functional language implementations. The compilation process is expressed as a succession of program transformations in the common framework. At each step, different transformations model fundamental choices. A benefit of this approach is to structure and decompose the implementation process. The correctness proofs can be tackled independently for each step and amount to proving program transformations in the functional world. This approach also paves the way to formal comparisons by making it possible to estimate the complexity of individual transformations or compositions of them. Our study aims at covering the whole known design space of sequential functional languages implementations. In particular, we consider call-by-value, call-by-name and call-by-need reduction strategies as well as environment and graph-based implementations. We describe for each compilation step the diverse alternatives as program tr...

In [CZ96], we argue that a combinator (i.e., variable-free) query algebra simplifies correctness proofs and implementations of query optimizers. But combinators make for poor query languages, and therefore translations from standard query languages (such as OQL [Cat93]) into some combinator form is required. In this paper, we present our translator that maps queries written in a variant of OQL (OQLdeB) into KOLA [Che95a]; our combinator-based query algebra. We introduce a denotational semantics for OQLdeB and define KOLA using an operational semantics that rewrites KOLA queries into OQLdeB . We then proceed to show the correctness of our translator by showing that translation produces a KOLA query whose OQLdeB equivalent has the same semantics as the original query. The significance of our work lies in its implications for the design of efficient and simply formalized query optimizers. With respect to formalization, we have used the Larch [GHG + 92] specification tool LSL to formally...

Abstract: The Krivine machine is a simple and natural implementation of the normal weak-head reduction strategy for pure λ-terms. While its original description has remained unpublished, this machine has served as a basis for many variants, extensions and theoretical studies. In this paper, we present the Krivine machine and some well-known variants in a common framework. Our framework consists of a hierarchy of intermediate languages that are subsets of the λ-calculus. The whole implementation process (compiler + abstract machine) is described via a sequence of transformations all of which express an implementation choice. We characterize the essence of the Krivine machine and locate it in the design space of functional language implementations. We show that, even within the particular class of Krivine machines, hundreds of variants can be designed. Key-words: Krivine machine, abstract machines, program transformation, compilation, functional language implementations.

ion avec des environnements partags (As) As ncessite sept nouveaux combinateurs pour exprimer la sauvegarde et la restauration des environnements (dupl e , swap se ), la construction et l'ouverture des fermetures (mkclos, appclos), l'accs aux valeurs (fst, snd), et enfin l'ajout d'une fermeture l'environnement (bind). Ils sont dfinis dans L e par dupl e = l e e. push e e o push e e swap se = l s x. l e e. push s x o push e e mkclos = l s x. l e e. push s (x,e) appclos = l s (x,e). push e e o x fst = l e (e,x). push e e snd = l e (e,x). push s x bind = l e e. l s x. push e (e,x) Rmi Douence & Pascal Fradet La correction de As est exprime par la Proprit 4 (R est une fonction changeant la reprsentation des fermetures de (c, e) en push e e o c). Proprit 4 "E R [[ push e () o As [[ E]] ()]] = b E La transformation As peut tre optimise en ajoutant la rgle : As [[ l s x.E]] r = pop se o As [[ E]] r si x n'est pas libre dans E avec pop se = l e e. l s x. push e e Les variables son...

Query optimizers generate plans to retrieve data specified by queries. Query optimization for object databases (i.e., object-oriented and object-relational databases) is an immature field, and stands to benefit from adaptation of techniques that have proved useful for relations. One technique uses query-to-query transformations to rewrite queries into queries that are potentially more amenable to plan generation. For transformations to be useful, they must preserve the semantics of the queries they rewrite (correctness) and usually result in queries that generate better plans (effectiveness). Object databases complicate the expression of correct and effective transformations. Transformation correctness is problematic even for relational queries. Especially error-prone are transformations that rewrite complex nested queries (queries containing other queries) or queries that return duplicates. Objects make correctness more difficult because object queries can be far more compl...

Abstract. Bracket abstraction is an algorithm that transforms lambda expressions into combinator terms. There are several versions of this algorithm depending on the actual set of combinators that is used. Most of them have been proven correct with respect to the operational semantics. In this paper we focus on typability. We present a fully machine verified proof of the property that bracket abstraction preserves types; the types assigned to an expression before and after performing bracket abstraction are identical. To our knowledge, this is the first time that (1) such proof has been given, and (2) the proof is verified by a theorem prover. The theorem prover used in the development of the proof is PVS. 1

Abstract: The Krivine machine is a simple and natural implementation of the normal weak-head reduction strategy for pure λ-terms. While its original description has remained unpublished, this machine has served as a basis for many variants, extensions and theoretical studies. In this paper, we present the Krivine machine and some well-known variants in a common framework. Our framework consists of a hierarchy of intermediate languages that are subsets of the λ-calculus. The whole implementation process (compiler + abstract machine) is described via a sequence of transformations all of which express an implementation choice. We characterize the essence of the Krivine machine and locate it in the design space of functional language implementations. We show that, even within the particular class of Krivine machines, hundreds of variants can be designed. Key-words: Krivine machine, abstract machines, program transformation, compilation, functional language implementations.