Curry: An Integrated Functional Logic Language

side of some rule, if the left-hand side has a constructor at this position, i.e., in order to apply the
rule, the actual value at this position must be the constructor). In this situation there are two
possibilities to proceed:
1. Delay the evaluation of this function call until the corresponding free variable is bound (this
corresponds to the residuation principle which is the basis of languages like Escher [31, 32],
Le Fun [2], Life [1], NUE-Prolog [40], or Oz [46]). In this case, the function is called rigid.
2. (Non-deterministically) instantiate the free variable to the different values demanded by the
left-hand sides and apply reduction steps using the different rules (this corresponds to narrowing
principle which is the basis of languages like ALF [20], Babel [37], K-Leaf [17], LPG
[8], or SLOG [16]). In this case, the function is called flexible.
Since Curry is an attempt to provide a common platform for different declarative programming
styles and the decision about the “right” strategy depends on the definition and intended meaning
of the functions, Curry supports both strategies. The precise strategy is specified by evaluation
annotations for each function. 6 The precise operational meaning of evaluation annotations is
defined in Appendix D. A function can be explicitly annotated as rigid. If an explicit annotation
is not provided by the user, a default strategy is used: functions with the result type “IO ...” are
rigid and all other defined functions are flexible. Functions with a polymorphic result type (like the
identity) are considered as flexible, although they can be applied like a function with result type
“IO ...” in a particular context. For each external function, i.e., a function that is not defined
by explicit program rules, the strategy is also fixed. Most predefined functions, like arithmetic
operators (see Section 4.1.4), are rigid, i.e., they suspend if some argument is an unbound variable.
For instance, consider the function f as defined above. As the default strategy, f is flexible, i.e.,
the expression f x is evaluated by instantiating x to 0 or 1 and applying a reduction step in both
cases. This yields the disjunctive expression
{x=0} 2 | {x=1} 3 .
However, if f has the evaluation annotation
f eval rigid
(i.e., f is rigid), then the expression f x cannot be evaluated since the argument is a free variable.
In order to proceed, we need a “generator” for values for x, which is the case in the following
constraint:
f x =:= y & x =:= 1
Here, the first constraint f x =:= y cannot be evaluated and thus suspends, but the second constraint
x=:=1 is evaluated by binding x to 1. After this binding, the first constraint can be evaluated
and the entire constraint is solved. Thus, the constraint is solved by the following steps:
f x =:= y & x =:= 1
❀ {x=1} f 1 =:= y
❀ {x=1} 3 =:= y
6 Evaluation annotations are similar to coroutining declarations [39] in Prolog where the programmer specifies
conditions under which a literal is ready for a resolution step.
13