Portability | to be determined |
---|---|

Stability | experimental |

Maintainer | stephen.tetley@gmail.com |

Safe Haskell | Safe-Inferred |

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

This catalogue is for reference and is not intended for use.

- fmap :: (a -> b) -> (r -> a) -> r -> b
- (<$>) :: (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
- id :: a -> a
- (.) :: (b -> c) -> (a -> b) -> a -> c
- (<<<) :: (b -> c) -> (a -> b) -> a -> c
- (>>>) :: (a -> b) -> (b -> c) -> a -> c
- (>>=) :: (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
- 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
- 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]

# Functor

# Applicative

# Category

For the function instance of Category `id`

is just the
identity function (Haskell's `id`

).

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

For the function instance of Category composition is just
regular function composition aka `bluebird`

.

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

For the function instance of Category right-to-left
composition is just regular function composition aka
`bluebird`

.

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

For the function instance of Category left-to-right
composition is the `queer`

bird.

# Monad

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

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

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

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

# Arrow

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

The Arrow operation `arr`

corresponds to function
application for the function instance of Arrow - i.e.
Haskell's (`$`

) operator.

This is the `applicator`

combinator in
Data.Aviary.