Curry: An Integrated Functional Logic Language

A single computation step performs a reduction in exactly one unsolved expression of a disjunction.
To provide a precise definition of the operational semantics, we use definitional trees. 18
A definitional tree is a hierarchical structure containing all rules of a defined function. T is a
definitional tree with call pattern π iff the depth of T is finite and one of the following cases holds:
T = rule(l = r), where l = r is a variant of a rule such that l = π.
T = branch(π, o, r, T1, . . . , Tk), where o is an occurrence of a variable in π, r ∈ {rigid, flex},
c1, . . . , ck are different constructors of the sort of π|o, for some k > 0, and, for all i = 1, . . . , k,
Ti is a definitional tree with call pattern π[ci(x1, . . . , xn)]o, where n is the arity of ci and
x1, . . . , xn are new variables.
T = or(T1, T2), where T1 and T2 are definitional trees with call pattern π. 19
A definitional tree of an n-ary function f is a definitional tree T with call pattern f(x1, . . . , xn),
where x1, . . . , xn are distinct variables, such that for each rule l = r with l = f(t1, . . . , tn) there is a
node rule(l ′ = r ′ ) in T with l variant of l ′ . In the following, we write pat(T ) for the call pattern of
a definitional tree T .
It is always possible to construct a definitional tree for each function (concrete algorithms are
described in [3, 33] and in Section D.6). For instance, consider the following definition of the
less-or-equal predicate on natural numbers represented by data terms built from z (zero) and s
(successor):
data Nat = z | s Nat
leq :: Nat -> Nat -> Bool
leq z n = True
leq (s m) z = False
leq (s m) (s n) = leq m n
Consider a function call like (leq e1 e2). In order to apply some reduction rule, the first argument
e1 must always be evaluated to head normal form (i.e., to an expression without a defined function
symbol at the top). However, the second argument must be evaluated only if the first argument
has the form (s e). 20 This dependency between the first and the second argument is expressed by
the definitional tree
branch(leq(x1, x2), 1, flex, rule(leq(z, x2) = True),
branch(leq(s(x), x2), 2, flex, rule(leq(s(x), z) = False),
rule(leq(s(x), s(y)) = leq(x, y))))
This definitional tree specifies that the first argument is initially evaluated and the second argument
is only evaluated if the first argument has the constructor s at the top. The precise operational
meaning induced by definitional trees is described in the following section.
18
Our notion is influenced by Antoy’s work [3], but here we use an extended form of definitional trees.
19
For the sake of simplicity, we consider only binary or nodes. The extension to such nodes with more than two
subtrees is straightforward.
20
Naive lazy narrowing strategies may also evaluate the second argument in any case. However, as shown in [6],
the consideration of dependencies between arguments is essential to obtain optimal evaluation strategies.
65