Data.Functor.Bind

NB: The definitions exported through Data.Functor.Apply need to be included here because otherwise the instances for the transformers package have orphaned heads.

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 ReadPrec

Functor ReadP

Functor Maybe

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 m => Functor (IdentityT m)

Functor (State s)

Functor (Map k)

Functor m => Functor (MaybeT m)

Functor m => Functor (ListT m)

Functor (HashMap k)

Functor f => Functor (MaybeApply f)

Functor f => Functor (WrappedApplicative f)

Arrow a => Functor (WrappedArrow a b)

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

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

Replace the contents of a functor uniformly with a constant value.

Applyable functors

class Functor f => Apply f where

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

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

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

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

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)

Apply w => Apply (IdentityT w)

Ord k => Apply (Map k)

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

(Functor m, Monad m) => Apply (MaybeT m)

Apply m => Apply (ListT m)

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

A variant of <.> with the arguments reversed.

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

Lift a binary function into a comonad with zipping

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

Lift a ternary function into a comonad with zipping

Wrappers

newtype WrappedApplicative f a

Wrap an Applicative to be used as a member of Apply

Constructors

WrapApplicative

Fields

unwrapApplicative :: f a

Instances

Alternative f => Alternative (WrappedApplicative f)

Functor f => Functor (WrappedApplicative f)

Applicative f => Applicative (WrappedApplicative f)

Applicative f => Apply (WrappedApplicative f)

Alternative f => Alt (WrappedApplicative f)

Alternative f => Plus (WrappedApplicative f)

newtype MaybeApply f a

Transform a Apply into an Applicative by adding a unit.

Constructors

MaybeApply

Fields

runMaybeApply :: Either (f a) a

Instances

Functor f => Functor (MaybeApply f)

Apply f => Applicative (MaybeApply f)

Comonad f => Comonad (MaybeApply f)

Extend f => Extend (MaybeApply f)

Apply f => Apply (MaybeApply f)

Bindable functors

class Apply m => Bind m where

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

Nothing

Methods

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

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

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

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

(->-) :: Bind m => (a -> m b) -> (b -> m c) -> a -> m c

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

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