On the value of variables

Programming Languages and Systems

Barras

2017

Self Cite

Abstract. The model behind functional programming languages is the closed λ-calculus, that is, the fragment of the λ-calculus where evaluation is weak (i.e. out of abstractions) and terms are closed. It is well-known that the number of β (i.e. evaluation) steps is a reasonable cost model in this setting, for all natural evaluation strategies (call-by-name / value / need). In this paper we try to close the gap between the closed λ-calculus and actual languages, by considering an extension of the λ-calculus with pattern matching. It is straightforward to prove that β plus matching steps provide a reasonable cost model. What we do then is finer: we show that β steps only, without matching steps, provide a reasonable cost model also in this extended setting-morally, pattern matching comes for free, complexity-wise. The result is proven for all evaluation strategies (name / value / need), and, while the proof itself is simple, the problem is shown to be subtle. In particular we show that qualitatively equivalent definitions of call-by-need may behave very differently.This work is part of a wider research effort, the COCA HOLA project [3].

Section: Introductionsupporting

confidence: 58%

“…Evaluation is right-to-left, and values include abstractions, error, and constructors applied recursively to values. In particular, variables are excluded from values as it is standard in the literature on abstract machines, see [14]. The language is thus defined by:…”

Section: Cbn Evaluation Contextsmentioning

confidence: 99%

The Negligible and Yet Subtle Cost of Pattern Matching

Programming Languages and Systems

Barras

2017

Self Cite

“…If variables can be substituted then the overhead becomes quadratic in |ρ| βthis is what happens in the GLAMOUr machine in [2]. The relationship between substituting variables and a linear/quadratic overhead is studied in-depth in [9]. Now, because the Fast GLAMOUr substitutes abstractions on-demand, variable occurrences that are not applied are not substituted by abstractions.…”

Section: Fast Glamourmentioning

confidence: 99%

Implementing Open Call-by-Value

Fundamentals of Software Engineering

Guerrieri

2017

Self Cite

The theory of the call-by-value λ-calculus relies on weak evaluation and closed terms, that are natural hypotheses in the study of programming languages. To model proof assistants, however, strong evaluation and open terms are required. Open call-by-value is the intermediate setting of weak evaluation with open terms, on top of which Grégoire and Leroy designed the abstract machine of Coq. This paper provides a theory of abstract machines for open call-by-value. The literature contains machines that are either simple but inefficient, as they have an exponential overhead, or efficient but heavy, as they rely on a labelling of environments and a technical optimization. We introduce a machine that is simple and efficient: it does not use labels and it implements open call-by-value within a bilinear overhead. Moreover, we provide a new fine understanding of how different optimizations impact on the complexity of the overhead.This work is part of a wider research effort, the COCA HOLA project https://sites.google.com/site/beniaminoaccattoli/coca-hola.

“…For more recent work, see Chang and Felleisen's [18], Danvy and Zerny's [22], Garcia, Lumsdaine, and Sabry's [26], Pédrot and Saurin's [36], or the already cited work on strong call-by-need [15]. As already pointed out, our treatment of call-by-need is based on Accattoli, Barenbaum, and Mazza's [4], plus Accattoli and Sacerdoti Coen's [11].…”

Section: Introductionmentioning

confidence: 99%

Environments and the complexity of abstract machines

Proceedings of the 19th International Symposium on Principles and Practice of Declarative Programming

Barras

2017

Self Cite

machines for functional languages rely on the notion of environment, a data structure storing the previously encountered and delayed beta-redexes. This paper provides a close analysis of the different approaches to define and implement environments. There are two main styles. The most common one is to have many local environments, one for every piece of code in the data structures of the machine. A minority of works instead uses a single global environment. Up to now, the two approaches have been considered equivalent, in particular at the level of the complexity of the overhead: they have both been used to obtain bilinear bounds, that is, linear in the number of beta steps and in the size of the initial term.We start by having a close look on global environments and how to implement them. Then we show that local environments admit implementations that are asymptotically faster than global environments, lowering the dependency from the size of the initial term from linear to logarithmic, thus improving the bounds in the literature. We then focus on a third style, split environments, that are in between local and global ones, and have the benefits of both. Finally, we provide a call-by-need machine with split environments for which we prove the new improved bounds on the overhead.Here we introduce the Milner Abstract Machine (MAM) [4,38], a machine with a single global environment for call-by-name evaluation.Machine components. The MAM is defined in Fig. 1. A machine state s is a triple (t, π , E) given by:• Code t: a term not considered up to α-equivalence, which is why it is over-lined;