| Copyright | (C) 2011-2018 Edward Kmett |
|---|---|
| License | BSD-style (see the file LICENSE) |
| Maintainer | Edward Kmett <ekmett@gmail.com> |
| Stability | provisional |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
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.
Synopsis
- class Functor f => Apply (f :: Type -> Type) where
- newtype WrappedApplicative (f :: Type -> Type) a = WrapApplicative {
- unwrapApplicative :: f a
- newtype MaybeApply (f :: Type -> Type) a = MaybeApply {
- runMaybeApply :: Either (f a) a
- (<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b
- (<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b
- traverse1Maybe :: (Traversable t, Apply f) => (a -> f b) -> t a -> MaybeApply f (t b)
- class Apply m => Bind (m :: Type -> Type) 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 :: Type -> Type -> Type) where
Applyable functors
class Functor f => Apply (f :: Type -> Type) where Source #
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)
Methods
(<.>) :: f (a -> b) -> f a -> f b infixl 4 Source #
(.>) :: f a -> f b -> f b infixl 4 Source #
(<.) :: f a -> f b -> f a infixl 4 Source #
liftF2 :: (a -> b -> c) -> f a -> f b -> f c Source #
Lift a binary function into a comonad with zipping
Instances
Wrappers
newtype WrappedApplicative (f :: Type -> Type) a Source #
Wrap an Applicative to be used as a member of Apply
Constructors
| WrapApplicative | |
Fields
| |
Instances
newtype MaybeApply (f :: Type -> Type) a Source #
Transform an Apply into an Applicative by adding a unit.
Constructors
| MaybeApply | |
Fields
| |
Instances
(<.*>) :: Apply f => f (a -> b) -> MaybeApply f a -> f b infixl 4 Source #
Apply a non-empty container of functions to a possibly-empty-with-unit container of values.
(<*.>) :: Apply f => MaybeApply f (a -> b) -> f a -> f b infixl 4 Source #
Apply a possibly-empty-with-unit container of functions to a non-empty container of values.
traverse1Maybe :: (Traversable t, Apply f) => (a -> f b) -> t a -> MaybeApply f (t b) Source #
Traverse a Traversable using Apply, getting the results back in a MaybeApply.
Bindable functors
class Apply m => Bind (m :: Type -> Type) where Source #
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
Biappliable bifunctors
class Bifunctor p => Biapply (p :: Type -> Type -> Type) where Source #
Minimal complete definition
Methods
(<<.>>) :: p (a -> b) (c -> d) -> p a c -> p b d infixl 4 Source #