# Module Prelude

The standard prelude of Curry with type classes. All exported functions, data types, type classes and methods defined in this module are always available in any Curry program.

## Summary of exported operations:

 ```(/==) :: Data a => a -> a -> Bool```    The negation of strict equality. ```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)]``` ```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``` ```(<\$>) :: Functor a => (b -> c) -> a b -> a c``` ```liftM2 :: Monad a => (b -> c -> d) -> a b -> a c -> a d``` ```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. ```mapM_ :: Monad a => (b -> a c) -> [b] -> a ()```    Maps an monadic action function on a list of elements. ```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. ```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. ```(\$) :: (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. ```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. ```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. ```(.) :: (a -> b) -> (c -> a) -> c -> b```    Function composition. ```id :: a -> a```    Identity function. ```const :: a -> b -> a```    Constant function. ```asTypeOf :: a -> a -> a```    `asTypeOf` is a type-restricted version of `const`. ```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. ```(||) :: 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. ```ifThenElse :: Bool -> a -> a -> a```    The standard conditional. ```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]```    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. ```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 . ```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. ```maybe :: a -> (b -> a) -> Maybe b -> a``` ```either :: (a -> b) -> (c -> b) -> Either a c -> b``` ```getChar :: IO Char```    An action that reads a character from standard output and returns it. ```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. ```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. ```catch :: IO a -> (IOError -> IO a) -> IO a```    Catches a possible error or failure during the execution of an I/O action. ```success :: Bool```    The always satisfiable constraint. ```solve :: Bool -> Bool```    Enforce a Boolean condition to be true. ```doSolve :: Bool -> IO ()```    Solves a constraint as an I/O action. ```(=:=) :: Data a => a -> a -> Bool```    The equational constraint. ```constrEq :: a -> a -> Bool```    Internal operation to implement equational constraints. ```(=:<=) :: Data a => a -> a -> Bool```    Non-strict equational constraint. ```(=:<<=) :: Data a => a -> a -> Bool```    Non-strict equational constraint for linear functional patterns. ```(&) :: Bool -> Bool -> Bool```    Concurrent conjunction. ```(&>) :: Bool -> a -> a```    Conditional expression. ```(?) :: a -> a -> a```    Non-deterministic choice par excellence. ```anyOf :: [a] -> a```    Returns non-deterministically any element of a list. ```unknown :: Data a => a```    Evaluates to a fresh free variable. ```failed :: a```    A non-reducible polymorphic function. ```error :: String -> a```    Aborts the execution with an error message. ```apply :: (a -> b) -> a -> b``` ```cond :: Bool -> a -> a``` ```letrec :: a -> a -> Bool``` ```failure :: a -> b -> c``` ```PEVAL :: a -> a```    Identity function used by the partial evaluator to mark expressions to be partially evaluated.

## Exported datatypes:

Char

Constructors:

Int

Constructors:

Float

Constructors:

Bool

Constructors:

• ```False :: Bool```
• ```True :: Bool```

Ordering

Constructors:

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

ShowS

Type synonym: `ShowS = String -> String`

Type synonym: `ReadS a = String -> [(a,String)]`

String

Type synonym: `String = [Char]`

Maybe

Constructors:

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

Either

Constructors:

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

IO

Constructors:

FilePath

Type synonym: `FilePath = String`

IOError

The (abstract) type of error values. Currently, it distinguishes between general I/O errors, user-generated errors (see userError), failures and non-determinism errors during I/O computations. These errors can be caught by catch. 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```

Success

Type synonym: `Success = Bool`

DET

Identity type synonym used to mark deterministic operations. Used by the Curry preprocessor.

Type synonym: `DET a = a`

## Exported operations:

 ```(/==) :: Data a => a -> a -> Bool```    The negation of strict equality. Further infos: defined as non-associative infix operator with precedence 4
 ```shows :: Show a => a -> String -> String```
 ```showChar :: Char -> String -> String```    Further infos: solution complete, i.e., able to compute all solutions
 ```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```    Further infos: partially defined
 ```lex :: String -> [(String,String)]```    Further infos: partially defined
 ```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```
 ```(<\$>) :: 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```
 ```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
 ```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]```    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. Further infos: partially defined
 ```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: 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.
 ```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```
 ```either :: (a -> b) -> (c -> b) -> Either a c -> b```
 ```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. 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`. Further infos: partially defined solution complete, i.e., able to compute all solutions
 ```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 partially defined solution complete, i.e., able to compute all solutions
 ```(?) :: 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
 ```letrec :: a -> a -> Bool```    Further infos: externally defined
 ```failure :: a -> b -> c```    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