Bohm Tree for the Lazy Lambda Calculus with Constants

1994

Abstract: In this paper we define the Lazy Lambda Calculus with constants, which extends Abramsky's pure lazy Lambda Calculus. This calculus forms a model for modern lazy functional programming languages. Such languages usually provide a call-by-value facility which is able to distinguish between the values _| _ and\ x. _| _. We study the operational and denotational semantics of this calculus both with and without a superimposed type inference system.

Theoretical Computer Science, 1989

A denotationaf semantics for the A-calculus is described. The semantics is cotinuationbased, and so reflects the order in which expressions are evaluated. It provides a means by which lazy functional languages can be better understood.

Science of Computer Programming, 1995

In this paper we present a new programming technique for lazy functional programming languages. The technique is embedded in a programming methodology which is based on divide and conquer: the division of problems into subproblems. Such a division will be represented by a call graph.

The intensional transformation is a promising technique for implementing lazy functional languages based on a demand-driven execution model. Despite its theoretical elegance and its simple and efficient execution model, the intensional transformation suffered, until now, from two main drawbacks: (a) it could only be applied to programs that manipulate primitive data-types, and (b) it could only compile a simple (and rather restricted) class of higher-order functions. In this paper we remedy the above two deficiencies, obtaining a transformation algorithm that is applicable to mainstream lazy functional languages. The proposed transformation initially uses defunctionalization in order to eliminate higher-order functions from the source program. The resulting first-order program is then transformed into a program in a simple tuple-based language. Finally, the original intensional transformation is extended in order to be applicable to the tuple language. The correctness of the generalized transformation is formally established. It is demonstrated that the proposed technique can be used to compile a relatively large subset of Haskell into portable C code whose performance is comparable to existing mainstream implementations.

1995

Abstract We define a category of games 𝒢, and its extensional quotient ℰ. A model of the lazy X-calculus, a type-free functional language based on evaluation to weak head normal form, is given in 𝒢, yielding an extensional model in ℰ. This model is shown to be fully abstract with respect to applicative simulation. This is, so fear as we known, the first purely semantic construction of a fully abstract model for a reflexively-typed sequential language

Logical Methods in Computer Science, 2010

The call-by-need lambda calculus provides an equational framework for reasoning syntactically about lazy evaluation. This paper examines its operational characteristics. By a series of reasoning steps, we systematically unpack the standard-order reduction relation of the calculus and discover a novel abstract machine definition which, like the calculus, goes "under lambdas." We prove that machine evaluation is equivalent to standard-order evaluation.

1995

We argue that Ariola and Felleisen's and Maraist, Odersky and Wadler's axiomatization of the call-by-need lambda calculus forms a suitable formal basis for tracing evaluation in lazy functional languages. In particular, it allows a one-dimensional textual representation of terms, rather than requiring a two-dimensional graphical representation using arrows. We describe a program LetTrace, implemented in Gofer and tracing lazy evaluation of a subset of Gofer.

2015

Into A-calculus we introduce lazy lsts $\tilde{a} $ whose naive meaning is an infinite tit consisting of variables, ($a_{0}, $ $a_{1} $ , a2, $\ldots$). It is shown that there exist maps which form aGalois connection ffom Parigot’s $\mathrm{A}/\mathrm{i}$-calculus to the A-calculus with lazy list. The translations form not only an equational correspondence but also areduction corre-spondence between the two calculi. 1Introduction We introduce lazy lists into A-calculus. The introduction of infinite lists is motived by a study on denotational semantics of type-free Ap-calculus [Pari92, Pari97, BHF99, BHFOI]. Given domains $U\mathrm{x}U\cong U\cong[Uarrow U] $ such as in Lambek-Scott [LS86], we have established acontinuation denotational semantics of type-free $\lambda\mu$-calculus[Fuji02], which formally coincides with the CPS-translation [HS97, SR98, FujiOl] followed by the direct denotational semantics of the A-calculus [ScOt72, StOy77]. See also the literature [HS97, SR98, SeliOl]...

2017

The evaluation strategies of programming languages can be broadly categorised as strict or lazy. A common approach to strict evaluation is to implement a call-by-value semantics that always evaluates expressions when they are bound to variables, while lazy evaluation is often implemented as call-by-need semantics that evaluates expressions when they are needed for some computation. Lazy semantics makes use of a data structure called thunk that contains an expression, whose evaluation has become suspended, together with its environment. This thesis presents (1) a Haskell definition of the existing semantics of CakeML, a strict programming language, (2) a Haskell definition of a lazy semantics for the pure part of CakeML, and (3) a Haskell implementation of a compiler that compiles lazy CakeML to strict CakeML as defined in (1) and (2). The compiler makes use of stateful features in strict CakeML to optimise evaluation so that each thunk is evaluated at most once, simulating a call-by...

Information Processing Letters, 2004

We bridge the gap between compositional evaluators and abstract machines for the lambda-calculus, using closure conversion, transformation into continuation-passing style, and defunctionalization of continuations. This article is a followup of our article at PPDP 2003, where we consider call by name and call by value. Here, however, we consider call by need.