Curry: An Integrated Functional Logic Language

Eval [try(g)] ⇒
⎧
[] if Eval [c] ⇒ ∅
⎪⎨
⎪⎩
[g ′ ] if Eval [c] ⇒ {σ success} (i.e., σ is a mgu for all equations in c) with
Dom(σ) ⊆ {x, x1, . . . , xn} (or c = success and σ = id) and
g ′ = \x->let x1, . . . , xn free in σ ◦ ϕ success
D if Eval [c] ⇒ {σ c ′ } with Dom(σ) ⊆ {x, x1, . . . , xn},
g ′ = \x->let x1, . . . , xn, y1, . . . , ym free in σ ◦ ϕ c ′
where {y1, . . . , ym} = VRan(σ) \ ({x, x1, . . . , xn} ∪ free(g)),
and Eval [try(g ′ )] ⇒ D
[g1,...,gk] if Eval [c] ⇒ {σ1 c1, . . . , σk ck}, k > 1, and, for i = 1, . . . , k,
Dom(σi) ⊆ {x, x1, . . . , xn} and
gi = \x->let x1, . . . , xn, y1, . . . , ymi free in σi ◦ ϕ ci
where {y1, . . . , ymi } = VRan(σi) \ ({x, x1, . . . , xn} ∪ free(g))
Figure 5: Operational semantics of the try operator for g = \x->let x1, . . . , xn free in ϕ c
It is easy to see that this algorithm computes a definitional tree for each function since the
number of rules is reduced in each recursive call and it keeps the invariant that the left-hand sides
of the current set of rules are always instances of the current call pattern.
Note that the algorithm gt is not strictly conform with the pattern matching strategy of functional
languages like Haskell or Miranda, since it generates for the rules
f 0 0 = 0
f x 1 = 0
the definitional tree
branch(f(x1,x2), 2, flex, branch(f(x1,0), 1, flex, rule(f(0,0) = 0)),
rule(f(x1,1) = 0))
(although both arguments are demanded, only the second argument is at an inductive position)
whereas Haskell or Miranda have a strict left-to-right pattern matching strategy which could be
expressed by the definitionl tree
or(branch(f(x1,x2), 1, flex, branch(f(0,x2), 2, flex, rule(f(0,0) = 0))),
branch(f(x1,x2), 2, flex, rule(f(x1,1) = 0)))
The latter tree is not optimal since it has a non-deterministic or node and always requires the
evaluation of the first argument (in the first alternative). If the function definitions are uniform in
the sense of [48], the strategy described by gt is identical to traditional functional languages.
D.7 Encapsulated Search
The exact behavior of the try operator is specified in Figure 5. Note that a substitution ϕ of the
form {x1 ↦→ t1, . . . , xn ↦→ tn}, computed by evaluating the body of a search goal, must be encoded as
a constraint in the new search goal. Therefore, ϕ is transformed into its equational representation
ϕ, where ϕ is a solved constraint of the form x1=:=t1 &...& xn=:=tn. Hence, a search goal can
72