Curry: An Integrated Functional Logic Language

that functions have to be evaluated in a strict manner but this behavior can be easily obtained by
sharing the different occurrences of a variable.
Since different occurrences of the same variable are always shared but different occurrences of
(textually identical) function calls are not shared, it is important to distinguish between variables
and functions. Usually, all symbols occurring at the top-level in the left-hand side of some rule are
considered as functions and the non-constructor symbols in the arguments of the left-hand sides
are considered as variables. But note that there is a small exception from this general rule in local
declarations (see Section 2.4).
2.3.2 Conditional Equations with Boolean Guards
For convenience and compatibility with Haskell, one can also write conditional equations with
multiple guards
f t1 . . . tn | b1 = e1
.
| bk = ek
where b1, . . . , bk (k > 0) are expressions of type Bool. Such a rule is interpreted as in Haskell:
the guards are successively evaluated and the right-hand side of the first guard which is evaluated
to True is the result of applying this equation. Thus, this equation can be considered as an
abbreviation for the rule
f t1 . . . tn = if b1 then e1 else
.
if bk then ek else undefined
(where undefined is some non-reducible function). To write rules with several Boolean guards
more nicely, there is a Boolean function otherwise which is predefined as True. For instance, the
factorial function can be declared as follows:
fac n | n==0 = 1
| otherwise = fac(n-1)*n
Since all guards have type Bool, this definition is equivalent to (after a simple optimization)
fac n = if n==0 then 1 else fac(n-1)*n
To avoid confusion, it is not allowed to mix the Haskell-like notation with Boolean guards and the
standard notation with constraints: in a rule with multiple guards, all guards must be expressions
of type Bool. The default type of a guard in single-guarded rules is Success, i.e., in a rule like
f c x | c = x
the type of the variable c is Success (provided that it is not restricted to Bool by the use of f).
2.4 Local Declarations
Since not all auxiliary functions should be globally visible, it is possible to restrict the scope of
declared entities. Note that the scope of parameters in function definitions is already restricted
7