Curry: An Integrated Functional Logic Language

the set of demanded positions of a call pattern π w.r.t. a set of rules R. For instance, the demanded
positions of the call pattern leq(x,y) w.r.t. the rules for the predicate leq (see Section 17, page 65)
are {1, 2} referring to the pattern variables x and y. Furthermore, we define by
IP (π, R) = {o ∈ DP (π, R) | root(l|o) ∈ C for all l = r ∈ R}
the set of inductive positions of a call pattern π w.r.t. a set of rules R. Thus, the inductive
positions are those demanded positions where a constructor occurs in all left-hand sides defining
this function. For instance, the set of inductive positions of the call pattern leq(x,y) w.r.t. the
rules for the predicate leq is {1}.
The generation of a definitional tree for a call pattern π and a set of rules R (where l is
an instance of π for each l = r ∈ R) is described by the function gt(π, m, R) (m ∈ {flex, rigid}
determines the mode annotation in the generated branch nodes). We distinguish the following
cases for gt:
1. If the position o is leftmost in IP (π, R), {root(l|o) | l = r ∈ R} = {c1, . . . , ck} where c1, . . . , ck
are different constructors with arities n1, . . . , nk, and Ri = {l = r ∈ R | root(l|o) = ci}, then
gt(π, m, R) = branch(π, o, m, gt(π[c1(x11, . . . , x1n1 )]o, m, R1),
. . . ,
gt(π[ck(xk1, . . . , xknk )]o, m, Rk))
where xij are fresh variables. I.e., we generate a branch node for the leftmost inductive
position (provided that there exists such a position).
2. If IP (π, R) = ∅, let o be the leftmost position in DP (π, R) and R ′ = {l = r ∈ R | root(l|o) ∈
C}. Then
gt(π, m, R) = or(gt(π, m, R ′ ), gt(π, m, R − R ′ ))
I.e., we generate an or node if the leftmost demanded position of the call pattern is not
demanded by the left-hand sides of all rules.
3. If DP (π, R) = ∅ and l = r variant of some rule in R with l = π, then
gt(π, m, R) = rule(l = r)
Note that all rules in R are variants of each other if there is no demanded position (this
follows from the weak orthogonality of the rewrite system). For non-weakly orthogonal rewrite
systems, which may occur in the presence of non-deterministic functions [18] or conditional
rules, the rules in R may not be variants. In this case we simply connect the different rules
by or nodes.
If R is the set of all rules defining the n-ary function f, then a definitional tree for f is generated by
computing gt(f(x1, . . . , xn), m, R), where m = rigid if the type of f has the form · · ·->IO ..., i.e.,
if f denotes an IO action, and m = flex otherwise (this default can be changed by the evaluation
annotation “eval rigid”, see Section 3).
71