aop-prelude-0.3.0.0: prelude for Algebra of Programming

Safe HaskellNone
LanguageHaskell2010

AOPPrelude

Synopsis

Documentation

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

const :: a -> b -> a Source #

id :: a -> a Source #

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

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

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

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

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

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

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

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

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

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

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

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

false :: a -> Bool Source #

true :: a -> Bool Source #

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

(||) :: Bool -> Bool -> Bool infixr 2 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 :: (a -> Bool, a -> Bool) -> a -> Bool Source #

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

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

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

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

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

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

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

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

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

null :: [a] -> Bool Source #

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

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

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

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

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

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

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

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

ord :: Char -> Int #

The fromEnum method restricted to the type Char.

chr :: Int -> Char #

The toEnum method restricted to the type Char.

(==) :: Eq a => a -> a -> Bool infix 4 #

(/=) :: Eq a => a -> a -> Bool infix 4 #

(<=) :: Ord a => a -> a -> Bool infix 4 #

(<) :: Ord a => a -> a -> Bool infix 4 #

(>=) :: Ord a => a -> a -> Bool infix 4 #

(>) :: Ord a => a -> a -> Bool infix 4 #

(+) :: Num a => a -> a -> a infixl 6 #

(-) :: Num a => a -> a -> a infixl 6 #

(/) :: Fractional a => a -> a -> a infixl 7 #

fractional division

div :: Integral a => a -> a -> a infixl 7 #

integer division truncated toward negative infinity

mod :: Integral a => a -> a -> a infixl 7 #

integer modulus, satisfying

(x `div` y)*y + (x `mod` y) == x

(*) :: Num a => a -> a -> a infixl 7 #

negate :: Num a => a -> a #

Unary negation.

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

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

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

error stops execution and displays an error message.

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

A specialised variant of showsPrec, using precedence context zero, and returning an ordinary String.

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