AOPPrelude

Documentation

(.) :: (t1 -> t2) -> (t3 -> t1) -> t3 -> t2 infixr 9

const :: p1 -> p2 -> p1

id :: p -> p

outl :: (a, b) -> a

outr :: (a, b) -> b

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

assocl :: (a, (b1, b2)) -> ((a, b1), b2)

assocr :: ((a1, a2), b) -> (a1, (a2, b))

dupl :: (a, (b1, b2)) -> ((a, b1), (a, b2))

dupr :: ((a1, a2), b) -> ((a1, b), (a2, b))

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

cross :: (t1 -> a, t2 -> b) -> (t1, t2) -> (a, b)

cond :: (t -> Bool) -> (t -> p, t -> p) -> t -> p

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

uncurry :: (t1 -> t2 -> t3) -> (t1, t2) -> t3

false :: p -> Bool

true :: p -> Bool

(&&) :: Bool -> Bool -> Bool infixr 3

(||) :: Bool -> Bool -> Bool infixr 2

not :: Bool -> Bool

otherwise :: Bool

leq :: Ord a => (a, a) -> Bool

less :: Ord a => (a, a) -> Bool

eql :: Ord a => (a, a) -> Bool

neq :: Ord a => (a, a) -> Bool

gtr :: Ord a => (a, a) -> Bool

geq :: Ord a => (a, a) -> Bool

meet :: (p -> Bool, p -> Bool) -> p -> Bool

join :: (p -> Bool, p -> Bool) -> p -> Bool

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

zero :: p -> Integer

succ :: Integer -> Integer

pred :: Integer

plus :: (Integer, Integer) -> Integer

minus :: (Integer, Integer) -> Integer

times :: (Integer, Integer) -> Integer

divide :: Fractional a => (a, a) -> a

negative :: Integer -> Bool

positive :: Integer -> Bool

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

null :: [a] -> Bool

nil :: p -> [a]

wrap :: a -> [a]

cons :: (a, [a]) -> [a]

cat :: ([a], [a]) -> [a]

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

snoc :: ([a], a) -> [a]

head :: [a] -> a

tail :: [a] -> [a]

split :: [a] -> (a, [a])

last :: [a] -> a

init :: [a] -> [a]

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

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

splits :: [a] -> [([a], [a])]

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

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

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

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

minlist :: ((b, b) -> Bool) -> [b] -> b

bmin :: ((a, a) -> Bool) -> (a, a) -> a

maxlist :: ((b, b) -> Bool) -> [b] -> b

bmax :: ((a, a) -> Bool) -> (a, a) -> a

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

length :: [a] -> Integer

sum :: [Integer] -> Integer

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

list :: (t -> a) -> [t] -> [a]

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

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

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

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

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

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

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

unzip :: [(a1, a2)] -> ([a1], [a2])

words :: [Char] -> [[Char]]

lines :: [Char] -> [[Char]]

unwords :: [[Char]] -> [Char]

unlines :: [[Char]] -> [Char]

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

flip :: (t1 -> t2 -> t3) -> t2 -> t1 -> t3