| 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
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.
- class Functor f => Apply f where
- newtype WrappedApplicative f a = WrapApplicative {
- unwrapApplicative :: f a
- newtype MaybeApply f a = MaybeApply {
- runMaybeApply :: Either (f a) a
- class Apply m => Bind m where
- apDefault :: Bind f => f (a -> b) -> f a -> f b
- returning :: Functor f => f a -> (a -> b) -> f b
- class Bifunctor p => Biapply p where
Applyable functors
class Functor f => Apply f where #
A strong lax semi-monoidal endofunctor.
This is equivalent to an Applicative without pure.
Laws:
(.)<$>u<.>v<.>w = u<.>(v<.>w) x<.>(f<$>y) = (.f)<$>x<.>y f<$>(x<.>y) = (f.)<$>x<.>y
The laws imply that .> and <. really ignore their
left and right results, respectively, and really
return their right and left results, respectively.
Specifically,
(mf<$>m).>(nf<$>n) = nf<$>(m.>n) (mf<$>m)<.(nf<$>n) = mf<$>(m<.n)
Minimal complete definition
Instances
Wrappers
newtype WrappedApplicative f a #
Wrap an Applicative to be used as a member of Apply
Constructors
| WrapApplicative | |
Fields
| |
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
| |
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 #
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)
Instances
| Bind [] # | |
| Bind Maybe # | |
| Bind IO # | |
| Bind Identity # | |
| Bind Option # | |
| Bind NonEmpty # | |
| Bind IntMap # | |
| Bind Tree # | |
| Bind Seq # | |
| Bind ((->) m) # | |
| Bind (Either a) # | |
| Semigroup m => Bind ((,) m) # | |
| Monad m => Bind (WrappedMonad m) # | |
| Ord k => Bind (Map k) # | |
| (Functor m, Monad m) => Bind (MaybeT m) # | |
| (Apply m, Monad m) => Bind (ListT m) # | |
| Bind m => Bind (IdentityT * m) # | |
| (Bind m, Semigroup w) => Bind (WriterT w m) # | |
| (Bind m, Semigroup w) => Bind (WriterT w m) # | |
| Bind m => Bind (StateT s m) # | |
| Bind m => Bind (StateT s m) # | |
| (Functor m, Monad m) => Bind (ExceptT e m) # | |
| (Functor m, Monad m) => Bind (ErrorT e m) # | |
| (Bind f, Bind g) => Bind (Product * f g) # | |
| 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) # | |
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 #
Instances
| Biapply (,) # | |
| Biapply Arg # | |
| Semigroup x => Biapply ((,,) x) # | |
| Biapply (Const *) # | |
| 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) # | |