semigroupoids-5.0.0.2: Semigroupoids: Category sans id

Copyright(C) 2011-2015 Edward Kmett
LicenseBSD-style (see the file LICENSE)
MaintainerEdward Kmett <ekmett@gmail.com>
Stabilityprovisional
Portabilityportable
Safe HaskellSafe
LanguageHaskell98

Data.Functor.Bind

Contents

Description

 

Synopsis

Functors

class Functor f where

The Functor class is used for types that can be mapped over. Instances of Functor should satisfy the following laws:

fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g

The instances of Functor for lists, Maybe and IO satisfy these laws.

Minimal complete definition

fmap

Methods

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

(<$) :: a -> f b -> f a infixl 4

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Instances

Functor [] 
Functor IO 
Functor Id 
Functor ZipList 
Functor Handler 
Functor STM 
Functor First 
Functor Last 
Functor ReadPrec 
Functor ReadP 
Functor Maybe 
Functor Id 
Functor Put 
Functor Identity 
Functor Digit 
Functor Node 
Functor Elem 
Functor Id 
Functor FingerTree 
Functor IntMap 
Functor Tree 
Functor Seq 
Functor ViewL 
Functor ViewR 
Functor Min 
Functor Max 
Functor First 
Functor Last 
Functor Option 
Functor NonEmpty 
Functor ((->) r) 
Functor (Either a) 
Functor ((,) a) 
Functor (ST s) 
Functor (StateL s) 
Functor (StateR s) 
Functor (Const m) 
Monad m => Functor (WrappedMonad m) 
Functor (ST s) 
Arrow a => Functor (ArrowMonad a) 
Functor (Proxy *) 
Functor (StateL s) 
Functor (StateR s) 
Bifunctor p => Functor (Join p) 
Functor m => Functor (IdentityT m) 
Functor (State s) 
Functor (Map k) 
Functor (Arg a) 
Functor f => Functor (Reverse f)

Derived instance.

Functor f => Functor (Backwards f)

Derived instance.

Functor m => Functor (MaybeT m) 
Functor m => Functor (ListT m) 
Functor f => Functor (Lift f) 
Functor (Constant a) 
Functor (HashMap k) 
Functor f => Functor (MaybeApply f) 
Functor f => Functor (WrappedApplicative f) 
Arrow a => Functor (WrappedArrow a b) 
Bifunctor p => Functor (WrappedBifunctor p a) 
Functor g => Functor (Joker g a) 
Bifunctor p => Functor (Flip p a) 
Functor (Clown f a) 
(Functor f, Functor g) => Functor (Coproduct f g) 
Functor w => Functor (TracedT m w) 
Functor w => Functor (StoreT s w) 
Functor w => Functor (EnvT e w) 
Functor (Cokleisli w a) 
Functor (Tagged k s) 
(Functor f, Functor g) => Functor (Sum f g) 
(Functor f, Functor g) => Functor (Product f g) 
(Functor f, Functor g) => Functor (Compose f g) 
Functor m => Functor (WriterT w m) 
Functor m => Functor (WriterT w m) 
Functor m => Functor (ErrorT e m) 
Functor m => Functor (ExceptT e m) 
Functor m => Functor (StateT s m) 
Functor m => Functor (StateT s m) 
Functor m => Functor (ReaderT r m) 
Functor (ContT r m) 
Functor f => Functor (Static f a) 
Typeable ((* -> *) -> Constraint) Functor 
(Functor f, Bifunctor p) => Functor (Tannen f p a) 
(Bifunctor p, Functor g) => Functor (Biff p f g a) 
Functor m => Functor (RWST r w s m) 
Functor m => Functor (RWST r w s m) 

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4

An infix synonym for fmap.

($>) :: Functor f => f a -> b -> f b infixl 4

Flipped version of <$.

Since: 4.7.0.0

Applyable functors

class Functor f => Apply f where Source

A strong lax semi-monoidal endofunctor. This is equivalent to an Applicative without pure.

Laws:

associative composition: (.) <$> u <.> v <.> w = u <.> (v <.> w)

Minimal complete definition

(<.>)

Methods

(<.>) :: f (a -> b) -> f a -> f b infixl 4 Source

(.>) :: f a -> f b -> f b infixl 4 Source

a  .> b = const id <$> a <.> b

(<.) :: f a -> f b -> f a infixl 4 Source

a <. b = const <$> a <.> b

Instances

Apply [] 
Apply IO 
Apply ZipList 
Apply Maybe 
Apply Identity 
Apply IntMap

An IntMap is not Applicative, but it is an instance of Apply

Apply Tree 
Apply Seq 
Apply Option 
Apply NonEmpty 
Apply ((->) m) 
Apply (Either a) 
Semigroup m => Apply ((,) m) 
Semigroup m => Apply (Const m) 
Monad m => Apply (WrappedMonad m) 
Biapply p => Apply (Join p) 
Apply w => Apply (IdentityT w) 
Ord k => Apply (Map k)

A Map is not Applicative, but it is an instance of Apply

Apply f => Apply (Reverse f) 
Apply f => Apply (Backwards f) 
(Functor m, Monad m) => Apply (MaybeT m) 
Apply m => Apply (ListT m) 
Apply f => Apply (Lift f) 
Semigroup f => Apply (Constant f) 
Apply f => Apply (MaybeApply f) 
Applicative f => Apply (WrappedApplicative f) 
Arrow a => Apply (WrappedArrow a b) 
Apply w => Apply (TracedT m w) 
(Apply w, Semigroup s) => Apply (StoreT s w) 
(Semigroup e, Apply w) => Apply (EnvT e w) 
Apply (Cokleisli w a) 
(Apply f, Apply g) => Apply (Product f g) 
(Apply f, Apply g) => Apply (Compose f g) 
(Apply m, Semigroup w) => Apply (WriterT w m) 
(Apply m, Semigroup w) => Apply (WriterT w m) 
(Functor m, Monad m) => Apply (ErrorT e m) 
(Functor m, Monad m) => Apply (ExceptT e m) 
Bind m => Apply (StateT s m) 
Bind m => Apply (StateT s m) 
Apply m => Apply (ReaderT e m) 
Apply (ContT r m) 
Apply f => Apply (Static f a) 
(Bind m, Semigroup w) => Apply (RWST r w s m) 
(Bind m, Semigroup w) => Apply (RWST r w s m) 

(<..>) :: Apply w => w a -> w (a -> b) -> w b infixl 4 Source

A variant of <.> with the arguments reversed.

liftF2 :: Apply w => (a -> b -> c) -> w a -> w b -> w c Source

Lift a binary function into a comonad with zipping

liftF3 :: Apply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d Source

Lift a ternary function into a comonad with zipping

Wrappers

newtype MaybeApply f a Source

Transform a Apply into an Applicative by adding a unit.

Constructors

MaybeApply 

Fields

runMaybeApply :: Either (f a) a
 

Bindable functors

class Apply m => Bind m where Source

A Monad sans return.

Minimal definition: Either join or >>-

If defining both, then the following laws (the default definitions) must hold:

join = (>>- id)
m >>- f = join (fmap f m)

Laws:

induced definition of <.>: f <.> x = f >>- (<$> x)

Finally, there are two associativity conditions:

associativity of (>>-):    (m >>- f) >>- g == m >>- (\x -> f x >>- g)
associativity of join:     join . join = join . fmap join

These can both be seen as special cases of the constraint that

associativity of (->-): (f ->- g) ->- h = f ->- (g ->- h)

Minimal complete definition

(>>-) | join

Methods

(>>-) :: m a -> (a -> m b) -> m b infixl 1 Source

join :: m (m a) -> m a Source

Instances

Bind [] 
Bind IO 
Bind Maybe 
Bind Identity 
Bind IntMap

An IntMap is not a Monad, but it is an instance of Bind

Bind Tree 
Bind Seq 
Bind Option 
Bind NonEmpty 
Bind ((->) m) 
Bind (Either a) 
Semigroup m => Bind ((,) m) 
Monad m => Bind (WrappedMonad m) 
Bind m => Bind (IdentityT m) 
Ord k => Bind (Map k)

A Map is not a Monad, but it is an instance of Bind

(Functor m, Monad m) => Bind (MaybeT m) 
(Apply m, Monad m) => Bind (ListT m) 
(Bind f, Bind g) => Bind (Product f g) 
(Bind m, Semigroup w) => Bind (WriterT w m) 
(Bind m, Semigroup w) => Bind (WriterT w m) 
(Functor m, Monad m) => Bind (ErrorT e m) 
(Functor m, Monad m) => Bind (ExceptT e m) 
Bind m => Bind (StateT s m) 
Bind m => Bind (StateT s m) 
Bind m => Bind (ReaderT e m) 
Bind (ContT r m) 
(Bind m, Semigroup w) => Bind (RWST r w s m) 
(Bind m, Semigroup w) => Bind (RWST r w s m) 

(-<<) :: Bind m => (a -> m b) -> m a -> m b infixr 1 Source

(-<-) :: Bind m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 Source

(->-) :: Bind m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Source

apDefault :: Bind f => f (a -> b) -> f a -> f b Source

returning :: Functor f => f a -> (a -> b) -> f b Source