Curry: An Integrated Functional Logic Language

to an expression):
Eval [ϕ(e1, . . . , em)@e] ⇒ ϕ(e1, . . . , em, e) if ϕ has arity n and m < n
Thus, we evaluate an application by simply adding the argument to a partial application. If
a function has the right number of arguments, it is evaluated by the rules in Figure 2. Note
that the function application is “rigid” in its first argument since the application suspends if the
applied function is unknown (instead of a possible but expensive non-deterministic search for the
appropriate function).
λ-abstractions occurring in expressions are anonymous functions and can be implemented by
assigning a new name to each λ-abstraction, where the free variables become parameters of the
function. For instance, the λ-abstraction (f is a free variable)
\x y -> f x y + 2
can be replaced by the (partial) application (lambda f), where lambda is a new name, and adding
the rule
lambda f x y = f x y + 2
Note that this transformation (as well as the extension of Eval [·] above) is only used to explain the
operational meaning of Curry’s higher-order features. A concrete Curry system is free to choose
other implementation techniques.
D.6 Generating Definitional Trees
Curry’s computation model is based on the specification of a definitional tree for each operation.
Although definitional trees are a high-level formalism to specify evaluation strategies, it is tedious
to annotate each operation which its definitional tree. Therefore, the user need not write them
explicitly in the program since they are automatically inserted by the Curry system. In the following,
we present Curry’s algorithm to generate definitional trees from the left-hand sides of the
functions’ rules.
The generation of definitional trees for each function is not straightforward, since there may
exist many non-isomorphic definitional trees for a single function representing different evaluation
strategies. This demands for a default strategy to generate definitional trees. Curry uses the
following default strategy:
1. The leftmost argument, where a constructor occurs at the corresponding position in all lefthand
sides defining this function, is evaluated to head normal form.
2. or nodes (i.e., disjunctions) are generated in case of a conflict between constructors and
variables in the left-hand sides, i.e., if two rules have a variable and a constructor at the same
position on the left-hand side.
In the following, we assume that all rules are unconditional (it is obvious how to extend it to
conditional rules since only the left-hand sides of the rules are relevant for the definitional trees).
To specify the construction algorithm, we define by
DP (π, R) = {o position of a variable in π | root(l|o) ∈ C for some l = r ∈ R}
70