Call-by-Need, Neededness and All That

One of the fundamental notions underlying this paper is the one of needed reduction in \(\lambda \)-calculus, which is to be used here to understand (lazy) evaluation of functional programs. Key notions are those of reducible and non-reducible programs: the former are programs (represented by \(\lambda \)-terms) containing non-evaluated subprograms, called reducible expressions (redexes), whereas the latter can be seen as definitive results of computations, called normal forms. It turns out that every reducible program contains a special kind of redex known as needed or, in other words, every \(\lambda \)-term not in normal form contains a needed redex. A redex \(\mathsf {r}\) is said to be needed in a \(\lambda \)-term t if \(\mathsf {r}\) has to be contracted (i.e. evaluated) sooner or later when reducing t to normal form, or, informally said, if there is no way of avoiding \(\mathsf {r}\) to reach a normal form.

The needed strategy, which always contracts a needed redex, is normalising [8], i.e. if a term can be reduced (in any way) to a normal form, then contraction of needed redexes necessarily terminates. This is an excellent starting point to design an evaluation strategy, but unfortunately, neededness of a redex is not decidable [8]. As a consequence, real implementations of functional languages cannot be directly based on this notion.

Our goal is, however, to establish a clear connection between the semantical notion of neededness and different implementations of lazy functional languages (e.g. Miranda or Haskell). Such implementations are based on call-by-need calculi, pioneered by Wadsworth [20], and extensively studied e.g. in [3]. Indeed, call-by-need calculi fill the gap between the well-known operational semantics of the call-by-name \(\lambda \)-calculus and the actual implementations of lazy functional languages. While call-by-name re-evaluates an argument each time it is used –an operation which is quite expensive– call-by-need can be seen as a memoized version of call-by-name, where the value of an argument is stored the first time it is evaluated for subsequent uses. For example, if , where and , then call-by-name duplicates the argument , while lazy languages first reduce to the value I so that further uses of this argument do not need to evaluate it again.

While the notion of needed reduction is defined with respect to (full strong) normal forms, call-by-need calculi evaluate programs to special values called weak-head normal forms, which are either abstractions or arbitrary applications headed by a variable (i.e. terms of the form where \(t_1 \ldots t_n\) are arbitrary terms). To overcome this shortfall, we first adapt the notion of needed redex to terms that are not going to be fully reduced to normal forms but only to weak-head normal forms. Thus, informally, a redex \(\mathsf {r}\) is weak-head needed in a term t if \(\mathsf {r}\) has to be contracted sooner or later when reducing t to a weak-head normal form. The derived notion of strategy is called a weak-head needed strategy, which always contracts a weak-head needed redex.

This paper introduces two independent results about weak-head neededness, both obtained by means of (non-idempotent) intersection types [12, 13] (a survey can be found in [9]). We consider, in particular, typing system \(\mathcal {V}\) [14] and show that it allows to identify all the weak-head needed redexes of a weak-head normalising term. This is done by adapting the classical notion of principal type [17] and proving that a redex in a weak-head normalising term t is weak-head needed iff it is typed in a principally typed derivation for t in \(\mathcal {V}\).

Our second goal is to show observational equivalence between call-by-need and weak-head needed reduction. Two terms are observationally equivalent when all the empirically testable computations on them are identical. This means that a term t can be evaluated to a weak-head normal form using the call-by-need machinery if and only if the weak-head needed reduction normalises t.

By means of system \(\mathcal {V}\) mentioned so far we use a technique to reason about observational equivalence that is flexible, general and easy to verify or even certify. Indeed, system \(\mathcal {V}\) provides a semantic argument: first showing that a term t is typable in system \(\mathcal {V}\) iff it is normalising for the weak-head needed strategy (\(t \in \mathcal {W\!N}_{\mathtt {whnd}}\)), then by resorting to some results in [14], showing that system \(\mathcal {V}\) is complete for call-by-name, i.e. a term t is typable in system \(\mathcal {V}\) iff t is normalising for call-by-name (\(t \in \mathcal {W\!N}_{\mathtt {name}}\)); and that t is normalising for call-by-name iff t is normalising for call-by-need (\(t \in \mathcal {W\!N}_{\mathtt {need}}\)). Thus completing the following chain of equivalences:

This leads to the observational equivalence between call-by-need, call-by-name and weak-head needed reduction.

Structure of the paper: Sect. 2 introduces preliminary concepts while Sect. 3 defines different notions of needed reduction. The type system \(\mathcal {V}\) is studied in Sect. 4. Section 5 extends \(\beta \)-reduction to derivation trees. We show in Sect. 6 how system \(\mathcal {V}\) identifies weak-head needed redexes, while Sect. 7 gives a characterisation of normalisation for the weak-head needed reduction. Sect. 8 is devoted to define call-by-need. Finally, Sect. 9 presents the observational equivalence result.

This section introduces some standard definitions and notions concerning the reduction strategies studied in this paper, that is, call-by-name, head and weak-head reduction, and neededness, this later notion being based on the theory of residuals [7].

Needed reduction is based on two fundamental notions: that of residual, which describes how a given redex is traced all along a reduction sequence, and that of normal form, which gives the form of the expected result of the reduction sequence. This section extends the standard notion of needed reduction [8] to those of head and weak-head needed reductions.

In this section we recall the (non-idempotent) intersection type system \(\mathcal {V}\) [14] –an extension of those in [12, 13]– used here to characterise normalising terms w.r.t. the weak-head strategy. More precisely, we show that t is typable in system \(\mathcal {V}\) if and only if t is normalising when only weak-head needed redexes are contracted. This characterisation is used in Sect. 9 to conclude that the weak-head needed strategy is observationally equivalent to the call-by-need calculus (to be introduced in Sect. 8).

Given a constant type \(\mathtt {a}\) that denotes answers and a countable infinite set \(\mathcal {B}\) of base type variables \(\alpha , \beta , \gamma , \ldots \), we define the following sets of types:

The empty multiset is denoted by \(\{\!\!\{{}\}\!\!\}_{}\). We remark that types are strict [18], i.e. the right-hand sides of functional types are never multisets. Thus, the general form of a type is \({\mathcal {M}_1}\rightarrow {{\ldots }\rightarrow {{\mathcal {M}_n}\rightarrow {\tau }}}\) with \(\tau \) being the constant type or a base type variable.

Typing contexts (or just contexts), written \(\varGamma , \varDelta \), are functions from variables to multiset types, assigning the empty multiset to all but a finite set of variables. The domain of \(\varGamma \) is given by . The union of contexts, written \({\varGamma }\mathrel {+_{}}{\varDelta }\), is defined by , where \(\sqcup \) denotes multiset union. An example is \((x:\{\!\!\{{\sigma }\}\!\!\}_{}, y:\{\!\!\{{\tau }\}\!\!\}_{}) + (x:\{\!\!\{{\sigma }\}\!\!\}_{}, z:\{\!\!\{{\tau }\}\!\!\}_{}) = (x:\{\!\!\{{\sigma , \sigma }\}\!\!\}_{}, y:\{\!\!\{{\tau }\}\!\!\}_{}, z:\{\!\!\{{\tau }\}\!\!\}_{})\). This notion is extended to several contexts as expected, so that \(+_{i \in I} \varGamma _i\) denotes a finite union of contexts (when \(I = \varnothing \) the notation is to be understood as the empty context). We write \({\varGamma }\mathrel {\setminus \!\!\setminus _{}}{x}\) for the context \(({\varGamma }\mathrel {\setminus \!\!\setminus _{}}{x})(x) = \{\!\!\{{}\}\!\!\}_{}\) and \(({\varGamma }\mathrel {\setminus \!\!\setminus _{}}{x})(y) = \varGamma (y)\) if \(y \ne x\).

Type judgements have the form \({\varGamma }\vdash {{t}:{\tau }}\), where \(\varGamma \) is a typing context, t is a term and \(\tau \) is a type. The intersection type system \(\mathcal {V}\) for the \(\lambda \)-calculus is given in Fig. 1.

The constant type \(\mathtt {a}\) in rule \(\mathtt {({val})}\) is used to type values. The axiom \(\mathtt {({ax})}\) is relevant (there is no weakening) and the rule \(\mathtt {({{\!}\rightarrow {\!}e})}\) is multiplicative. Note that the argument of an application is typed \(\#(I)\) times by the premises of rule \(\mathtt {({{\!}\rightarrow {\!}e})}\). A particular case is when \(I = \varnothing \): the subterm u occurring in the typed term turns out to be untyped.

A (type) derivation is a tree obtained by applying the (inductive) typing rules of system \(\mathcal {V}\). The notation \({}\rhd _{\mathcal {V}}{{\varGamma }\vdash {{t}:{\tau }}}\) means there is a derivation of the judgement \({\varGamma }\vdash {{t}:{\tau }}\) in system \(\mathcal {V}\). The term t is typable in system \(\mathcal {V}\), or \(\mathcal {V}\)-typable, iff t is the subject of some derivation, i.e. iff there are \(\varGamma \) and \(\tau \) such that \({}\rhd _{\mathcal {V}}{{\varGamma }\vdash {{t}:{\tau }}}\). We use the capital Greek letters \(\varPhi , \varPsi , \ldots \) to name type derivations, by writing for example \({\varPhi }\rhd _{\mathcal {V}}{{\varGamma }\vdash {{t}:{\tau }}}\). For short, we usually denote with \(\varPhi _{t}\) a derivation with subject t for some type and context. The size of the derivation \(\varPhi \), denoted by \(\mathtt {sz}({\varPhi })\), is defined as the number of nodes of the corresponding derivation tree. We write \(\mathtt {RULE}({\varPhi }) \in \{{\mathtt {({ax})}, \mathtt {({{\!}\rightarrow {\!}i})}, \mathtt {({{\!}\rightarrow {\!}e})}}\}\) to access the last rule applied in the derivation \(\varPhi \). Likewise, \(\mathtt {PREM}({\varPhi })\) is the multiset of proper maximal subderivations of \(\varPhi \). For instance, givenwe have \(\mathtt {RULE}({\varPhi }) = \mathtt {({{\!}\rightarrow {\!}e})}\) and \(\mathtt {PREM}({\varPhi }) = \{\!\!\{{\varPhi _{t}}\}\!\!\} \sqcup \{\!\!\{{\varPhi _{u}^{i} \mid i \in I}\}\!\!\}\). We also use functions \(\mathtt {CTXT}({\varPhi })\), \(\mathtt {SUBJ}({\varPhi })\) and \(\mathtt {TYPE}({\varPhi })\) to access the context, subject and type of the judgement in the root of the derivation tree respectively. For short, we also use notation \(\varPhi (x)\) to denote the type associated to the variable x in the typing environment of the conclusion of \(\varPhi \) (i.e.  ).

Intersection type systems can usually be seen as models [11], i.e. typing is stable by convertibility: if t is typable and \(t =_{\beta } t'\), then \(t'\) is typable too. This property splits in two different statements known as subject reduction and subject expansion respectively, the first one giving stability of typing by reduction, the second one by expansion. In the particular case of non-idempotent types, subject reduction refines to weighted subject-reduction, stating that not only typability is stable by reduction, but also that the size of type derivations is decreasing. Moreover, this decrease is strict when reduction is performed on special occurrences of redexes, called typed occurrences. We now introduce all these concepts.

Given a type derivation \(\varPhi \), the set \(\mathtt {TOC}({\varPhi })\) of typed occurrences of \(\varPhi \), which is a subset of \(\mathtt {oc}({\mathtt {SUBJ}({\varPhi })})\), is defined by induction on the last rule of \(\varPhi \).

Remark that there are two kind of untyped occurrences, those inside untyped arguments of applications, and those inside untyped bodies of abstractions. For instance consider the following type derivations:

Then, \(\mathtt {TOC}({\varPhi _{KI\varOmega }}) = \{{\epsilon , \mathsf {0}, \mathsf {00}, \mathsf {01}, \mathsf {000},\mathsf {0000}}\} \subseteq \mathtt {oc}({KI\varOmega })\).

Given \(\varPhi \) and \(\mathsf {p} \in \mathtt {TOC}({\varPhi })\), we define \({\varPhi }|_{\mathsf {p}}\) as the multiset of all the subderivations of \(\varPhi \) at occurrence \(\mathsf {p}\) (a formal definition can be found in [15]). Note that \({\varPhi }|_{\mathsf {p}}\) is a multiset since the subterm of \(\mathtt {SUBJ}({\varPhi })\) at position \(\mathsf {p}\) may be typed several times in \(\varPhi \), due to rule \(\mathtt {({{\!}\rightarrow {\!}e})}\).

We can now state the two main properties of system \(\mathcal {V}\), whose proofs can be found in Sect. 7 of [9].

Note that weighted subject reduction implies that reduction of typed redex occurrences turns out to be normalising.

In order to relate typed redex occurrences of convertible terms, we now extend the notion of \(\beta \)-reduction to derivation trees, by making use of a natural and basic concept of typed substitution. In contrast to substitution and \(\beta \)-reduction on terms, these operations are now both non-deterministic on derivation trees (see [19] for discussions and examples). Given a variable x and type derivations \(\varPhi _{t}\) and \(({\varPhi _{u}^{i}})_{i \in I}\), the typed substitution of x by \(({\varPhi _{u}^{i}})_{i \in I}\) in \(\varPhi _{t}\), written by making an abuse of notation, is a type derivation inductively defined on \(\varPhi _{t}\), only if \(\varPhi _{t}(x) = \{\!\!\{{\mathtt {TYPE}({\varPhi _{u}^{i}})}\}\!\!\}_{i \in I}\). This non-deterministic construction may be non-trivial but it can be naturally formalised in a quite straightforward way (full details can be found in [15]). Intuitively, the typed substitution replaces typed occurrences of x in \(\varPhi _t\) by a corresponding derivation \(\varPhi _u^i\) matching the same type, where such a matching is chosen in a non-deterministic way. Moreover, it also substitutes all untyped occurrences of x by u, where this untyped operation is completely deterministic. Thus, for example, consider the following substitution, where \(\varPhi _{KI}\) is defined in Sect. 4:

The following lemma relates the typed occurrences of the trees composing a substitution and those of the substituted tree itself:

Based on the previous notion of substitutions on derivations, we are now able to introduce (non-deterministic) reduction on derivation trees. The reduction relation \(\mathrel {\rightarrow _{\beta }}\) on derivation trees is then defined by first considering the following basic rewriting rules.

As in the case of the \(\lambda \)-calculus, where reduction is closed under usual term contexts, we need to close the previous relation under derivation tree contexts. However, a one-step reduction on a given subterm causes many one-step reductions in the corresponding derivation tree (recall \({\varPhi }|_{\mathsf {p}}\) is defined to be a multiset). Then, informally, given a redex occurrence \(\mathsf {r}\) of t, a type derivation \(\varPhi \) of t, and the multiset of minimal subderivations of \(\varPhi \) containing \(\mathsf {r}\), written \(\mathscr {M}\), we apply the reduction rules \(\mathrel {\mapsto _{\beta ,\nu ,\xi }}\) to all the elements of \(\mathscr {M}\), thus obtaining a multiset \(\mathscr {M'}\), and we recompose the type derivation of the reduct of t (see [15] for a formal definition). This gives the reduction relation \(\mathrel {\rightarrow _{\beta }}\) on trees. A reduction sequence on derivation trees contracting only redexes in typed positions is dubbed a typed reduction sequence.

Note that typed reductions are normalising by Theorem 2, yielding a special kind of derivation. Indeed, given a type derivation \({\varPhi }\rhd _{\mathcal {V}}{{\varGamma }\vdash {{t}:{\tau }}}\), we say that \(\varPhi \) is normal iff \(\mathtt {TOC}({\varPhi }) \cap \mathtt {r}\mathtt {oc}({t}) = \varnothing \). Reduction on trees induces reduction on terms: when \({\rho }:{\varPhi }\mathrel {\twoheadrightarrow _{\beta }}{\varPhi '}\), then \(\mathtt {SUBJ}({\varPhi }) \mathrel {\twoheadrightarrow _{\beta }} \mathtt {SUBJ}({\varPhi '})\). By abuse of notation we may denote both sequences with the same letter \(\rho \).

This section presents one of our main results. It establishes a connection between weak-head needed redexes and typed redex occurrences. More precisely, we first show in Sect. 6.1 that every weak-head needed redex occurrence turns out to be a typed occurrence, whatever its type derivation is. The converse does not however hold. But, we show in Sect. 6.2 that any typed occurrence in a special kind of typed derivation (that we call principal) corresponds to a weak-head needed redex occurrence. We start with a technical lemma.

This section presents one of the main pieces contributing to our observational equivalence result. Indeed, we relate typing with weak-head neededness by showing that any typable term in system \(\mathcal {V}\) is normalising for weak-head needed reduction. This characterisation highlights the power of intersection types. We start by a technical lemma.

Let \({\rho }:{t_1}\mathrel {\twoheadrightarrow _{\beta }}{t_n}\). We say that \(\rho \) is a left-to-right reduction sequence iff for every \(i < n\) if \({\mathsf {r_i}}:{t_i}\mathrel {\rightarrow _{\beta }}{t_{i+1}}\) and \(\mathsf {l_i}\) is to the left of \(\mathsf {r_i}\) then, for every \(j > i\) such that \({\mathsf {r_j}}:{t_j}\mathrel {\rightarrow _{\beta }}{t_{j+1}}\) we have that \(\mathsf {r_j} \notin {\{{\mathsf {l_i}}\}}/{\rho _{ij}}\) where \({\rho _{ij}}:{t_i}\mathrel {\twoheadrightarrow _{\beta }}{t_j}\) is the corresponding subsequence of \(\rho \). In other words, for every j and every \(i < j\), \(\mathsf {r_j}\) is not a residual of a redex to the left of \(\mathsf {r_i}\) (relative to the given reduction subsequence from \(t_i\) to \(t_j\)) [7].

Left-to-right reductions define in particular standard strategies, which give canonical ways to construct reduction sequences from one term to another:

This section describes the syntax and the operational semantics of the call-by-need lambda-calculus introduced in [1]. It is more concise than previous specifications of call-by-need [2, 3, 10, 16], but it is operationally equivalent to them [6], so that our results could also be presented by using alternative specifications.

Given a countable infinite set \(\mathcal {X}\) of variables \(x, y, z, \ldots \) we define different syntactic categories for terms, values, list contexts, answers and need contexts:

We denote the set of terms by \(\mathcal {T}_{\mathtt {e}}\). Terms of the form \({t}[{x}\backslash {u}]\) are closures, and \([{x}\backslash {u}]\) is called an explicit substitution (ES). The set of \(\mathcal {T}_{\mathtt {e}}\)-terms without ES is the set of terms of the \(\lambda \)-calculus, i.e.  \(\mathcal {T}_{\mathtt {a}}\). The notions of free and bound variables are defined as expected, in particular, , , and . We extend the standard notion of \(\alpha \)-conversion to ES, as expected.

We use the special notation \({\mathtt {N}}\langle \langle {u}\rangle \rangle \) or \({\mathtt {L}}\langle \langle {u}\rangle \rangle \) when the free variables of u are not captured by the context, i.e. there are no abstractions or explicit substitutions in the context that binds the free variables of u. Thus for example, given , we have , but cannot be written as \({\mathtt {N}}\langle \langle {x}\rangle \rangle \). Notice the use of this special notation in the last case of needed contexts, an example of such case being

The call-by-need calculus, introduced in [1], is given by the set of terms \(\mathcal {T}_{\mathtt {e}}\) and the reduction relation \(\mathrel {\rightarrow _{\mathtt {need}}}\), the union of \(\mathrel {\rightarrow _{\mathtt {dB}}}\) and \(\mathrel {\rightarrow _{\mathtt {lsv}}}\), which are, respectively, the closure by need contexts of the following rewriting rules:These rules avoid capture of free variables. An example of \(\mathtt {need}\)-reduction sequence is the following, where the redex of each step is underlined for clearness:As for call-by-name, reduction preserves free variables, i.e.  \(t \mathrel {\rightarrow _{\mathtt {need}}} t'\) implies \(\mathtt {fv}({t}) \supseteq \mathtt {fv}({t'})\). Notice that call-by-need reduction is also weak, so that answers are not \(\mathtt {need}\)-reducible.

The results in Sect. 7 are used here to prove soundness and completeness of call-by-need w.r.t weak-head neededness, our second main result. More precisely, a call-by-need interpreter stops in a value if and only if the weak-head needed reduction stops in a value. This means that call-by-need and call-by-name are observationally equivalent.

Formally, given a reduction relation \(\mathcal {R}\) on a term language \(\mathcal {T}\), and an associated notion of context for \(\mathcal {T}\), we define t to be observationally equivalent to u, written \(t \cong _{\mathcal {R}} u\), iff \({\mathtt {C}}\langle {t}\rangle \in \mathcal {W\!N}_{\mathcal {R}} \Leftrightarrow {\mathtt {C}}\langle {u}\rangle \in \mathcal {W\!N}_{\mathcal {R}}\) for every context \(\mathtt {C}\). In order to show our final result we resort to the following theorem:

These observations allows us to conclude:

We establish a clear connection between the semantical standard notion of neededness and the syntactical concept of call-by-need. The use of non-idempotent types –a powerful technique being able to characterise different operational properties– provides a simple and natural tool to show observational equivalence between these two notions. We refer the reader to [5] for other proof techniques (not based on intersection types) used to connect semantical notions of neededness with syntactical notions of lazy evaluation.

An interesting (and not difficult) extension of our result in Sect. 6 is that call-by-need reduction (defined on \(\lambda \)-terms with explicit substitutions) contracts only \(\mathtt {dB}\) weak-head needed redexes, for an appropriate (and very natural) notion of weak-head needed redex for \(\lambda \)-terms with explicit substitutions. A technical tool to obtain such a result would be the type system \(\mathcal {A}\) [14], a straightforward adaptation of system \(\mathcal {V}\) to call-by-need syntax.

Given the recent formulation of strong call-by-need [6] describing a deterministic call-by-need strategy to normal form (instead of weak-head normal form), it would be natural to extend our technique to obtain an observational equivalence result between the standard notion of needed reduction (to full normal forms) and the strong call-by-need strategy. This remains as future work.