aop-prelude-0.2.0.0: prelude for Algebra of Programming

AOPPrelude

# Documentation

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

const :: p1 -> p2 -> p1 Source #

id :: p -> p Source #

outl :: (a, b) -> a Source #

outr :: (a, b) -> b Source #

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

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

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

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

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

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

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

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

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

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

false :: p -> Bool Source #

true :: p -> Bool Source #

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

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

not :: Bool -> Bool Source #

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

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

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

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

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

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

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

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

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

zero :: p -> Integer Source #

succ :: Integer -> Integer Source #

pred :: Integer Source #

plus :: (Integer, Integer) -> Integer Source #

minus :: (Integer, Integer) -> Integer Source #

times :: (Integer, Integer) -> Integer Source #

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

negative :: Integer -> Bool Source #

positive :: Integer -> Bool Source #

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

null :: [a] -> Bool Source #

nil :: p -> [a] Source #

wrap :: a -> [a] Source #

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

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

concat :: [[a]] -> [a] Source #

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

head :: [a] -> a Source #

tail :: [a] -> [a] Source #

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

last :: [a] -> a Source #

init :: [a] -> [a] Source #

inits :: [a] -> [[a]] Source #

tails :: [a] -> [[a]] Source #

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

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

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

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

cplist :: [[a]] -> [[a]] Source #

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

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

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

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

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

length :: [a] -> Integer Source #

sum :: [Integer] -> Integer Source #

trans :: [[a]] -> [[a]] Source #

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

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

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

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

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

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

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

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

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

words :: [Char] -> [[Char]] Source #

lines :: [Char] -> [[Char]] Source #

unwords :: [[Char]] -> [Char] Source #

unlines :: [[Char]] -> [Char] Source #

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

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

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

show :: Show a => a -> String #

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