Portability | portable |
---|---|
Stability | provisional |
Maintainer | Edward Kmett <ekmett@gmail.com> |
- class Functor f where
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- ($>) :: Functor f => f a -> b -> f b
- class Functor w => Comonad w where
- (=>=) :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c
- (=<=) :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c
- (=>>) :: Comonad w => w a -> (w a -> b) -> w b
- (<<=) :: Comonad w => (w a -> b) -> w a -> w b
- liftW :: Comonad w => (a -> b) -> w a -> w b
- wfix :: Comonad w => w (w a -> a) -> a
- class Functor f => FunctorApply f where
- (<..>) :: FunctorApply w => w a -> w (a -> b) -> w b
- liftF2 :: FunctorApply w => (a -> b -> c) -> w a -> w b -> w c
- liftF3 :: FunctorApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d
- class (Comonad w, FunctorApply w) => ComonadApply w
- liftW2 :: ComonadApply w => (a -> b -> c) -> w a -> w b -> w c
- liftW3 :: ComonadApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d
- newtype Cokleisli w a b = Cokleisli {
- runCokleisli :: w a -> b
- newtype WrappedApplicative f a = WrappedApplicative {
- unwrapApplicative :: f a
- newtype WrappedApply f a = WrapApply {
- unwrapApply :: Either (f a) a
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, Data.Maybe.Maybe
and System.IO.IO
satisfy these laws.
Functor [] | |
Functor IO | |
Functor ZipList | |
Functor Maybe | |
Functor Identity | |
Functor ((->) r) | |
Functor (Either a) | |
Functor ((,) a) | |
Functor (Const m) | |
Monad m => Functor (WrappedMonad m) | |
Functor m => Functor (IdentityT m) | |
Functor f => Functor (WrappedApply f) | |
Functor f => Functor (WrappedApplicative f) | |
Arrow a => Functor (WrappedArrow a b) | |
Functor (Cokleisli w a) |
Comonads
class Functor w => Comonad w whereSource
There are two ways to define a comonad:
I. Provide definitions for extract
and extend
satisfying these laws:
extend extract = id extract . extend f = f extend f . extend g = extend (f . extend g)
In this case, you may simply set fmap
= liftW
.
These laws are directly analogous to the laws for monads and perhaps can be made clearer by viewing them as laws stating that Cokleisli composition must be associative, and has extract for a unit:
f =>= extract = f extract =>= f = f (f =>= g) =>= h = f =>= (g =>= h)
II. Alternately, you may choose to provide definitions for fmap
,
extract
, and duplicate
satisfying these laws:
extract . duplicate = id fmap extract . duplicate = id duplicate . duplicate = fmap duplicate . duplicate
In this case you may not rely on the ability to define fmap
in
terms of liftW
.
You may of course, choose to define both duplicate
and extend
.
In that case you must also satisfy these laws:
extend f = fmap f . duplicate duplicate = extend id fmap f = extend (f . extract)
These are the default definitions of extend
andduplicate
and
the definition of liftW
respectively.
FunctorApply - strong lax symmetric semimonoidal endofunctors
class Functor f => FunctorApply f whereSource
A strong lax symmetric semi-monoidal functor.
(<.>) :: f (a -> b) -> f a -> f bSource
(.>) :: f a -> f b -> f bSource
(<.) :: f a -> f b -> f aSource
a . b = const <$ a . b
FunctorApply [] | |
FunctorApply IO | |
FunctorApply ZipList | |
FunctorApply Maybe | |
FunctorApply Identity | |
Monoid m => FunctorApply ((->) m) | |
Monoid m => FunctorApply ((,) m) | |
Monoid m => FunctorApply (Const m) | |
Monad m => FunctorApply (WrappedMonad m) | |
FunctorApply w => FunctorApply (IdentityT w) | |
FunctorApply f => FunctorApply (WrappedApply f) | |
Applicative f => FunctorApply (WrappedApplicative f) | |
Arrow a => FunctorApply (WrappedArrow a b) | |
FunctorApply (Cokleisli w a) |
(<..>) :: FunctorApply w => w a -> w (a -> b) -> w bSource
A variant of <.>
with the arguments reversed.
liftF2 :: FunctorApply w => (a -> b -> c) -> w a -> w b -> w cSource
Lift a binary function into a comonad with zipping
liftF3 :: FunctorApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w dSource
Lift a ternary function into a comonad with zipping
ComonadApply - strong lax symmetric semimonoidal comonads
class (Comonad w, FunctorApply w) => ComonadApply w Source
A strong lax symmetric semi-monoidal comonad. As such an instance of
ComonadApply
is required to satisfy:
extract (a <.> b) = extract a (extract b)
This class is based on ComonadZip from "The Essence of Dataflow Programming"
by Tarmo Uustalu and Varmo Vene, but adapted to fit the programming style of
Control.Applicative. Applicative
can be seen as a similar law over and above
FunctorApply that:
pure (a b) = pure a <.> pure b
ComonadApply Identity | |
Monoid m => ComonadApply ((->) m) | Only requires a Semigroup, but no such class exists |
Monoid m => ComonadApply ((,) m) | Only requires a Semigroup, but no such class exists |
ComonadApply w => ComonadApply (IdentityT w) | |
ComonadApply f => ComonadApply (WrappedApply f) |
liftW2 :: ComonadApply w => (a -> b -> c) -> w a -> w b -> w cSource
Lift a binary function into a comonad with zipping
liftW3 :: ComonadApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w dSource
Lift a ternary function into a comonad with zipping
Wrappers
newtype Cokleisli w a b Source
Cokleisli | |
|
Comonad w => Arrow (Cokleisli w) | |
Comonad w => ArrowChoice (Cokleisli w) | |
Comonad w => ArrowApply (Cokleisli w) | |
ComonadApply w => ArrowLoop (Cokleisli w) | |
Comonad w => Category (Cokleisli w) | |
Monad (Cokleisli w a) | |
Functor (Cokleisli w a) | |
Applicative (Cokleisli w a) | |
FunctorApply (Cokleisli w a) |
newtype WrappedApplicative f a Source
Wrap Applicatives to be used as a member of FunctorApply
Functor f => Functor (WrappedApplicative f) | |
Applicative f => Applicative (WrappedApplicative f) | |
Applicative f => FunctorApply (WrappedApplicative f) |
newtype WrappedApply f a Source
Transform a strong lax symmetric semi-monoidal endofunctor into a strong lax symmetric monoidal endofunctor by adding a unit.
WrapApply | |
|
Functor f => Functor (WrappedApply f) | |
FunctorApply f => Applicative (WrappedApply f) | |
ComonadApply f => ComonadApply (WrappedApply f) | |
FunctorApply f => FunctorApply (WrappedApply f) | |
Comonad f => Comonad (WrappedApply f) |