Curry: An Integrated Functional Logic Language

this pattern that are not data constructors are considered as variables. For instance, the locally
introduced identifiers a, b, l, and r in the previous examples are variables whereas the identifiers
even and square denote functions. Note that this rule exclude the definition of 0-ary local functions
since a definition of the form “where f = ...” is considered as the definition of a local variable
f by this rule which is usually the intended interpretation (see previous examples). Appendix D.8
contains a precise formalization of the meaning of local definitions.
2.5 Free Variables
Since Curry is intended to cover functional as well as logic programming paradigms, expressions
(or constraints, see Section 2.6) might contain free (unbound, uninstantiated) variables. The idea
is to compute values for these variables such that the expression is reducible to a data term or that
the constraint is solvable. For instance, consider the definitions
mother John = Christine
mother Alice = Christine
mother Andrew = Alice
Then we can compute a child of Alice by solving the equation (see Section 2.6)
mother x =:= Alice. Here, x is a free variable which is instantiated to Andrew in order to reduce
the equation’s left-hand side to Alice. Similarly, we can compute a grandchild of Chistine by
solving the equation mother (mother x) =:= Christine which yields the value Andrew for x.
In logic programming languages like Prolog, all free variables are considered as existentially
quantified at the top-level. Thus, they are always implicitly declared at the top-level. In a language
with different nested scopes like Curry, it is not clear to which scope an undeclared variable belongs
(the exact scope of a variable becomes particularly important in the presence of search operators,
see Section 8, where existential quantifiers and lambda abstractions are often mixed). Therefore,
Curry requires that each free variable x must be explicitly declared using a declaration of the form
x free. These declarations can occur in where-clauses or in a let enclosing a constraint. The
variable is then introduced as unbound with the same scoping rules as for all other local entities
(see Section 2.4). For instance, we can define
isgrandmother g | let c free in mother (mother c) =:= g = True
As a further example, consider the definition of the concatentation of two lists:
append [] ys = ys
append (x:xs) ys = x : append xs ys
Then we can define the function last which computes the last element of a list by the rule
last l | append xs [x] =:= l = x where x,xs free
Since the variable xs occurs in the condition but not in the right-hand side, the following definition
is also possible:
last l | let xs free in append xs [x] =:= l = x where x free
Note that the free declarations can be freely mixed with other local declarations after a let or
where. The only difference is that a declaration like “let x free” introduces an existentially quan-
9