Curry: An Integrated Functional Logic Language

D Operational Semantics of Curry
The precise specification of the operational semantics of Curry is based on the evaluation annotation
and the patterns on the rules’ left-hand sides for each function. Therefore, we describe the
computation model by providing a precise definition of pattern matching with evaluation annotations
(Section D.1) which is the basis to define the computation steps on expressions (Section D.2).
The extension of this basic computation model to solving equational constraints and higher-order
functions is described in Sections D.4 and D.5, respectively. Section D.6 describes the automatic
generation of the definitional trees to guide the pattern matching strategy. Finally, Section D.7
specifies the operational semantics of the primitive operator try for encapsulating search.
D.1 Definitional Trees
We start by considering only the unconditional first-order part of Curry, i.e., rules do not contain
conditions and λ-abstractions and partial function applications are not allowed. We assume some
familiarity with basic notions of term rewriting [14] and functional logic programming [21].
We denote by C the set of constructors (with elements c, d), by F the set of defined functions
or operations (with elements f, g), and by X the set of variables (with elements x, y), where C, F
and X are disjoint. An expression (data term) is a variable x ∈ X or an application ϕ(e1, . . . , en)
where ϕ ∈ C ∪ F (ϕ ∈ C) has arity n and e1, . . . , en are expressions (data terms). 17 The set of all
expressions and data terms are denoted by T (C ∪ F, X ) and T (C, X ), respectively. A call pattern
is an expression of the form f(t1, . . . , tn) where each variable occurs only once, f ∈ F is an n-ary
function, and t1, . . . , tn ∈ T (C, X ). root(e) denotes the symbol at the root of the expression e.
A position p in an expression e is represented by a sequence of natural numbers, e|p denotes the
subterm or subexpression of e at position p, and e[e ′ ]p denotes the result of replacing the subterm
e|p by the expression e ′ (see [14] for details).
A substitution is a mapping σ: X → T (C ∪ F, X ) with σ(x) �= x only for finitely many variables
x. Thus, we denote a substitution by σ = {x1 ↦→ t1, . . . , xn ↦→ tn}, where σ(xi) �= xi for i = 1, . . . , n,
and id denotes the identity substitution (n = 0). Dom(σ) = {x1, . . . , xn} is the domain of σ and
VRan(σ) = {x | x is a variable occurring in some ti, i ∈ {1, . . . , n}}
is its variable range. Substitutions are extended to morphisms on expressions by σ(f(e1, . . . , en)) =
f(σ(e1), . . . , σ(en)) for every expression f(e1, . . . , en).
A Curry program is a set of rules l = r satisfying some restrictions (see Section 2.3). In particular,
the left-hand side l must be a call pattern. A rewrite rule is called a variant of another rule if it is
obtained by a unique replacement of variables by other variables.
An answer expression is a pair σ e consisting of a substitution σ (the answer computed so far)
and an expression e. An answer expression σ e is solved if e is a data term. We sometimes omit
the identity substitution in answer expressions, i.e., we write e instead of id e if it is clear from the
context. A disjunctive expression is a (multi-)set of answer expressions {σ1 e1, . . . , σn en}. The
set of all disjunctive expressions is denoted by D.
17 Since we do not consider partial applications in this part, we write the full application as ϕ(e1, . . . , en) which is
equivalent to Curry’s notation ϕ e1 . . . en.
64