The standard prelude of Curry. All toplevel functions defined in this module are always available in any Curry program.
(.)
:: (a > b) > (c > a) > c > b
Function composition. 
id
:: a > a
Identity function. 
const
:: a > b > a
Constant function. 
curry
:: ((a,b) > c) > a > b > c
Converts an uncurried function to a curried function. 
uncurry
:: (a > b > c) > (a,b) > c
Converts an curried function to a function on pairs. 
flip
:: (a > b > c) > b > a > c
(flip f) is identical to f but with the order of arguments reversed. 
until
:: (a > Bool) > (a > a) > a > a
Repeats application of a function until a predicate holds. 
seq
:: a > b > b
Evaluates the first argument to head normal form (which could also be a free variable) and returns the second argument. 
ensureNotFree
:: a > a
Evaluates the argument to head normal form and returns it. 
ensureSpine
:: [a] > [a]
Evaluates the argument to spine form and returns it. 
($)
:: (a > b) > a > b
Rightassociative application. 
($!)
:: (a > b) > a > b
Rightassociative application with strict evaluation of its argument to head normal form. 
($!!)
:: (a > b) > a > b
Rightassociative application with strict evaluation of its argument to normal form. 
($#)
:: (a > b) > a > b
Rightassociative application with strict evaluation of its argument to a nonvariable term. 
($##)
:: (a > b) > a > b
Rightassociative application with strict evaluation of its argument to ground normal form. 
error
:: String > a
Aborts the execution with an error message. 
prim_error
:: String > a

failed
:: a
A nonreducible polymorphic function. 
(&&)
:: Bool > Bool > Bool
Sequential conjunction on Booleans. 
()
:: Bool > Bool > Bool
Sequential disjunction on Booleans. 
not
:: Bool > Bool
Negation on Booleans. 
otherwise
:: Bool
Useful name for the last condition in a sequence of conditional equations. 
if_then_else
:: Bool > a > a > a
The standard conditional. 
solve
:: Bool > Bool
Enforce a Boolean condition to be true. 
(&>)
:: Bool > a > a
Conditional expression. 
(==)
:: a > a > Bool
Equality on finite ground data terms. 
(/=)
:: a > a > Bool
Disequality. 
(=:=)
:: a > a > Bool
The equational constraint. 
(&)
:: Bool > Bool > Bool
Concurrent conjunction. 
compare
:: a > a > Ordering
Comparison of arbitrary ground data terms. 
(<)
:: a > a > Bool
Lessthan on ground data terms. 
(>)
:: a > a > Bool
Greaterthan on ground data terms. 
(<=)
:: a > a > Bool
Lessorequal on ground data terms. 
(>=)
:: a > a > Bool
Greaterorequal on ground data terms. 
max
:: a > a > a
Maximum of ground data terms. 
min
:: a > a > a
Minimum of ground data terms. 
fst
:: (a,b) > a
Selects the first component of a pair. 
snd
:: (a,b) > b
Selects the second component of a pair. 
head
:: [a] > a
Computes the first element of a list. 
tail
:: [a] > [a]
Computes the remaining elements of a list. 
null
:: [a] > Bool
Is a list empty? 
(++)
:: [a] > [a] > [a]
Concatenates two lists. 
length
:: [a] > Int
Computes the length of a list. 
(!!)
:: [a] > Int > a
List index (subscript) operator, head has index 0. 
map
:: (a > b) > [a] > [b]
Map a function on all elements of a list. 
foldl
:: (a > b > a) > a > [b] > a
Accumulates all list elements by applying a binary operator from left to right. 
foldl1
:: (a > a > a) > [a] > a
Accumulates a nonempty list from left to right. 
foldr
:: (a > b > b) > b > [a] > b
Accumulates all list elements by applying a binary operator from right to left. 
foldr1
:: (a > a > a) > [a] > a
Accumulates a nonempty list from right to left: 
filter
:: (a > Bool) > [a] > [a]
Filters all elements satisfying a given predicate in a list. 
zip
:: [a] > [b] > [(a,b)]
Joins two lists into one list of pairs. 
zip3
:: [a] > [b] > [c] > [(a,b,c)]
Joins three lists into one list of triples. 
zipWith
:: (a > b > c) > [a] > [b] > [c]
Joins two lists into one list by applying a combination function to corresponding pairs of elements. 
zipWith3
:: (a > b > c > d) > [a] > [b] > [c] > [d]
Joins three lists into one list by applying a combination function to corresponding triples of elements. 
unzip
:: [(a,b)] > ([a],[b])
Transforms a list of pairs into a pair of lists. 
unzip3
:: [(a,b,c)] > ([a],[b],[c])
Transforms a list of triples into a triple of lists. 
concat
:: [[a]] > [a]
Concatenates a list of lists into one list. 
concatMap
:: (a > [b]) > [a] > [b]
Maps a function from elements to lists and merges the result into one list. 
iterate
:: (a > a) > a > [a]
Infinite list of repeated applications of a function f to an element x. 
repeat
:: a > [a]
Infinite list where all elements have the same value. 
replicate
:: Int > a > [a]
List of length n where all elements have the same value. 
take
:: Int > [a] > [a]
Returns prefix of length n. 
drop
:: Int > [a] > [a]
Returns suffix without first n elements. 
splitAt
:: Int > [a] > ([a],[a])
(splitAt n xs) is equivalent to (take n xs, drop n xs) 
takeWhile
:: (a > Bool) > [a] > [a]
Returns longest prefix with elements satisfying a predicate. 
dropWhile
:: (a > Bool) > [a] > [a]
Returns suffix without takeWhile prefix. 
span
:: (a > Bool) > [a] > ([a],[a])
(span p xs) is equivalent to (takeWhile p xs, dropWhile p xs) 
break
:: (a > Bool) > [a] > ([a],[a])
(break p xs) is equivalent to (takeWhile (not.p) xs, dropWhile (not.p) xs). 
lines
:: String > [String]
Breaks a string into a list of lines where a line is terminated at a newline character. 
unlines
:: [String] > String
Concatenates a list of strings with terminating newlines. 
words
:: String > [String]
Breaks a string into a list of words where the words are delimited by white spaces. 
unwords
:: [String] > String
Concatenates a list of strings with a blank between two strings. 
reverse
:: [a] > [a]
Reverses the order of all elements in a list. 
and
:: [Bool] > Bool
Computes the conjunction of a Boolean list. 
or
:: [Bool] > Bool
Computes the disjunction of a Boolean list. 
any
:: (a > Bool) > [a] > Bool
Is there an element in a list satisfying a given predicate? 
all
:: (a > Bool) > [a] > Bool
Is a given predicate satisfied by all elements in a list? 
elem
:: a > [a] > Bool
Element of a list? 
notElem
:: a > [a] > Bool
Not element of a list? 
lookup
:: a > [(a,b)] > Maybe b
Looks up a key in an association list. 
enumFrom
:: Int > [Int]
Generates an infinite sequence of ascending integers. 
enumFromThen
:: Int > Int > [Int]
Generates an infinite sequence of integers with a particular in/decrement. 
enumFromTo
:: Int > Int > [Int]
Generates a sequence of ascending integers. 
enumFromThenTo
:: Int > Int > Int > [Int]
Generates a sequence of integers with a particular in/decrement. 
ord
:: Char > Int
Converts a character into its ASCII value. 
prim_ord
:: Char > Int

chr
:: Int > Char
Converts a Unicode value into a character, fails iff the value is out of bounds 
prim_chr
:: Int > Char

(+)
:: Int > Int > Int
Adds two integers. 
()
:: Int > Int > Int
Subtracts two integers. 
(*)
:: Int > Int > Int
Multiplies two integers. 
div
:: Int > Int > Int
Integer division. 
mod
:: Int > Int > Int
Integer remainder. 
divMod
:: Int > Int > (Int,Int)
Returns an integer (quotient,remainder) pair. 
quot
:: Int > Int > Int
Integer division. 
rem
:: Int > Int > Int
Integer remainder. 
quotRem
:: Int > Int > (Int,Int)
Returns an integer (quotient,remainder) pair. 
negate
:: Int > Int
Unary minus. 
negateFloat
:: Float > Float
Unary minus on Floats. 
success
:: Bool
The always satisfiable constraint. 
maybe
:: a > (b > a) > Maybe b > a

either
:: (a > b) > (c > b) > Either a c > b

(>>=)
:: IO a > (a > IO b) > IO b
Sequential composition of actions. 
return
:: a > IO a
The empty action that directly returns its argument. 
(>>)
:: IO a > IO b > IO b
Sequential composition of actions. 
done
:: IO ()
The empty action that returns nothing. 
putChar
:: Char > IO ()
An action that puts its character argument on standard output. 
prim_putChar
:: Char > IO ()

getChar
:: IO Char
An action that reads a character from standard output and returns it. 
readFile
:: String > IO String
An action that (lazily) reads a file and returns its contents. 
prim_readFile
:: String > IO String

writeFile
:: String > String > IO ()
An action that writes a file. 
prim_writeFile
:: String > String > IO ()

appendFile
:: String > String > IO ()
An action that appends a string to a file. 
prim_appendFile
:: String > String > IO ()

putStr
:: String > IO ()
Action to print a string on stdout. 
putStrLn
:: String > IO ()
Action to print a string with a newline on stdout. 
getLine
:: IO String
Action to read a line from stdin. 
userError
:: String > IOError
A user error value is created by providing a description of the error situation as a string. 
ioError
:: IOError > IO a
Raises an I/O exception with a given error value. 
prim_ioError
:: IOError > IO a

showError
:: IOError > String
Shows an error values as a string. 
catch
:: IO a > (IOError > IO a) > IO a
Catches a possible error or failure during the execution of an I/O action. 
show
:: a > String
Converts an arbitrary term into an external string representation. 
prim_show
:: a > String

print
:: a > IO ()
Converts a term into a string and prints it. 
doSolve
:: Bool > IO ()
Solves a constraint as an I/O action. 
sequenceIO
:: [IO a] > IO [a]
Executes a sequence of I/O actions and collects all results in a list. 
sequenceIO_
:: [IO a] > IO ()
Executes a sequence of I/O actions and ignores the results. 
mapIO
:: (a > IO b) > [a] > IO [b]
Maps an I/O action function on a list of elements. 
mapIO_
:: (a > IO b) > [a] > IO ()
Maps an I/O action function on a list of elements. 
foldIO
:: (a > b > IO a) > a > [b] > IO a
Folds a list of elements using an binary I/O action and a value for the empty list. 
liftIO
:: (a > b) > IO a > IO b
Apply a pure function to the result of an I/O action. 
forIO
:: [a] > (a > IO b) > IO [b]
Like mapIO , but with flipped arguments.

forIO_
:: [a] > (a > IO b) > IO ()
Like mapIO_ , but with flipped arguments.

unless
:: Bool > IO () > IO ()
Performs an IO
action unless the condition is met.

when
:: Bool > IO () > IO ()
Performs an IO
action when the condition is met.

(?)
:: a > a > a
Nondeterministic choice par excellence. 
anyOf
:: [a] > a

unknown
:: a
Evaluates to a fresh free variable. 
PEVAL
:: a > a
Identity function used by the partial evaluator to mark expressions to be partially evaluated. 
normalForm
:: a > a
Evaluates the argument to normal form and returns it. 
groundNormalForm
:: a > a
Evaluates the argument to ground normal form and returns it. 
apply
:: (a > b) > a > b

cond
:: Bool > a > a

(=:<=)
:: a > a > Bool
Nonstrict equational constraint. 
Constructors:
Constructors:
Constructors:
Type synonym: String = [Char]
Constructors:
False
:: Bool
True
:: Bool
Ordering type. Useful as a result of comparison functions.
Constructors:
LT
:: Ordering
EQ
:: Ordering
GT
:: Ordering
Type synonym: Success = Bool
Constructors:
Nothing
:: Maybe a
Just
:: a > Maybe a
Constructors:
Left
:: a > Either a b
Right
:: b > Either a b
Constructors:
The (abstract) type of error values.
Currently, it distinguishes between general IO errors,
usergenerated errors (see userError
), failures and nondeterminism
errors during IO computations. These errors can be caught by catch
and shown by showError
.
Each error contains a string shortly explaining the error.
This type might be extended in the future to distinguish
further error situations.
Constructors:
IOError
:: String > IOError
UserError
:: String > IOError
FailError
:: String > IOError
NondetError
:: String > IOError
Identity type synonym used to mark deterministic operations.
Type synonym: DET a = a
Function composition.

Identity function.

Constant function.

Converts an uncurried function to a curried function. 
Converts an curried function to a function on pairs. 
(flip f) is identical to f but with the order of arguments reversed. 
Repeats application of a function until a predicate holds. 
Evaluates the first argument to head normal form (which could also be a free variable) and returns the second argument.

Evaluates the argument to head normal form and returns it. Suspends until the result is bound to a nonvariable term.

Evaluates the argument to spine form and returns it. Suspends until the result is bound to a nonvariable spine. 
Rightassociative application.

Rightassociative application with strict evaluation of its argument to head normal form.

Rightassociative application with strict evaluation of its argument to normal form.

Rightassociative application with strict evaluation of its argument to a nonvariable term.

Rightassociative application with strict evaluation of its argument to ground normal form.

Aborts the execution with an error message. 

A nonreducible polymorphic function.
It is useful to express a failure in a search branch of the execution.
It could be defined by:

Sequential conjunction on Booleans.

Sequential disjunction on Booleans.

Negation on Booleans.

Useful name for the last condition in a sequence of conditional equations.

The standard conditional. It suspends if the condition is a free variable. 
Enforce a Boolean condition to be true.
The computation fails if the argument evaluates to

Conditional expression.
An expression like

Equality on finite ground data terms.

Disequality.

The equational constraint.

Concurrent conjunction.
An expression like

Comparison of arbitrary ground data terms. Data constructors are compared in the order of their definition in the datatype declarations and recursively in the arguments. 
Lessthan on ground data terms.

Greaterthan on ground data terms.

Lessorequal on ground data terms.

Greaterorequal on ground data terms.

Maximum of ground data terms. 
Minimum of ground data terms. 
Selects the first component of a pair.

Selects the second component of a pair.

Computes the first element of a list.

Computes the remaining elements of a list.

Is a list empty?

Concatenates two lists. Since it is flexible, it could be also used to split a list into two sublists etc.

Computes the length of a list. 
List index (subscript) operator, head has index 0.

Map a function on all elements of a list. 
Accumulates all list elements by applying a binary operator from left to right. Thus, foldl f z [x1,x2,...,xn] = (...((z `f` x1) `f` x2) ...) `f` xn 
Accumulates a nonempty list from left to right.

Accumulates all list elements by applying a binary operator from right to left. Thus, foldr f z [x1,x2,...,xn] = (x1 `f` (x2 `f` ... (xn `f` z)...)) 
Accumulates a nonempty list from right to left:

Filters all elements satisfying a given predicate in a list. 
Joins two lists into one list of pairs. If one input list is shorter than the other, the additional elements of the longer list are discarded.

Joins three lists into one list of triples. If one input list is shorter than the other, the additional elements of the longer lists are discarded.

Joins two lists into one list by applying a combination function to
corresponding pairs of elements. Thus 
Joins three lists into one list by applying a combination function to
corresponding triples of elements. Thus 
Transforms a list of pairs into a pair of lists.

Transforms a list of triples into a triple of lists.

Concatenates a list of lists into one list. 
Maps a function from elements to lists and merges the result into one list. 
Infinite list of repeated applications of a function f to an element x.
Thus, 
Infinite list where all elements have the same value.
Thus,

List of length n where all elements have the same value. 
Returns prefix of length n. 
Returns suffix without first n elements. 
(splitAt n xs) is equivalent to (take n xs, drop n xs) 
Returns longest prefix with elements satisfying a predicate. 
Returns suffix without takeWhile prefix. 
(span p xs) is equivalent to (takeWhile p xs, dropWhile p xs) 
(break p xs) is equivalent to (takeWhile (not.p) xs, dropWhile (not.p) xs). Thus, it breaks a list at the first occurrence of an element satisfying p. 
Breaks a string into a list of lines where a line is terminated at a newline character. The resulting lines do not contain newline characters. 
Concatenates a list of strings with terminating newlines. 
Breaks a string into a list of words where the words are delimited by white spaces. 
Concatenates a list of strings with a blank between two strings. 
Reverses the order of all elements in a list. 
Computes the conjunction of a Boolean list. 
Computes the disjunction of a Boolean list. 
Is there an element in a list satisfying a given predicate? 
Is a given predicate satisfied by all elements in a list? 
Element of a list?

Not element of a list?

Looks up a key in an association list. 
Generates an infinite sequence of ascending integers. 
Generates an infinite sequence of integers with a particular in/decrement. 
Generates a sequence of ascending integers. 
Generates a sequence of integers with a particular in/decrement. 
Converts a character into its ASCII value. 

Converts a Unicode value into a character, fails iff the value is out of bounds 

Adds two integers.

Subtracts two integers.

Multiplies two integers.

Integer division. The value is the integer quotient of its arguments
and always truncated towards negative infinity.
Thus, the value of

Integer remainder. The value is the remainder of the integer division and
it obeys the rule

Returns an integer (quotient,remainder) pair. The value is the integer quotient of its arguments and always truncated towards negative infinity.

Integer division. The value is the integer quotient of its arguments
and always truncated towards zero.
Thus, the value of

Integer remainder. The value is the remainder of the integer division and
it obeys the rule

Returns an integer (quotient,remainder) pair. The value is the integer quotient of its arguments and always truncated towards zero.

Unary minus. Usually written as " e". 
Unary minus on Floats. Usually written as "e".

The always satisfiable constraint.



Sequential composition of actions.

The empty action that directly returns its argument.

Sequential composition of actions.

The empty action that returns nothing.

An action that puts its character argument on standard output. 

An action that reads a character from standard output and returns it.

An action that (lazily) reads a file and returns its contents. 

An action that writes a file.


An action that appends a string to a file. It behaves like writeFile if the file does not exist.


Action to print a string on stdout. 
Action to print a string with a newline on stdout. 
Action to read a line from stdin. 
A user error value is created by providing a description of the error situation as a string.

Raises an I/O exception with a given error value. 

Shows an error values as a string.

Catches a possible error or failure during the execution of an
I/O action.

Converts an arbitrary term into an external string representation. 

Converts a term into a string and prints it. 
Solves a constraint as an I/O action. Note: the constraint should be always solvable in a deterministic way 
Executes a sequence of I/O actions and collects all results in a list. 
Executes a sequence of I/O actions and ignores the results. 
Maps an I/O action function on a list of elements. The results of all I/O actions are collected in a list. 
Maps an I/O action function on a list of elements. The results of all I/O actions are ignored. 
Folds a list of elements using an binary I/O action and a value for the empty list. 
Apply a pure function to the result of an I/O action. 
Like This can be useful if the definition of the function is longer than those of the list, like in forIO [1..10] $ \n > do ... 
Like This can be useful if the definition of the function is longer than those of the list, like in forIO_ [1..10] $ \n > do ... 
Performs an 
Performs an 
Nondeterministic choice par excellence.
The value of


Evaluates to a fresh free variable.

Identity function used by the partial evaluator to mark expressions to be partially evaluated.

Evaluates the argument to normal form and returns it. 
Evaluates the argument to ground normal form and returns it. Suspends as long as the normal form of the argument is not ground. 


Nonstrict equational constraint. Used to implement functional patterns.
