Curry: An Integrated Functional Logic Language

which takes a search goal and produces a list of search goals. The search operator try attempts to
evaluate the search goal until the computation finishes or performs a non-deterministic splitting.
In the latter case, the computation is stopped and the different search goals caused by this splitting
are returned as the result list. Thus, an expression of the form try \x->c can have three possible
results:
1. An empty list. This indicates that the search goal \x->c has no solution. For instance, the
expression
try \x -> 1=:=2
reduces to [].
2. A list containing a single element. In this case, the search goal \x->c has a single solution
represented by the element of this list. For instance, the expression
try \x->[x]=:=[0]
reduces to [\x->x=:=0]. Note that a solution, i.e., a binding for the search variable like the
substitution {x ↦→ 0}, can always be presented by an equational constraint like x=:=0.
Generally, a one-element list as a result of try has always the form [\x->x=:=e] (plus some
local variables, see next subsection) where e is fully evaluated, i.e., e does not contain defined
functions. Otherwise, this goal might not be solvable due to the definition of equational
constraints.
3. A list containing more than one element. In this case, the evaluation of the search goal
\x->c requires a non-deterministic computation step. The different alternatives immediately
after this non-deterministic step are represented as elements of this list. For instance, if the
function f is defined by
f a = c
f b = d
then the expression
try \x -> f x =:= d
reduces to the list [\x->x=:=a & f a =:= d, \x->x=:=b & f b =:= d]. This example also
shows why the search variable must be abstracted: the alternative bindings cannot be actually
performed (since a free variable is only bound to at most one value in each computation
thread) but are represented as equational constraints in the search goal.
Note that the search goals of the list in the last example are not further evaluated. This provides
the possibility to determine the behavior for non-deterministic computations. For instance, the
following function defines a depth-first search operator which collects all solutions of a search goal
in a list:
solveAll :: (a->Success) -> [a->Success]
solveAll g = collect (try g)
where collect [] = []
30