Curry: An Integrated Functional Logic Language

C x1 . . . xn == D y1 . . . ym = False % for all different constructors C and D
This implements a test for strict equality (cf. Section 2.6). For instance, the test “[0]==[0]”
reduces to True, whereas the test “1==0” reduces to False. An equality test with a free variable in
one side is delayed in order to avoid an infinite set of solutions for insufficiently instantiated tests
like x==y. Usually, strict equality is only defined on data terms, i.e., == is not really polymorphic
but an overloaded function symbol. This could be more precisely expressed using type classes which
will be considered in a future version.
Note that e1==e2 only tests the identity of e1 and e2 but never binds one side to the other if it
is a free variable. This is in contrast to solving the equational constraint e1=:=e2 which is checked
for satisfiability and propagates new variable bindings in order to solve this constraint. Thus, in
terms of concurrent constraint programming languages [44], == and =:= correspond to ask and tell
equality constraints, respectively.
4.1.2 Constraints
The type Success is the result type of expressions used in conditions of defining rules. Since
conditions must be successfully evaluated in order to apply the rule, the type Success can be also
interpreted as the type of successful evaluations. A function with result type Success is also called
a constraint.
Constraints are different from Boolean-valued functions: a Boolean expression reduces to True
or False whereas a constraint is checked for satisfiability. A constraint is applied (i.e., solved) in a
condition of a conditional equation. The equational constraint e1=:=e2 is an elementary constraint
which is solvable if the expressions e1 and e2 are evaluable to unifiable data terms. success denotes
an always solvable constraint.
Constraints can be combined into a conjunction of the form c1 & c2 & . . . & cn by applying the
concurrent conjunction operator &. In this case, all constraints in the conjunction are evaluated
concurrently. Constraints can also be evaluated in a sequential order by the sequential conjunction
operator &>, i.e., the combined constraint c1 &> c2 will be evaluated by first completely evaluating
c1 and then c2.
Constraints can be passed as parameters or results of functions like any other data object. For
instance, the following function takes a list of constraints as input and produces a single constraint,
the concurrent conjunction of all constraints of the input list:
conj :: [Success] -> Success
conj [] = success
conj (c:cs) = c & conj cs
The trivial constraint success is usually not shown in answers to a constraint expression. For
instance, the constraint x*x=:=y & x=:=2 is evaluated to the answer
{x=2, y=4}
15