Copyright | (C) 2008-2015 Edward Kmett (C) 2004 Dave Menendez |
---|---|
License | BSD-style (see the file LICENSE) |
Maintainer | Edward Kmett <ekmett@gmail.com> |
Stability | provisional |
Portability | portable |
Safe Haskell | Safe |
Language | Haskell2010 |
Control.Comonad
Description
Synopsis
- class Functor w => Comonad w where
- liftW :: Comonad w => (a -> b) -> w a -> w b
- wfix :: Comonad w => w (w a -> a) -> a
- cfix :: Comonad w => (w a -> a) -> w a
- kfix :: ComonadApply w => w (w a -> a) -> w a
- (=>=) :: 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 -> b) -> w a -> w b
- (=>>) :: Comonad w => w a -> (w a -> b) -> w b
- class Comonad w => ComonadApply w where
- (<@@>) :: ComonadApply w => w a -> w (a -> b) -> w b
- 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
- class Functor (f :: Type -> Type) where
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- ($>) :: Functor f => f a -> b -> f b
Comonads
class Functor w => Comonad w where #
There are two ways to define a comonad:
I. Provide definitions for extract
and extend
satisfying these laws:
extend
extract
=id
extract
.extend
f = fextend
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
= fextract
=>=
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
idfmap
f =extend
(f .extract
)
These are the default definitions of extend
and duplicate
and
the definition of liftW
respectively.
Methods
Instances
Comonad Identity # | |
Comonad NonEmpty # | |
Comonad Tree # | |
Comonad (Arg e) # | |
Comonad ((,) e) # | |
Comonad w => Comonad (EnvT e w) # | |
Comonad w => Comonad (StoreT s w) # | |
(Comonad w, Monoid m) => Comonad (TracedT m w) # | |
Comonad (Tagged s) # | |
Comonad w => Comonad (IdentityT w) # | |
(Comonad f, Comonad g) => Comonad (Sum f g) # | |
Monoid m => Comonad ((->) m) # | |
kfix :: ComonadApply w => w (w a -> a) -> w a #
Comonadic fixed point à la Kenneth Foner:
This is the evaluate
function from his "Getting a Quick Fix on Comonads" talk.
(=>=) :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c infixr 1 #
Left-to-right Cokleisli
composition
(=<=) :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c infixr 1 #
Right-to-left Cokleisli
composition
(=>>) :: Comonad w => w a -> (w a -> b) -> w b infixl 1 #
extend
with the arguments swapped. Dual to >>=
for a Monad
.
Combining Comonads
class Comonad w => ComonadApply w where #
ComonadApply
is to Comonad
like Applicative
is to Monad
.
Mathematically, it is a strong lax symmetric semi-monoidal comonad on the
category Hask
of Haskell types. That it to say that w
is a strong lax
symmetric semi-monoidal functor on Hask, where both extract
and duplicate
are
symmetric monoidal natural transformations.
Laws:
(.
)<$>
u<@>
v<@>
w = u<@>
(v<@>
w)extract
(p<@>
q) =extract
p (extract
q)duplicate
(p<@>
q) = (<@>
)<$>
duplicate
p<@>
duplicate
q
If our type is both a ComonadApply
and Applicative
we further require
(<*>
) = (<@>
)
Finally, if you choose to define (<@
) and (@>
), the results of your
definitions should match the following laws:
a@>
b =const
id
<$>
a<@>
b a<@
b =const
<$>
a<@>
b
Minimal complete definition
Nothing
Instances
ComonadApply Identity # | |
ComonadApply NonEmpty # | |
ComonadApply Tree # | |
Semigroup m => ComonadApply ((,) m) # | |
(Semigroup e, ComonadApply w) => ComonadApply (EnvT e w) # | |
(ComonadApply w, Semigroup s) => ComonadApply (StoreT s w) # | |
(ComonadApply w, Monoid m) => ComonadApply (TracedT m w) # | |
ComonadApply w => ComonadApply (IdentityT w) # | |
Monoid m => ComonadApply ((->) m) # | |
(<@@>) :: ComonadApply w => w a -> w (a -> b) -> w b infixl 4 #
A variant of <@>
with the arguments reversed.
liftW2 :: ComonadApply w => (a -> b -> c) -> w a -> w b -> w c #
Lift a binary function into a Comonad
with zipping
liftW3 :: ComonadApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d #
Lift a ternary function into a Comonad
with zipping
Cokleisli Arrows
Constructors
Cokleisli | |
Fields
|
Instances
Comonad w => Category (Cokleisli w :: Type -> Type -> Type) # | |
Comonad w => Arrow (Cokleisli w) # | |
Defined in Control.Comonad | |
Comonad w => ArrowApply (Cokleisli w) # | |
Defined in Control.Comonad | |
Comonad w => ArrowChoice (Cokleisli w) # | |
Defined in Control.Comonad | |
ComonadApply w => ArrowLoop (Cokleisli w) # | |
Defined in Control.Comonad | |
Applicative (Cokleisli w a) # | |
Defined in Control.Comonad Methods pure :: a0 -> Cokleisli w a a0 (<*>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b liftA2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c (*>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b (<*) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0 | |
Functor (Cokleisli w a) # | |
Monad (Cokleisli w a) # | |
Functors
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Functor ZipList | |
Defined in Control.Applicative | |
Functor Complex | |
Defined in Data.Complex | |
Functor Identity | |
Defined in Data.Functor.Identity | |
Functor First | |
Defined in Data.Monoid | |
Functor Last | |
Defined in Data.Monoid | |
Functor First | |
Defined in Data.Semigroup | |
Functor Last | |
Defined in Data.Semigroup | |
Functor Max | |
Defined in Data.Semigroup | |
Functor Min | |
Defined in Data.Semigroup | |
Functor Dual | |
Defined in Data.Semigroup.Internal | |
Functor Product | |
Defined in Data.Semigroup.Internal | |
Functor Sum | |
Defined in Data.Semigroup.Internal | |
Functor NonEmpty | |
Functor Par1 | |
Defined in GHC.Generics | |
Functor P | |
Defined in Text.ParserCombinators.ReadP | |
Functor ReadP | |
Defined in Text.ParserCombinators.ReadP | |
Functor IntMap | |
Defined in Data.IntMap.Internal | |
Functor Digit | |
Defined in Data.Sequence.Internal | |
Functor Elem | |
Defined in Data.Sequence.Internal | |
Functor FingerTree | |
Defined in Data.Sequence.Internal | |
Functor Node | |
Defined in Data.Sequence.Internal | |
Functor Seq | |
Defined in Data.Sequence.Internal | |
Functor ViewL | |
Defined in Data.Sequence.Internal | |
Functor ViewR | |
Defined in Data.Sequence.Internal | |
Functor Tree | |
Functor IO | |
Functor AnnotDetails | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
Functor Doc | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
Functor Span | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
Functor Q | |
Defined in Language.Haskell.TH.Syntax | |
Functor TyVarBndr | |
Defined in Language.Haskell.TH.Syntax | |
Functor Maybe | |
Functor Solo | |
Functor List | |
Monad m => Functor (WrappedMonad m) | |
Defined in Control.Applicative | |
Arrow a => Functor (ArrowMonad a) | |
Defined in Control.Arrow | |
Functor (Either a) | |
Defined in Data.Either | |
Functor (Proxy :: Type -> Type) | |
Defined in Data.Proxy | |
Functor (Arg a) | |
Defined in Data.Semigroup | |
Functor (Array i) | |
Functor (U1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (V1 :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (Map k) | |
Defined in Data.Map.Internal | |
Functor ((,) a) | |
Arrow a => Functor (WrappedArrow a b) | |
Defined in Control.Applicative | |
Functor m => Functor (Kleisli m a) | |
Defined in Control.Arrow | |
Functor (Const m :: Type -> Type) | |
Defined in Data.Functor.Const | |
Functor f => Functor (Ap f) | |
Defined in Data.Monoid | |
Functor f => Functor (Alt f) | |
Defined in Data.Semigroup.Internal | |
(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f) | |
Defined in GHC.Generics | |
Functor f => Functor (Rec1 f) | |
Defined in GHC.Generics | |
Functor (URec (Ptr ()) :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Char :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Double :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Float :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Int :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (URec Word :: Type -> Type) | |
Defined in GHC.Generics | |
Functor w => Functor (EnvT e w) # | |
Functor w => Functor (StoreT s w) # | |
Functor w => Functor (TracedT m w) # | |
(Applicative f, Monad f) => Functor (WhenMissing f x) | |
Defined in Data.IntMap.Internal | |
Functor f => Functor (Indexing f) | |
Functor (Tagged s) | |
Functor f => Functor (Backwards f) | |
Defined in Control.Applicative.Backwards | |
Functor m => Functor (IdentityT m) | |
Functor m => Functor (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
Functor (Constant a :: Type -> Type) | |
Defined in Data.Functor.Constant | |
Functor f => Functor (Reverse f) | |
Defined in Data.Functor.Reverse | |
Functor ((,,) a b) | |
(Functor f, Functor g) => Functor (Sum f g) | |
Defined in Data.Functor.Sum | |
(Functor f, Functor g) => Functor (f :*: g) | |
Defined in GHC.Generics | |
(Functor f, Functor g) => Functor (f :+: g) | |
Defined in GHC.Generics | |
Functor (K1 i c :: Type -> Type) | |
Defined in GHC.Generics | |
Functor (Cokleisli w a) # | |
Functor f => Functor (WhenMatched f x y) | |
Defined in Data.IntMap.Internal | |
(Applicative f, Monad f) => Functor (WhenMissing f k x) | |
Defined in Data.Map.Internal | |
Functor ((,,,) a b c) | |
Functor ((->) r) | |
(Functor f, Functor g) => Functor (Compose f g) | |
Defined in Data.Functor.Compose | |
(Functor f, Functor g) => Functor (f :.: g) | |
Defined in GHC.Generics | |
Functor f => Functor (M1 i c f) | |
Defined in GHC.Generics | |
Functor f => Functor (WhenMatched f k x y) | |
Defined in Data.Map.Internal | |
Functor ((,,,,) a b c d) | |
Functor ((,,,,,) a b c d e) | |
Functor ((,,,,,,) a b c d e f) | |