The standard prelude of Curry (with type classes). All exported functions, data types, classes, and methods 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. 
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
The equational constraint. 
(&)
:: Bool > Bool > Bool
Concurrent conjunction. 
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
:: Eq a => a > [a] > Bool
Element of a list? 
notElem
:: Eq a => a > [a] > Bool
Not element of a list? 
lookup
:: Eq a => 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. 
chr
:: Int > Char
Converts a Unicode value into a character. 
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

done
:: IO ()
The empty IO action that returns nothing. 
putChar
:: Char > IO ()
An action that puts its character argument on standard output. 
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. 
writeFile
:: String > String > IO ()
An action that writes a file. 
appendFile
:: String > String > IO ()
An action that appends a string to a file. 
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. 
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. 
print
:: Show a => 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

letrec
:: a > a > Bool
This operation is internally used by PAKCS to implement recursive let s by using cyclic term structures.

(=:<=)
:: a > a > Bool
Nonstrict equational constraint. 
(=:<<=)
:: a > a > Bool
Nonstrict equational constraint for linear functional patterns. 
shows
:: Show a => a > String > String

showChar
:: Char > String > String

showString
:: String > String > String

showParen
:: Bool > (String > String) > String > String

reads
:: Read a => String > [(a,String)]

readParen
:: Bool > (String > [(a,String)]) > String > [(a,String)]

read
:: Read a => String > a

lex
:: String > [(String,String)]

boundedEnumFrom
:: (Bounded a, Enum a) => a > [a]

boundedEnumFromThen
:: (Bounded a, Enum a) => a > a > [a]

asTypeOf
:: a > a > a

sequence
:: Monad a => [a b] > a [b]
Evaluates a sequence of monadic actions and collects all results in a list. 
sequence_
:: Monad a => [a b] > a ()
Evaluates a sequence of monadic actions and ignores the results. 
mapM
:: Monad a => (b > a c) > [b] > a [c]
Maps a monadic action function on a list of elements. 
mapM_
:: Monad a => (b > a c) > [b] > a ()
Maps a monadic action function on a list of elements. 
foldM
:: Monad a => (b > c > a b) > b > [c] > a b
Folds a list of elements using a binary monadic action and a value for the empty list. 
liftM
:: Monad a => (b > c) > a b > a c
Apply a pure function to the result of a monadic action. 
liftM2
:: Monad a => (b > c > d) > a b > a c > a d
Apply a pure binary function to the result of two monadic actions. 
forM
:: Monad a => [b] > (b > a c) > a [c]
Like mapM , but with flipped arguments.

forM_
:: Monad a => [b] > (b > a c) > a ()
Like mapM_ , but with flipped arguments.

unlessM
:: Monad a => Bool > a () > a ()
Performs a monadic action unless the condition is met. 
whenM
:: Monad a => Bool > a () > a ()
Performs a monadic action when the condition is met. 
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
Type synonym: ShowS = String > String
Type synonym: ReadS a = String > [(a,String)]
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

The equational constraint.

Concurrent conjunction.
An expression like

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. The conversion is total, i.e., for outofbound values, the smallest or largest character is generated. 
Unary minus. Usually written as " e". 
Unary minus on Floats. Usually written as "e". 
The always satisfiable constraint.



The empty IO 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 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. 


This operation is internally used by PAKCS to implement recursive
letrec ones (1:ones)
(where

Nonstrict equational constraint. Used to implement functional patterns.

Nonstrict equational constraint for linear functional patterns. Thus, it must be ensured that the first argument is always (after evalutation by narrowing) a linear pattern. Experimental.












Evaluates a sequence of monadic actions and collects all results in a list. 
Evaluates a sequence of monadic actions and ignores the results. 
Maps a monadic action function on a list of elements. The results of all monadic actions are collected in a list. 
Maps a monadic action function on a list of elements. The results of all monadic actions are ignored. 
Folds a list of elements using a binary monadic action and a value for the empty list. 
Apply a pure function to the result of a monadic action. 
Apply a pure binary function to the result of two monadic actions. 
Like This can be useful if the definition of the function is longer than those of the list, like in forM [1..10] $ \n > do ... 
Like This can be useful if the definition of the function is longer than those of the list, like in forM_ [1..10] $ \n > do ... 
Performs a monadic action unless the condition is met. 
Performs a monadic action when the condition is met. 