Curry: An Integrated Functional Logic Language

and introduces a new n-ary type constructor T and k new (data) constructors C1, . . . , Ck, where
each Ci has the type
τi1 -> · · · -> τini -> T α1 . . . αn
(i = 1, . . . , k). Each τij is a type expression built from the type variables α1, . . . , αn and some
type constructors. Curry has a number of built-in type constructors, like Bool, Int, -> (function
space), or, lists and tuples, which are described in Section 4.1. Since Curry is a higher-order
language, the types of functions (i.e., constructors or operations) are written in their curried form
τ1 -> τ2 -> · · · -> τn -> τ where τ is not a functional type. In this case, n is called the arity of
the function. For instance, the datatype declarations
data Bool = True | False
data List a = [] | a : List a
data Tree a = Leaf a | Node (Tree a) a (Tree a)
introduces the datatype Bool with the 0-ary constructors (constants) True and False, and the
polymorphic types List a and Tree a of lists and binary trees. Here, “:” is an infix operator, i.e.,
“a:List a” is another notation for “(:) a (List a)”. Lists are predefined in Curry, where the
notation “[a]” is used to denote list types (instead of “List a”). The usual convenient notations
for lists are supported, i.e., [0,1,2] is an abbreviation for 0:(1:(2:[])) (see also Section 4.1).
A data term is a variable x or a constructor application c t1 . . . tn where c is an n-ary constructor
and t1, . . . , tn are data terms. An expression is a variable or a (partial) application ϕ e1 . . . em
where ϕ is a function or constructor and e1, . . . , em are expressions. A data term or expression is
called ground if it does not contain any variable. Ground data terms correspond to values in the
intended domain, and expressions containing operations should be evaluated to data terms. Note
that traditional functional languages compute on ground expressions, whereas logic languages also
allow non-ground expressions.
2.2 Type Synonym Declarations
To make type definitions more readable, it is possible to specify new names for type expressions by
a type synonym declaration. Such a declaration has the general form
type T α1 ... αn = τ
which introduces a new n-ary type constructor T . α1, . . . , αn are pairwise distinct type variables
and τ is a type expressions built from type constructors and the type variables α1, . . . , αn. The type
(T τ1 . . . τn) is equivalent to the type {α1 ↦→ τ1, . . . , αn ↦→ τn}(τ), i.e., the type expression τ where
each αi is replaced by τi. Thus, a type synonym and its definition are always interchangeable and
have no influence on the typing of a program. For example, we can provide an alternative notation
for list types and strings by the following type synonym declarations:
type List a = [a]
type Name = [Char]
Since a type synonym introduces just another name for a type expression, recursive or mutually
dependent type synonym declarations are not allowed. Therefore, the following declarations are
invalid:
4