Curry: An Integrated Functional Logic Language

instance, if we want to compute the last element of the list [3,4,5] based on append, we could try
to solve the search goal
\e -> append l [e] =:= [3,4,5]
However, the evaluation of this goal suspends due to the necessary binding of the free variable l.
This can be avoided by declaring the variable l as local to the constraint by the use of let (see
Section 2.5), like in the following expression:
first \e -> let l free in append l [e] =:= [3,4,5]
Due to the local declaration of the variable l (which corresponds logically to an existential quantification),
the variable l is only visible inside the constraint and, therefore, it can be bound to
different values in different branches. Hence this expression evaluates to the result 5.
In order to ensure that an encapsulated search will not be suspended due to necessary bindings
of free variables, the search goal should be a closed expression when a search operator is applied
to it, i.e., the search variable is bound by the lambda abstraction and all other free variables are
existentially quantified by local declarations.
8.3 Predefined Search Operators
There are a number of search operators which are predefined in the prelude. All these operators are
based on the primitive try as described above. It is also possible to define other search strategies
in a similar way. Thus, the try operator is a a powerful primitive to define appropriate search
strategies. In the following, we list the predefined search operators.
solveAll :: (a->Success) -> [a->Success]
Compute all solutions for a search goal via a depth-first search strategy. If there is no solution
and the search space is finite, the result is the empty list, otherwise the list contains solved
search goals (i.e., without defined operations).
once :: (a->Success) -> (a->Success)
Compute the first solution for a search goal via a depth-first search strategy. Note that once
is partially defined, i.e., if there is no solution and the search space is finite, the result is
undefined.
findall :: (a->Success) -> [a]
Compute all solutions for a search goal via a depth-first search strategy and unpack the
solution’s values for the search variable into a list.
best :: (a->Success) -> (a->a->Bool) -> [a->Success]
Compute the best solution via a depth-first search strategy, according to a specified relation
(the second argument) that can always take a decision which of two solutions is better
(the relation should deliver True if the first argument is a better solution than the second
argument).
As a trivial example, consider the relation shorter defined by
shorter l1 l2 = length l1