Module Prelude

The standard prelude of Curry. All top-level functions defined in this module are always available in any Curry program.

Summary of exported operations:

(.) :: (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   
Right-associative application.
($!) :: (a -> b) -> a -> b   
Right-associative application with strict evaluation of its argument to head normal form.
($!!) :: (a -> b) -> a -> b   
Right-associative application with strict evaluation of its argument to normal form.
($#) :: (a -> b) -> a -> b   
Right-associative application with strict evaluation of its argument to a non-variable term.
($##) :: (a -> b) -> a -> b   
Right-associative 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 non-reducible 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   
Less-than on ground data terms.
(>) :: a -> a -> Bool   
Greater-than on ground data terms.
(<=) :: a -> a -> Bool   
Less-or-equal on ground data terms.
(>=) :: a -> a -> Bool   
Greater-or-equal 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 non-empty 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 non-empty 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 an ASCII value into a character.
prim_chr :: Int -> Char   
(+) :: Int -> Int -> Int   
Adds two integers.
prim_Int_plus :: Int -> Int -> Int   
(-) :: Int -> Int -> Int   
Subtracts two integers.
prim_Int_minus :: Int -> Int -> Int   
(*) :: Int -> Int -> Int   
Multiplies two integers.
prim_Int_times :: Int -> Int -> Int   
div :: Int -> Int -> Int   
Integer division.
prim_Int_div :: Int -> Int -> Int   
mod :: Int -> Int -> Int   
Integer remainder.
prim_Int_mod :: Int -> Int -> Int   
divMod :: Int -> Int -> (Int,Int)   
Returns an integer (quotient,remainder) pair.
quot :: Int -> Int -> Int   
Integer division.
prim_Int_quot :: Int -> Int -> Int   
rem :: Int -> Int -> Int   
Integer remainder.
prim_Int_rem :: Int -> Int -> Int   
quotRem :: Int -> Int -> (Int,Int)   
Returns an integer (quotient,remainder) pair.
negate :: Int -> Int   
Unary minus.
negateFloat :: Float -> Float   
Unary minus on Floats.
prim_negateFloat :: Float -> Float   
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   
prim_readFileContents :: String -> 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.
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   
Non-deterministic 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   
(=:<=) :: a -> a -> Bool   
Non-strict equational constraint.
(=:<<=) :: a -> a -> Bool   
Non-strict equational constraint for linear functional patterns.
ifVar :: a -> b -> b -> b   
internal function to implement =:<=
failure :: a -> b -> c   
internal operation to implement failure reporting

Exported datatypes:


Int

Constructors:


Float

Constructors:


Char

Constructors:


String

Type synonym: String = [Char]


Bool

Constructors:

  • False :: Bool
  • True :: Bool

Ordering

Ordering type. Useful as a result of comparison functions.

Constructors:

  • LT :: Ordering
  • EQ :: Ordering
  • GT :: Ordering

Success

Type synonym: Success = Bool


Maybe

Constructors:

  • Nothing :: Maybe a
  • Just :: a -> Maybe a

Either

Constructors:

  • Left :: a -> Either a b
  • Right :: b -> Either a b

IO

Constructors:


IOError

The (abstract) type of error values. Currently, it distinguishes between general IO errors, user-generated errors (see userError), failures and non-determinism 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

DET

Identity type synonym used to mark deterministic operations.

Type synonym: DET a = a


Exported operations:

(.) :: (a -> b) -> (c -> a) -> c -> b   

Function composition.

Further infos:
  • defined as right-associative infix operator with precedence 9

id :: a -> a   

Identity function.

Further infos:
  • solution complete, i.e., able to compute all solutions

const :: a -> b -> a   

Constant function.

Further infos:
  • solution complete, i.e., able to compute all solutions

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.

Further infos:
  • defined as right-associative infix operator with precedence 0

ensureNotFree :: a -> a   

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

Further infos:
  • externally defined

ensureSpine :: [a] -> [a]   

Evaluates the argument to spine form and returns it. Suspends until the result is bound to a non-variable spine.

($) :: (a -> b) -> a -> b   

Right-associative application.

Further infos:
  • defined as right-associative infix operator with precedence 0

($!) :: (a -> b) -> a -> b   

Right-associative application with strict evaluation of its argument to head normal form.

Further infos:
  • defined as right-associative infix operator with precedence 0
  • externally defined

($!!) :: (a -> b) -> a -> b   

Right-associative application with strict evaluation of its argument to normal form.

Further infos:
  • defined as right-associative infix operator with precedence 0
  • externally defined

($#) :: (a -> b) -> a -> b   

Right-associative application with strict evaluation of its argument to a non-variable term.

Further infos:
  • defined as right-associative infix operator with precedence 0

($##) :: (a -> b) -> a -> b   

Right-associative application with strict evaluation of its argument to ground normal form.

Further infos:
  • defined as right-associative infix operator with precedence 0
  • externally defined

error :: String -> a   

Aborts the execution with an error message.

prim_error :: String -> a   

Further infos:
  • externally defined

failed :: a   

A non-reducible polymorphic function. It is useful to express a failure in a search branch of the execution. It could be defined by: failed = head []

Further infos:
  • externally defined

(&&) :: Bool -> Bool -> Bool   

Sequential conjunction on Booleans.

Further infos:
  • defined as right-associative infix operator with precedence 3
  • solution complete, i.e., able to compute all solutions

(||) :: Bool -> Bool -> Bool   

Sequential disjunction on Booleans.

Further infos:
  • defined as right-associative infix operator with precedence 2
  • solution complete, i.e., able to compute all solutions

not :: Bool -> Bool   

Negation on Booleans.

Further infos:
  • solution complete, i.e., able to compute all solutions

otherwise :: Bool   

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

Further infos:
  • solution complete, i.e., able to compute all solutions

if_then_else :: Bool -> a -> a -> a   

The standard conditional. It suspends if the condition is a free variable.

solve :: Bool -> Bool   

Enforce a Boolean condition to be true. The computation fails if the argument evaluates to False.

Further infos:
  • partially defined
  • solution complete, i.e., able to compute all solutions

(&>) :: Bool -> a -> a   

Conditional expression. An expression like (c &> e) is evaluated by evaluating the first argument to True and then evaluating e. The expression has no value if the condition does not evaluate to True.

Further infos:
  • defined as right-associative infix operator with precedence 0
  • partially defined
  • solution complete, i.e., able to compute all solutions

(==) :: a -> a -> Bool   

Equality on finite ground data terms.

Further infos:
  • defined as non-associative infix operator with precedence 4
  • externally defined

(/=) :: a -> a -> Bool   

Disequality.

Further infos:
  • defined as non-associative infix operator with precedence 4

(=:=) :: a -> a -> Bool   

The equational constraint. (e1 =:= e2) is satisfiable if both sides e1 and e2 can be reduced to a unifiable data term (i.e., a term without defined function symbols).

Further infos:
  • defined as non-associative infix operator with precedence 4
  • solution complete, i.e., able to compute all solutions
  • externally defined

(&) :: Bool -> Bool -> Bool   

Concurrent conjunction. An expression like (c1 & c2) is evaluated by evaluating the c1 and c2 in a concurrent manner.

Further infos:
  • defined as right-associative infix operator with precedence 0
  • solution complete, i.e., able to compute all solutions
  • externally defined

compare :: a -> a -> Ordering   

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.

Further infos:
  • externally defined

(<) :: a -> a -> Bool   

Less-than on ground data terms.

Further infos:
  • defined as non-associative infix operator with precedence 4

(>) :: a -> a -> Bool   

Greater-than on ground data terms.

Further infos:
  • defined as non-associative infix operator with precedence 4

(<=) :: a -> a -> Bool   

Less-or-equal on ground data terms.

Further infos:
  • defined as non-associative infix operator with precedence 4

(>=) :: a -> a -> Bool   

Greater-or-equal on ground data terms.

Further infos:
  • defined as non-associative infix operator with precedence 4

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.

Further infos:
  • solution complete, i.e., able to compute all solutions

snd :: (a,b) -> b   

Selects the second component of a pair.

Further infos:
  • solution complete, i.e., able to compute all solutions

tail :: [a] -> [a]   

Computes the remaining elements of a list.

Further infos:
  • partially defined
  • solution complete, i.e., able to compute all solutions

null :: [a] -> Bool   

Is a list empty?

Further infos:
  • solution complete, i.e., able to compute all solutions

(++) :: [a] -> [a] -> [a]   

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

Further infos:
  • defined as right-associative infix operator with precedence 5
  • solution complete, i.e., able to compute all solutions

length :: [a] -> Int   

Computes the length of a list.

(!!) :: [a] -> Int -> a   

List index (subscript) operator, head has index 0.

Further infos:
  • defined as left-associative infix operator with precedence 9
  • partially defined

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. Thus,

foldl f z [x1,x2,...,xn] = (...((z `f` x1) `f` x2) ...) `f` xn

foldl1 :: (a -> a -> a) -> [a] -> a   

Accumulates a non-empty list from left to right.

Further infos:
  • partially defined

foldr :: (a -> b -> b) -> b -> [a] -> b   

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)...))

foldr1 :: (a -> a -> a) -> [a] -> a   

Accumulates a non-empty list from right to left:

Further infos:
  • partially defined

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. If one input list is shorter than the other, the additional elements of the longer list are discarded.

Further infos:
  • solution complete, i.e., able to compute all solutions

zip3 :: [a] -> [b] -> [c] -> [(a,b,c)]   

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.

Further infos:
  • solution complete, i.e., able to compute all solutions

zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]   

Joins two lists into one list by applying a combination function to corresponding pairs of elements. Thus zip = zipWith (,)

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. Thus zip3 = zipWith3 (,,)

unzip :: [(a,b)] -> ([a],[b])   

Transforms a list of pairs into a pair of lists.

Further infos:
  • solution complete, i.e., able to compute all solutions

unzip3 :: [(a,b,c)] -> ([a],[b],[c])   

Transforms a list of triples into a triple of lists.

Further infos:
  • solution complete, i.e., able to compute all solutions

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. Thus, iterate f x = [x, f x, f (f x),...]

repeat :: a -> [a]   

Infinite list where all elements have the same value. Thus, repeat x = [x, x, x,...]

Further infos:
  • solution complete, i.e., able to compute all solutions

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). Thus, it breaks a list at the first occurrence of an element satisfying p.

lines :: String -> [String]   

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.

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?

Further infos:
  • defined as non-associative infix operator with precedence 4

notElem :: a -> [a] -> Bool   

Not element of a list?

Further infos:
  • defined as non-associative infix operator with precedence 4

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   

Further infos:
  • externally defined

chr :: Int -> Char   

Converts an ASCII value into a character.

prim_chr :: Int -> Char   

Further infos:
  • externally defined

(+) :: Int -> Int -> Int   

Adds two integers.

Further infos:
  • defined as left-associative infix operator with precedence 6

prim_Int_plus :: Int -> Int -> Int   

Further infos:
  • externally defined

(-) :: Int -> Int -> Int   

Subtracts two integers.

Further infos:
  • defined as left-associative infix operator with precedence 6

prim_Int_minus :: Int -> Int -> Int   

Further infos:
  • externally defined

(*) :: Int -> Int -> Int   

Multiplies two integers.

Further infos:
  • defined as left-associative infix operator with precedence 7

prim_Int_times :: Int -> Int -> Int   

Further infos:
  • externally defined

div :: Int -> Int -> Int   

Integer division. The value is the integer quotient of its arguments and always truncated towards negative infinity. Thus, the value of 13 div 5 is 2, and the value of -15 div 4 is -4.

Further infos:
  • defined as left-associative infix operator with precedence 7

prim_Int_div :: Int -> Int -> Int   

Further infos:
  • externally defined

mod :: Int -> Int -> Int   

Integer remainder. The value is the remainder of the integer division and it obeys the rule x mod y = x - y * (x `div` y). Thus, the value of 13 `mod` 5 is 3, and the value of -15 `mod` 4 is -3.

Further infos:
  • defined as left-associative infix operator with precedence 7

prim_Int_mod :: Int -> Int -> Int   

Further infos:
  • externally defined

divMod :: Int -> Int -> (Int,Int)   

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

quot :: Int -> Int -> Int   

Integer division. The value is the integer quotient of its arguments and always truncated towards zero. Thus, the value of 13 quot 5 is 2, and the value of -15 quot 4 is -3.

Further infos:
  • defined as left-associative infix operator with precedence 7

prim_Int_quot :: Int -> Int -> Int   

Further infos:
  • externally defined

rem :: Int -> Int -> Int   

Integer remainder. The value is the remainder of the integer division and it obeys the rule x rem y = x - y * (x `quot` y). Thus, the value of 13 `rem` 5 is 3, and the value of -15 `rem` 4 is -3.

Further infos:
  • defined as left-associative infix operator with precedence 7

prim_Int_rem :: Int -> Int -> Int   

Further infos:
  • externally defined

quotRem :: Int -> Int -> (Int,Int)   

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

negate :: Int -> Int   

Unary minus. Usually written as "- e".

negateFloat :: Float -> Float   

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

prim_negateFloat :: Float -> Float   

Further infos:
  • externally defined

success :: Bool   

The always satisfiable constraint.

Further infos:
  • solution complete, i.e., able to compute all solutions

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.

Example call:
(a >>= fa)
Parameters:
  • a : An action
  • fa : A function from a value into an action
Returns:
An action that first performs a (yielding result r) and then performs (fa r)
Further infos:
  • defined as left-associative infix operator with precedence 1
  • externally defined

return :: a -> IO a   

The empty action that directly returns its argument.

Further infos:
  • solution complete, i.e., able to compute all solutions
  • externally defined

(>>) :: IO a -> IO b -> IO b   

Sequential composition of actions.

Example call:
(a1 >> a2)
Parameters:
  • a1 : An action
  • a2 : An action
Returns:
An action that first performs a1 and then a2
Further infos:
  • defined as left-associative infix operator with precedence 1

done :: IO ()   

The empty action that returns nothing.

Further infos:
  • solution complete, i.e., able to compute all solutions

putChar :: Char -> IO ()   

An action that puts its character argument on standard output.

prim_putChar :: Char -> IO ()   

Further infos:
  • externally defined

getChar :: IO Char   

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

Further infos:
  • externally defined

readFile :: String -> IO String   

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

prim_readFile :: String -> IO String   

Further infos:
  • externally defined

prim_readFileContents :: String -> String   

Further infos:
  • externally defined

writeFile :: String -> String -> IO ()   

An action that writes a file.

Example call:
(writeFile filename contents)
Parameters:
  • filename : The name of the file to be written.
  • contents : The contents to be written to the file.

prim_writeFile :: String -> String -> IO ()   

Further infos:
  • externally defined

appendFile :: String -> String -> IO ()   

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

Example call:
(appendFile filename contents)
Parameters:
  • filename : The name of the file to be written.
  • contents : The contents to be appended to the file.

prim_appendFile :: String -> String -> IO ()   

Further infos:
  • externally defined

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.

Further infos:
  • solution complete, i.e., able to compute all solutions

ioError :: IOError -> IO a   

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

showError :: IOError -> String   

Shows an error values as a string.

Further infos:
  • solution complete, i.e., able to compute all solutions

catch :: IO a -> (IOError -> IO a) -> IO a   

Catches a possible error or failure during the execution of an I/O action. (catch act errfun) executes the I/O action act. If an exception or failure occurs during this I/O action, the function errfun is applied to the error value.

Further infos:
  • externally defined

show :: a -> String   

Converts an arbitrary term into an external string representation.

prim_show :: a -> String   

Further infos:
  • externally defined

print :: a -> IO ()   

Converts a term into a string and prints it.

doSolve :: Bool -> IO ()   

Solves a constraint as an I/O action. Note: the constraint should be always solvable in a deterministic way

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. The results of all I/O actions are collected in a list.

mapIO_ :: (a -> IO b) -> [a] -> IO ()   

Maps an I/O action function on a list of elements. The results of all I/O actions are ignored.

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.

This can be useful if the definition of the function is longer than those of the list, like in

forIO [1..10] $ \n -> do ...

forIO_ :: [a] -> (a -> IO b) -> IO ()   

Like mapIO_, but with flipped arguments.

This can be useful if the definition of the function is longer than those of the list, like in

forIO_ [1..10] $ \n -> do ...

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   

Non-deterministic choice par excellence. The value of x ? y is either x or y.

Example call:
(x ? y)
Parameters:
  • x : The right argument.
  • y : The left argument.
Returns:
either x or y non-deterministically.
Further infos:
  • defined as right-associative infix operator with precedence 0
  • solution complete, i.e., able to compute all solutions

anyOf :: [a] -> a   

unknown :: a   

Evaluates to a fresh free variable.

Further infos:
  • solution complete, i.e., able to compute all solutions

PEVAL :: a -> a   

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

Further infos:
  • solution complete, i.e., able to compute all solutions

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. Suspends as long as the normal form of the argument is not ground.

apply :: (a -> b) -> a -> b   

Further infos:
  • externally defined

cond :: Bool -> a -> a   

Further infos:
  • externally defined

letrec :: a -> a -> Bool   

Further infos:
  • externally defined

(=:<=) :: a -> a -> Bool   

Non-strict equational constraint. Used to implement functional patterns.

Further infos:
  • defined as non-associative infix operator with precedence 4
  • externally defined

(=:<<=) :: a -> a -> Bool   

Non-strict 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.

Further infos:
  • defined as non-associative infix operator with precedence 4
  • externally defined

ifVar :: a -> b -> b -> b   

internal function to implement =:<=

Further infos:
  • externally defined

failure :: a -> b -> c   

internal operation to implement failure reporting

Further infos:
  • externally defined