Module Prelude

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

The negation of strict equality.

Further infos:

• defined as non-associative infix operator with precedence 4

eqString :: String -> String -> Bool   

shows :: Show a => a -> String -> String   

Converts a showable value to a show function that prepends this value.

showChar :: Char -> String -> String   

Converts a character to a show function that prepends the character.

Further infos:

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

showString :: String -> String -> String   

Converts a string to a show function that prepends the string.

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

If the first argument is True, Converts a show function to a show function adding enclosing brackets, otherwise the show function is returned unchanged.

showTuple :: [String -> String] -> String -> String   

Converts a list of show functions to a show function combining the given show functions to a tuple representation.

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

A parser to read data from a string. For instance, reads "42" :: [(Int,String)] returns [(42,[])], and reads "hello" :: [(Int,String)] returns [].

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

readParen True p parses what p parses, but surrounded with parentheses. readParen False p parses what p parses, but the string to be parsed can be optionally with parentheses.

read :: Read a => String -> a   

Reads data of the given type from a string. The operations fails if the data cannot be parsed. For instance read "42" :: Int evaluates to 42, and read "hello" :: Int fails.

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

Reads a single lexeme from the given string. Initial white space is discarded and the characters of the lexeme are returned. If the input string contains only white space, lex returns the empty string as lexeme. If there is no legal lexeme at the beginning of the input string, the operation fails, i.e., [] is returned.

even :: Integral a => a -> Bool   

Returns whether an integer is even.

odd :: Integral a => a -> Bool   

Returns whether an integer is odd.

fromIntegral :: (Integral a, Num b) => a -> b   

General coercion from integral types.

realToFrac :: (Real a, Fractional b) => a -> b   

General coercion to fractional types.

(^) :: (Num a, Integral b) => a -> b -> a   

Raises a number to a non-negative integer power.

(<$>) :: Functor a => (b -> c) -> a b -> a c   

Further infos:

• defined as left-associative infix operator with precedence 4

liftM2 :: Monad a => (b -> c -> d) -> a b -> a c -> a d   

Promotes a function to a monad. The function arguments are scanned from left to right. For instance, liftM2 (+) [1,2] [3,4] evaluates to [4,5,5,6], and liftM2 (,) [1,2] [3,4] evaluates to [(1,3),(1,4),(2,3),(2,4)].

sequence :: Monad a => [a b] -> a [b]   

Executes a sequence of monadic actions and collects all results in a list.

sequence_ :: Monad a => [a b] -> a ()   

Executes 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. The results of all monadic actions are collected in a list.

mapM_ :: Monad a => (b -> a c) -> [b] -> a ()   

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

isUpper :: Char -> Bool   

Returns true if the argument is an uppercase letter.

isLower :: Char -> Bool   

Returns true if the argument is an lowercase letter.

isAlpha :: Char -> Bool   

Returns true if the argument is a letter.

isDigit :: Char -> Bool   

Returns true if the argument is a decimal digit.

isAlphaNum :: Char -> Bool   

Returns true if the argument is a letter or digit.

isBinDigit :: Char -> Bool   

Returns true if the argument is a binary digit.

isOctDigit :: Char -> Bool   

Returns true if the argument is an octal digit.

isHexDigit :: Char -> Bool   

Returns true if the argument is a hexadecimal digit.

isSpace :: Char -> Bool   

Returns true if the argument is a white space.

ord :: Char -> Int   

Converts a character into its ASCII value.

chr :: Int -> Char   

Converts a Unicode value into a character. The conversion is total, i.e., for out-of-bound values, the smallest or largest character is generated.

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.

($) :: (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

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.

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.

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

asTypeOf :: a -> a -> a   

asTypeOf is a type-restricted version of const. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.

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.

(&&) :: 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

ifThenElse :: Bool -> a -> a -> a   

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

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

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?

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

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

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

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?

Further infos:

• defined as non-associative infix operator with precedence 4

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

Not element of a list?

Further infos:

• defined as non-associative infix operator with precedence 4

lookup :: Eq a => a -> [(a,b)] -> Maybe b   

Looks up a key in an association list.

maybe :: a -> (b -> a) -> Maybe b -> a   

The maybe function takes a default value, a function, and a Maybe value. If the Maybe value is Nothing, the default value is returned. Otherwise, the function is applied to the value inside the Just and the result is returned.

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

Apply a case analysis to a value of the Either type. If the value is Left x, the first function is applied to x. If the value is Right y, the second function is applied to y.

getChar :: IO Char   

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

Further infos:

• externally defined

getLine :: IO String   

An action that reads a line from standard input and returns it.

putChar :: Char -> IO ()   

An action that puts its character argument on standard output.

putStr :: String -> IO ()   

Action to print a string on standard output.

putStrLn :: String -> IO ()   

Action to print a string with a newline on standard output.

print :: Show a => a -> IO ()   

Converts a term into a string and prints 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. It behaves like writeFile if the file does not exist.

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.

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

success :: Bool   

The always satisfiable constraint. It is included for backward compatibility and should be no longer used.

Further infos:

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

solve :: Bool -> Bool   

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

doSolve :: Bool -> IO ()   

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

(=:=) :: Data a => 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

constrEq :: a -> a -> Bool   

Internal operation to implement equational constraints. It is used by the strict equality optimizer but should not be used in regular programs.

Further infos:

• externally defined

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

Non-strict equational constraint. This operation is not intended to be used in source programs but it is used to implement functional patterns. Conceptually, (e1 =:<= e2) is satisfiable if e1 can be evaluated to some pattern (data term) that matches e2, i.e., e2 is an instance of this pattern. The Data context is required since the resulting pattern might be non-linear so that it abbreviates some further equational constraints, see Section 7.

Further infos:

• defined as non-associative infix operator with precedence 4

(=:<<=) :: Data a => 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

(&) :: 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

(&>) :: 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

(?) :: a -> a -> a   

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

Further infos:

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

anyOf :: [a] -> a   

Returns non-deterministically any element of a list.

unknown :: Data a => a   

Evaluates to a fresh free variable.

Further infos:

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

failed :: a   

A non-reducible polymorphic function. It is useful to express a failure in a search branch of the execution.

Further infos:

• externally defined

error :: String -> a   

Aborts the execution with an error message.

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

Further infos:

• externally defined

cond :: Bool -> a -> a   

Further infos:

• externally defined

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