AOPPrelude

Documentation

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

const :: a -> b -> a

id :: a -> a

outl :: (a, b) -> a

outr :: (a, b) -> b

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

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

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

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

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

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

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

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

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

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

false :: a -> Bool

true :: a -> 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 :: (a -> Bool, a -> Bool) -> a -> Bool

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

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

zero :: a -> Natural

succ :: Natural -> Natural

pred :: Natural -> Natural

plus :: Num a => (a, a) -> a

minus :: Num a => (a, a) -> a

times :: Num a => (a, a) -> a

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

negative :: (Ord a, Num a) => a -> Bool

positive :: (Ord a, Num a) => a -> Bool

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

null :: [a] -> Bool

nil :: t -> [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 :: ((a, a) -> Bool) -> [a] -> a

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

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

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

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

length :: [a] -> Natural

sum :: Num a => [a] -> a

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

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

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 :: [(a, b)] -> ([a], [b])

words :: String -> [String]

lines :: String -> [String]

unwords :: [String] -> String

unlines :: [String] -> String

ord :: Char -> Int

chr :: Int -> Char

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

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

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

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

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

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

(+) :: Num a => a -> a -> a

(-) :: Num a => a -> a -> a

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

div :: Integral a => a -> a -> a

mod :: Integral a => a -> a -> a

(*) :: Num a => a -> a -> a

negate :: Num a => a -> a

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

strict :: (a -> b) -> a -> b

error :: HasCallStack => [Char] -> a

show :: Show a => a -> String

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