Copyright	(C) 2011-2015 Edward Kmett
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	provisional
Portability	portable
Safe Haskell	Safe
Language	Haskell98

Data.Functor.Bind.Class

Contents

Applyable functors
Wrappers
Bindable functors
Biappliable bifunctors

Description

This module is used to resolve the cyclic we get from defining these classes here rather than in a package upstream. Otherwise we'd get orphaned heads for many instances on the types in transformers and bifunctors.

Synopsis

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 Identity
Apply ZipList
Apply Maybe
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`
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)
Biapply p => Apply (Join * p)
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 (Compose f g)
(Apply f, Apply g) => Apply (Product 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)

Wrappers

newtype WrappedApplicative f a

Wrap an Applicative to be used as a member of Apply

Constructors

WrapApplicative
Fields unwrapApplicative :: f a

Instances

Functor f => Functor (WrappedApplicative f)
Applicative f => Applicative (WrappedApplicative f)
Alternative f => Alternative (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

(>>-) | join

Methods

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

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

Instances

Bind []
Bind IO
Bind Identity
Bind Maybe
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)

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

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

Biappliable bifunctors

class Bifunctor p => Biapply p where

Minimal complete definition

(<<.>>)

Methods

(<<.>>) :: p (a -> b) (c -> d) -> p a c -> p b d infixl 4

(.>>) :: p a b -> p c d -> p c d infixl 4

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

(<<.) :: p a b -> p c d -> p a b infixl 4

a <. b ≡ const <$> a <.> b

Instances

Biapply (,)
Biapply Const
Biapply Arg
Semigroup x => Biapply ((,,) x)
Biapply (Tagged *)
(Semigroup x, Semigroup y) => Biapply ((,,,) x y)
(Semigroup x, Semigroup y, Semigroup z) => Biapply ((,,,,) x y z)
Biapply p => Biapply (WrappedBifunctor * * p)
Apply g => Biapply (Joker * * g)
Biapply p => Biapply (Flip * * p)
Apply f => Biapply (Clown * * f)
(Biapply p, Biapply q) => Biapply (Product * * p q)
(Apply f, Biapply p) => Biapply (Tannen * * * f p)
(Biapply p, Apply f, Apply g) => Biapply (Biff * * * * p f g)