Data.Aviary.Functional

Functor, Applicative, Monad operations specialized to the functional type.

This is for reference (obviously) and is not intended for use.

Functor

fmap :: (a -> b) -> (r -> a) -> r -> b

Applicative

(<$>) :: (a -> b) -> (r -> a) -> r -> b

(<$) :: a -> (r -> b) -> r -> a

pure :: a -> r -> a

(<*>) :: (r -> a -> b) -> (r -> a) -> r -> b

(*>) :: (r -> a) -> (r -> b) -> r -> b

(<*) :: (r -> a) -> (r -> b) -> r -> a

(<**>) :: (r -> a) -> (r -> a -> b) -> r -> b

liftA :: (a -> b) -> (r -> a) -> r -> b

liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c

liftA3 :: (a -> b -> c -> d) -> (r -> a) -> (r -> b) -> (r -> c) -> r -> d

Category

id :: a -> a

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

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

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

Monad

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b

(>>) :: (r -> a) -> (r -> b) -> r -> b

return :: a -> r -> a

fail :: String -> r -> a

mapM :: (a -> r -> b) -> [a] -> r -> [b]

mapM_ :: (a -> r -> b) -> [a] -> r -> ()

forM :: [a] -> (a -> r -> b) -> r -> [b]

forM_ :: [a] -> (a -> r -> b) -> r -> ()

sequence :: [r -> a] -> r -> [a]

sequence_ :: [r -> a] -> r -> ()

(=<<) :: (a -> r -> b) -> (r -> a) -> r -> b

(>=>) :: (a -> r -> b) -> (b -> r -> c) -> a -> r -> c

(<=<) :: (b -> r -> c) -> (a -> r -> b) -> a -> r -> c

forever :: (r -> a) -> r -> b

join :: (r -> r -> a) -> r -> a

filterM :: (a -> r -> Bool) -> [a] -> r -> [a]

mapAndUnzipM :: (a -> r -> (b, c)) -> [a] -> r -> ([b], [c])

zipWithM :: (a -> b -> r -> c) -> [a] -> [b] -> r -> [c]

zipWithM_ :: (a -> b -> r -> c) -> [a] -> [b] -> r -> ()

foldM :: (a -> b -> r -> a) -> a -> [b] -> r -> a

foldM_ :: (a -> b -> r -> a) -> a -> [b] -> r -> ()

replicateM :: Int -> (r -> a) -> r -> [a]

replicateM_ :: Int -> (r -> a) -> r -> ()

when :: Bool -> (r -> ()) -> r -> ()

unless :: Bool -> (r -> ()) -> r -> ()

liftM :: (a -> b) -> (r -> a) -> r -> b

liftM2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c

liftM3 :: (a -> b -> c -> d) -> (r -> a) -> (r -> b) -> (r -> c) -> r -> d

liftM4 :: (a -> b -> c -> d -> e) -> (r -> a) -> (r -> b) -> (r -> c) -> (r -> d) -> r -> e

liftM5 :: (a -> b -> c -> d -> e -> f) -> (r -> a) -> (r -> b) -> (r -> c) -> (r -> d) -> (r -> e) -> r -> f

ap :: (r -> a -> b) -> (r -> a) -> r -> b

Arrow

arr :: (b -> c) -> b -> c

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

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

(***) :: (b -> c) -> (b' -> c') -> (b, b') -> (c, c')

(&&&) :: (b -> c) -> (b -> c') -> b -> (c, c')

returnA :: b -> b

(^>>) :: (b -> c) -> (c -> d) -> b -> d

(>>^) :: (b -> c) -> (c -> d) -> b -> d

(<<^) :: (c -> d) -> (b -> c) -> b -> d

(^<<) :: (c -> d) -> (b -> c) -> b -> d

left :: (b -> c) -> Either b d -> Either c d

right :: (b -> c) -> Either d b -> Either d c

(+++) :: (b -> c) -> (b' -> c') -> Either b b' -> Either c c'

(|||) :: (b -> d) -> (c -> d) -> Either b c -> d

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

leftApp :: (b -> c) -> Either b d -> Either c d

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

Comonad

extract :: Monoid m => (m -> a) -> a

duplicate :: Monoid m => (m -> a) -> m -> m -> a

extend :: Monoid m => ((m -> a) -> b) -> (m -> a) -> m -> b

liftW :: Monoid m => (a -> b) -> (m -> a) -> m -> b

(=>>) :: Monoid m => (m -> a) -> ((m -> a) -> b) -> m -> b

(.>>) :: Monoid m => (m -> a) -> b -> m -> b

liftCtx :: Monoid m => (a -> b) -> (m -> a) -> b

mapW :: Monoid m => ((m -> a) -> b) -> (m -> [a]) -> [b]

parallelW :: Monoid m => (m -> [a]) -> [m -> a]

unfoldW :: Monoid m => ((m -> b) -> (a, b)) -> (m -> b) -> [a]

sequenceW :: Monoid m => [(m -> a) -> b] -> (m -> a) -> [b]