Curry: An Integrated Functional Logic Language

Computation step for a single expression:
Eval [ei ] ⇒ D
Eval [e1 & e2 ] ⇒ replace(e1 & e2, i, D)
i ∈ {1, 2}
Eval [ei ] ⇒ D
Eval [c(e1, . . . , en)] ⇒ replace(c(e1, . . . , en), i, D)
Eval [f(e1, . . . , en); T ] ⇒ D
Eval [f(e1, . . . , en)] ⇒ D
i ∈ {1, . . . , n}
if T is a definitional tree for f with fresh variables
Computation step for an operation-rooted expression e:
Eval [e; rule(l = r)] ⇒ {id σ(r)}
Eval [e; T1 ] ⇒ D1 Eval [e; T2 ] ⇒ D2
Eval [e; or(T1, T2)] ⇒ D1 ∪ D2
if σ is a substitution with σ(l) = e
Eval [e; branch(π, p, r, T1, . . . , Tk)] ⇒
⎧
D if e|p = c(e1, . . . , en), pat(Ti)|p = c(x1, . . . , xn), and Eval [e; Ti ] ⇒ D
⎪⎨
∅ if e|p = c(· · ·) and pat(Ti)|p �= c(· · ·), i = 1, . . . , k
�k ⎪⎩ i=1 {σi σi(e)} if e|p = x, r = flex, and σi = {x ↦→ pat(Ti)|p}
replace(e, p, D) if e|p = f(e1, . . . , en) and Eval [e|p ] ⇒ D
Derivation step for a disjunctive expression:
Eval [e] ⇒ {σ1 e1, . . . , σn en}
{σ e} ∪ D ⇒ {σ1 ◦ σ e1, . . . , σn ◦ σ en} ∪ D
D.2 Computation Steps
Figure 2: Operational semantics of Curry
The operational semantics is defined by the derivability relation D1 ⇒ D2 on disjunctive expressions
specified in Figure 2. An inference rule α
should be read as “if α is derivable, then β is also
β
derivable”. We say that the computation of an expression e suspends if there is no D with Eval [e] ⇒
D. A constraint is solvable if it can be reduced to success. The exact method to solve constraints
depends on the constraint solver. A method to solve equational constraints on data terms is
specified in Section D.4. For the purpose of this definition, we consider success as the neutral
element of the operation &, i.e., success & c and c & success are considered as equivalent to c.
As can be seen by the rules for evaluating constraints in Figure 2, the concurrent conjunction
of two constraints is evaluated by applying computation steps to one of the two constraints. Since
both constraints must be finally solved (i.e., reduced to success), one can consider the evaluation
of a concurrent conjunction as two computation threads evaluating these constraints. They
are synchronized by accessing common variables (which may suspend a thread, see below). In a
simple sequential implementation, the evaluation of e1 & e2 could be started by an attempt to solve
e1. If the evaluation of e1 suspends, an evaluation step is applied to e2. If a variable responsible
66