Curry: An Integrated Functional Logic Language

to the suspension of e1 is instantiated, the left expression e1 will be evaluated in the subsequent
step. Thus, we obtain a concurrent behavior with an interleaving semantics. However, a sophisticated
implementation should provide a fair selection of threads, e.g., as done in a Java-based
implementation of Curry [25].
A computation step for an expression e attempts to apply a reduction step to an outermost
operation-rooted subterm in e by evaluating this subterm with the definitional tree for the function
symbol at the root of this subterm. Although it is unspecified which outermost subterm is evaluated
(compare second inference rule in Figure 2 for constructor-rooted expressions), we assume that a
single (e.g., leftmost) outermost subterm is always selected. The evaluation of an operation-rooted
term is defined by a case distinction on the definitional tree. If it is a rule node, this rule is applied.
An or node produces a disjunction where the different alternatives are combined. Note that this
definition requires that the entire disjunction suspends if one disjunct suspends. This can be relaxed
in concrete implementations by continuing the evaluation in one or branch even if the other branch
is suspended. However, to ensure completeness, it is not allowed to omit a suspended or branch
and continue with the other non-suspended or branch [23]. For a similar reason, we cannot commit
to a disjunct which does not bind variables but we have to consider both alternatives (see [5] for a
counter-example).
The most interesting case is a branch node. Here we have to branch on the value of the
top-level symbol at the selected position. If the symbol is a constructor, we proceed with the
appropriate definitional subtree, if possible. If it is a function symbol, we proceed by evaluating
this subexpression. If it is a variable and the branch is flexible, we instantiate the variable to
the different constructors, otherwise (if the branch is rigid) we cannot proceed and suspend. The
auxiliary function replace puts a possibly disjunctive expression into a subterm:
replace(e, p, {σ1 e1, . . . , σn en}) = {σ1 σ1(e)[e1]p, . . . , σn σn(e)[en]p} (n ≥ 0)
The overall computation strategy on disjunctive expressions takes a disjunct σ e not in solved
form and evaluates e. If the evaluation does not suspend and yields a disjunctive expression, we
substitute it for σ e composed with the old answer substitution.
Soundness and completeness results for the operational semantics can be found in [23]. Note
that the evaluation of expressions is completely deterministic if the concurrent conjunction of
constraints does not occur.
Conditional rules. Note that the operational semantics specified in Figure 2 handles only unconditional
rules. Conditional rules are treated by the rules in Figure 3. If a conditional rules
is applied, the condition and the right-hand side are joined into a guarded expression, i.e., a pair
of the form c|r. Due to the additional evaluation rules, a guarded expression is evaluated by an
attempt to solve its condition. If the condition is solvable (i.e., reducible to success), the guarded
expression is replaced by its right-hand side. If the condition is not solvable and does not suspend,
the disjunct containing this guarded expression will be deleted by the definition of computation
steps, i.e., the application of the conditional rule fails and does not contribute to the final result.
Sharing and graph rewriting. For the sake of simplicity, this description of the operational
semantics is based on term rewriting and does not take into account that common subterms are
shared (see Section 2.3.1). We only note here that several occurrences of the same variable are
67