Module "Prelude.curry"

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

Datatypes:
() | (,) | (,,) | (,,,) | (,,,,) | (,,,,,) | (,,,,,,) | (,,,,,,,) | (,,,,,,,,) | (,,,,,,,,,) | (,,,,,,,,,,) | (,,,,,,,,,,,) | (,,,,,,,,,,,,) | (,,,,,,,,,,,,,) | (,,,,,,,,,,,,,,) | Bool | Char | Either | Float | Int | IO | Maybe | Ordering | String | Success | []

Constructors:
() | (,) | (,,) | (,,,) | (,,,,) | (,,,,,) | (,,,,,,) | (,,,,,,,) | (,,,,,,,,) | (,,,,,,,,,) | (,,,,,,,,,,) | (,,,,,,,,,,,) | (,,,,,,,,,,,,) | (,,,,,,,,,,,,,) | (,,,,,,,,,,,,,,) | : | EQ | False | GT | Just | Left | LT | Nothing | Right | True | []

Functions:
!! | $ | $! | $!! | $# | $## | & | && | &> | * | + | ++ | - | . | /= | < | <= | =:<<= | =:<= | =:= | == | > | >= | >> | >>= | ? | all | and | any | appendFile | apply | best | break | browse | browseList | catchFail | chr | compare | concat | concatMap | cond | const | curry | div | done | doSolve | drop | dropWhile | either | elem | ensureNotFree | ensureSpine | enumFrom | enumFromThen | enumFromThenTo | enumFromTo | error | failed | failure | filter | findall | findfirst | flip | foldl | foldl1 | foldr | foldr1 | fst | getAllValues | getChar | getLine | getSomeValue | groundNormalForm | head | id | ifVar | if_then_else | inject | iterate | length | letrec | lines | lookup | map | mapIO | mapIO_ | max | maybe | min | mod | negate | negateFloat | normalForm | not | notElem | null | once | or | ord | otherwise | prim_appendFile | prim_chr | prim_error | prim_Int_div | prim_Int_minus | prim_Int_mod | prim_Int_plus | prim_Int_times | prim_negateFloat | prim_ord | prim_putChar | prim_readFile | prim_readFileContents | prim_show | prim_writeFile | print | putChar | putStr | putStrLn | PEVAL | readFile | repeat | replicate | return | reverse | seq | sequenceIO | sequenceIO_ | show | snd | solveAll | solveAll2 | span | splitAt | success | tail | take | takeWhile | try | uncurry | unknown | unlines | unpack | until | unwords | unzip | unzip3 | words | writeFile | zip | zip3 | zipWith | zipWith3 | ||

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

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

(==)  :: a -> a -> Bool              Equality on finite ground data terms.

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

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

negate  :: Int -> Int              Unary minus.

negateFloat  :: Float -> Float              Unary minus on Floats.

prim_negateFloat  :: Float -> Float

(=:=)  :: a -> a -> Success              The equational constraint.

success  :: Success              The always satisfiable constraint.

(&)  :: Success -> Success -> Success              Concurrent conjunction on constraints.

(&>)  :: Success -> a -> a              Constrained expression.

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

catchFail  :: IO a -> IO a -> IO a              Catches a possible failure during the execution of an I/O action.

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.

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  :: Success -> 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.

(?)  :: a -> a -> a              Non-deterministic choice par excellence.

unknown  :: a              Evaluates to a fresh free variable.

getAllValues  :: a -> IO [a]              Gets all values of an expression (currently, via an incomplete depth-first strategy).

getSomeValue  :: a -> IO a              Gets a value of an expression (currently, via an incomplete depth-first strategy).

try  :: (a -> Success) -> [a -> Success]              Basic search control operator.

inject  :: (a -> Success) -> (a -> Success) -> a -> Success              Inject operator which adds the application of the unary procedure p to the search variable to the search goal taken from Oz.

solveAll  :: (a -> Success) -> [a -> Success]              Computes all solutions via a a depth-first strategy.

solveAll2  :: (a -> Success) -> [a -> Success]

once  :: (a -> Success) -> a -> Success              Gets the first solution via a depth-first strategy.

best  :: (a -> Success) -> (a -> a -> Bool) -> [a -> Success]              Gets the best solution via a depth-first strategy according to a specified operator that can always take a decision which of two solutions is better.

findall  :: (a -> Success) -> [a]              Gets all solutions via a depth-first strategy and unpack the values from the lambda-abstractions.

findfirst  :: (a -> Success) -> a              Gets the first solution via a depth-first strategy and unpack the values from the search goals.

browse  :: (a -> Success) -> IO ()              Shows the solution of a solved constraint.

browseList  :: [a -> Success] -> IO ()              Unpacks solutions from a list of lambda abstractions and write them to the screen.

unpack  :: (a -> Success) -> a              Unpacks a solution's value from a (solved) search goal.

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  :: Success -> a -> a

letrec  :: a -> a -> Success

(=:<=)  :: a -> a -> Success              Non-strict equational constraint.

(=:<<=)  :: a -> a -> Success              Non-strict equational constraint for linear function patterns.

ifVar  :: a -> b -> b -> b              internal function to implement =:<=

failure  :: a -> b -> c              internal operation to implement failure reporting

()

Constructors:

() :: ()

[]

Constructors:

[] :: [] a

: :: a -> [a] -> [] a

(,)

Constructors:

(,) :: a -> b -> (,) a b

(,,)

Constructors:

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

(,,,)

Constructors:

(,,,) :: a -> b -> c -> d -> (,,,) a b c d

(,,,,)

Constructors:

(,,,,) :: a -> b -> c -> d -> e -> (,,,,) a b c d e

(,,,,,)

Constructors:

(,,,,,) :: a -> b -> c -> d -> e -> f -> (,,,,,) a b c d e f

(,,,,,,)

Constructors:

(,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> (,,,,,,) a b c d e f g

(,,,,,,,)

Constructors:

(,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> (,,,,,,,) a b c d e f g h

(,,,,,,,,)

Constructors:

(,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> (,,,,,,,,) a b c d e f g h i

(,,,,,,,,,)

Constructors:

(,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> (,,,,,,,,,) a b c d e f g h i j

(,,,,,,,,,,)

Constructors:

(,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> (,,,,,,,,,,) a b c d e f g h i j k

(,,,,,,,,,,,)

Constructors:

(,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> (,,,,,,,,,,,) a b c d e f g h i j k l

(,,,,,,,,,,,,)

Constructors:

(,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> (,,,,,,,,,,,,) a b c d e f g h i j k l m

(,,,,,,,,,,,,,)

Constructors:

(,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> (,,,,,,,,,,,,,) a b c d e f g h i j k l m n

(,,,,,,,,,,,,,,)

Constructors:

(,,,,,,,,,,,,,,) :: a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m -> n -> o -> (,,,,,,,,,,,,,,) a b c d e f g h i j k l m n o

String

Type synonym: String = [Char]

Int

Constructors:

---

Float

Constructors:

---

Char

Constructors:

---

Bool

Constructors:

False :: Bool

True :: Bool

---

Ordering

Ordering type. Useful as a result of comparison functions.

Constructors:

LT :: Ordering

EQ :: Ordering

GT :: Ordering

---

Success

Constructors:

---

Maybe

Constructors:

Nothing :: Maybe a

Just :: a -> Maybe a

---

Either

Constructors:

Left :: a -> Either a b

Right :: b -> Either a b

---

IO

Constructors:

---

---

Exported functions:

---

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

Further infos:

• incompletely 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
• externally defined

---

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.

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 normal form.

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

---

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.

---

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

---

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
• incompletely defined

---

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

Greater-than on ground data terms.

Further infos:

• defined as non-associative infix operator with precedence 4
• incompletely defined

---

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

Further infos:

• incompletely defined

---

min :: a -> a -> a   

Minimum of ground data terms.

Further infos:

• incompletely defined

---

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.

Further infos:

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

---

tail :: [a] -> [a]   

Computes the remaining elements of a list.

Further infos:

• incompletely 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
• incompletely 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:

• incompletely 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:

• incompletely defined

---

filter :: (a -> Bool) -> [a] -> [a]   

Filters all elements satisfying a given predicate in a list.

Further infos:

• incompletely defined

---

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.

Further infos:

• incompletely defined

---

drop :: Int -> [a] -> [a]   

Returns suffix without first n elements.

Further infos:

• incompletely defined

---

splitAt :: Int -> [a] -> ([a],[a])   

(splitAt n xs) is equivalent to (take n xs, drop n xs)

Further infos:

• incompletely defined

---

takeWhile :: (a -> Bool) -> [a] -> [a]   

Returns longest prefix with elements satisfying a predicate.

Further infos:

• incompletely defined

---

dropWhile :: (a -> Bool) -> [a] -> [a]   

Returns suffix without takeWhile prefix.

Further infos:

• incompletely defined

---

span :: (a -> Bool) -> [a] -> ([a],[a])   

(span p xs) is equivalent to (takeWhile p xs, dropWhile p xs)

Further infos:

• incompletely defined

---

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.

Further infos:

• incompletely defined

---

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.

Further infos:

• incompletely defined

---

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.

Further infos:

• incompletely defined

---

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 zero. Thus, the value of 13 `div` 5 is 2, and the value of -15 `div` 4 is -3.

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

---

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

---

(=:=) :: a -> a -> Success   

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

---

success :: Success   

The always satisfiable constraint.

Further infos:

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

---

(&) :: Success -> Success -> Success   

Concurrent conjunction on constraints. An expression like (c1 & c2) is evaluated by evaluating the constraints 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

---

(&>) :: Success -> a -> a   

Constrained expression. An expression like (c &> e) is evaluated by first solving constraint c and then evaluating e.

Further infos:

• defined as right-associative infix operator with precedence 0

---

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

---

catchFail :: IO a -> IO a -> IO a   

Catches a possible failure during the execution of an I/O action. (catchFail act err): apply action act and, if it fails, apply action err

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.

---

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 :: Success -> 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.

---

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

---

unknown :: a   

Evaluates to a fresh free variable.

Further infos:

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

---

getAllValues :: a -> IO [a]   

Gets all values of an expression (currently, via an incomplete depth-first strategy). Conceptually, all values are computed on a copy of the expression, i.e., the evaluation of the expression does not share any results. Moreover, the evaluation suspends as long as the expression contains unbound variables. Similar to Prolog's findall.

---

getSomeValue :: a -> IO a   

Gets a value of an expression (currently, via an incomplete depth-first strategy). The expression must have a value, otherwise the computation fails. Conceptually, the value is computed on a copy of the expression, i.e., the evaluation of the expression does not share any results. Moreover, the evaluation suspends as long as the expression contains unbound variables.

---

try :: (a -> Success) -> [a -> Success]   

Basic search control operator.

Further infos:

• externally defined

---

inject :: (a -> Success) -> (a -> Success) -> a -> Success   

Inject operator which adds the application of the unary procedure p to the search variable to the search goal taken from Oz. p x comes before g x to enable a test+generate form in a sequential implementation.

---

solveAll :: (a -> Success) -> [a -> Success]   

Computes all solutions via a a depth-first strategy.

---

solveAll2 :: (a -> Success) -> [a -> Success]   

---

once :: (a -> Success) -> a -> Success   

Gets the first solution via a depth-first strategy.

---

best :: (a -> Success) -> (a -> a -> Bool) -> [a -> Success]   

Gets the best solution via a depth-first strategy according to a specified operator that can always take a decision which of two solutions is better. In general, the comparison operation should be rigid in its arguments!

---

findall :: (a -> Success) -> [a]   

Gets all solutions via a depth-first strategy and unpack the values from the lambda-abstractions. Similar to Prolog's findall.

---

findfirst :: (a -> Success) -> a   

Gets the first solution via a depth-first strategy and unpack the values from the search goals.

---

browse :: (a -> Success) -> IO ()   

Shows the solution of a solved constraint.

---

browseList :: [a -> Success] -> IO ()   

Unpacks solutions from a list of lambda abstractions and write them to the screen.

---

unpack :: (a -> Success) -> a   

Unpacks a solution's value from a (solved) search goal.

---

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 :: Success -> a -> a   

Further infos:

• externally defined

---

letrec :: a -> a -> Success   

Further infos:

• externally defined

---

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

Non-strict equational constraint. Experimental.

Further infos:

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

---

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

Non-strict equational constraint for linear function 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

---

---

Generated by CurryDoc (Version 0.4.1 of June 7, 2007) at Nov 9 17:59:19 2009