Curry: An Integrated Functional Logic Language

may cause the reactivation of c1 at some later time (due to the binding of common variables). In
a sequential implementation, the evaluation of c1 & c2 could be started by an attempt to solve c1.
If the evaluation of c1 suspends, an evaluation step is applied to c2.
It is interesting to note that parallel functional computation models [11, 12] are covered by the
use of concurrent constraints. For instance, a constraint of the form
x =:= f t1 & y =:= g t2 & z =:= h x y
specifies a potentially concurrent computation of the functions f, g and h where the function h can
proceed its computation only if the arguments have been bound by evaluating the expressions f t1
and g t2. Since constraints could be passed as arguments or results of functions (like any other
data object or function), it is possible to specify general operators to create flexible communication
architectures similarly to Goffin [12]. Thus, the same abstraction facilities could be used for
sequential as well as concurrent programming. On the other hand, the clear separation between
sequential and concurrent computations (e.g., a program without any occurrences of concurrent
conjunctions is purely sequential) supports the use of efficient and optimal evaluation strategies for
the sequential parts [4, 6], where similar techniques for the concurrent parts are not available.
2.7 Higher-order Features
Curry is a higher-order language supporting the common functional programming techniques by
partial function applications and lambda abstractions. Function application is denoted by juxtaposition
the function and its argument. For instance, the well-known map function is defined in
Curry by
map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (x:xs) = f x : map f xs
However, there is an important difference w.r.t. to functional programming. Since Curry is also
a logic language, it allows logical variables also for functional values, i.e., it is possible to evaluate
the equation map f [1 2] =:= [2 3] which has, for instance, a solution {f=inc} if inc is the
increment function on natural numbers. In principle, such solutions can be computed by extending
(first-order) unification to higher-order unification [24, 38, 43]. Since higher-order unification is a
computationally expensive operation, Curry delays the application of unknown functions until the
function becomes known [2, 46]. 5 Thus, the application operation can be considered as a function
(“@” is a left-associative infix operator)
(@) :: (a -> b) -> a -> b
f@x = f x
which is “rigid” in its first argument (cf. Section 3).
In cases where a function is only used a single time, it is tedious to assign a name to it. For
5 Note that an unbound functional variable can never be instantiated if all program rules are constructor-based and
the equational constraint =:= denotes equality between data terms. However, extensions of Curry might overcome
this weakness by instantiating unbound functional variables to (type-conform) functions occurring in the program in
order to evaluate an application (as in [19]), or by considering partial applications (i.e., functions calls with less than
the required number of arguments) as data terms (as in [49]).
11