-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Comonads
--
-- Comonads
@package comonad
@version 5
module Data.Functor.Composition
-- | We often need to distinguish between various forms of Functor-like
-- composition in Haskell in order to please the type system. This lets
-- us work with these representations uniformly.
class Composition o
decompose :: Composition o => o f g x -> f (g x)
compose :: Composition o => f (g x) -> o f g x
instance Data.Functor.Composition.Composition Data.Functor.Compose.Compose
module Control.Comonad.Trans.Identity
-- | The trivial monad transformer, which maps a monad to an equivalent
-- monad.
newtype IdentityT (f :: * -> *) a :: (* -> *) -> * -> *
IdentityT :: f a -> IdentityT a
[runIdentityT] :: IdentityT a -> f a
module Control.Comonad
-- | 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 and
-- duplicate and the definition of liftW respectively.
class Functor w => Comonad w where duplicate = extend id extend f = fmap f . duplicate
-- |
-- extract . fmap f = f . extract
--
extract :: Comonad w => w a -> a
-- |
-- duplicate = extend id
-- fmap (fmap f) . duplicate = duplicate . fmap f
--
duplicate :: Comonad w => w a -> w (w a)
-- |
-- extend f = fmap f . duplicate
--
extend :: Comonad w => (w a -> b) -> w a -> w b
-- | A suitable default definition for fmap for a Comonad.
-- Promotes a function to a comonad.
--
-- You can only safely use to define fmap if your Comonad
-- defined extend, not just duplicate, since defining
-- extend in terms of duplicate uses fmap!
--
--
-- fmap f = liftW f = extend (f . extract)
--
liftW :: Comonad w => (a -> b) -> w a -> w b
-- | Comonadic fixed point à la David Menendez
wfix :: Comonad w => w (w a -> a) -> a
-- | Comonadic fixed point à la Dominic Orchard
cfix :: Comonad 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.
kfix :: ComonadApply w => w (w a -> a) -> w a
-- | Left-to-right Cokleisli composition
(=>=) :: Comonad w => (w a -> b) -> (w b -> c) -> w a -> c
-- | Right-to-left Cokleisli composition
(=<=) :: Comonad w => (w b -> c) -> (w a -> b) -> w a -> c
-- | extend in operator form
(<<=) :: Comonad w => (w a -> b) -> w a -> w b
-- | extend with the arguments swapped. Dual to >>= for
-- a Monad.
(=>>) :: Comonad w => w a -> (w a -> b) -> w b
-- | 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
--
class Comonad w => ComonadApply w where (<@>) = (<*>) a @> b = const id <$> a <@> b a <@ b = const <$> a <@> b
(<@>) :: ComonadApply w => w (a -> b) -> w a -> w b
(@>) :: ComonadApply w => w a -> w b -> w b
(<@) :: ComonadApply w => w a -> w b -> w a
-- | A variant of <@> with the arguments reversed.
(<@@>) :: ComonadApply w => w a -> w (a -> b) -> w b
-- | Lift a binary function into a Comonad with zipping
liftW2 :: ComonadApply w => (a -> b -> c) -> w a -> w b -> w c
-- | Lift a ternary function into a Comonad with zipping
liftW3 :: ComonadApply w => (a -> b -> c -> d) -> w a -> w b -> w c -> w d
-- | The Cokleisli Arrows of a given Comonad
newtype Cokleisli w a b
Cokleisli :: (w a -> b) -> Cokleisli w a b
[runCokleisli] :: Cokleisli w a b -> w a -> b
-- | 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, Maybe and IO
-- satisfy these laws.
class Functor (f :: * -> *)
fmap :: Functor f => (a -> b) -> f a -> f b
-- | Replace all locations in the input with the same value. The default
-- definition is fmap . const, but this may be
-- overridden with a more efficient version.
(<$) :: Functor f => a -> f b -> f a
-- | An infix synonym for fmap.
--
-- Examples
--
-- Convert from a Maybe Int to a
-- Maybe String using show:
--
--
-- >>> show <$> Nothing
-- Nothing
--
-- >>> show <$> Just 3
-- Just "3"
--
--
-- Convert from an Either Int Int to
-- an Either Int String using
-- show:
--
--
-- >>> show <$> Left 17
-- Left 17
--
-- >>> show <$> Right 17
-- Right "17"
--
--
-- Double each element of a list:
--
--
-- >>> (*2) <$> [1,2,3]
-- [2,4,6]
--
--
-- Apply even to the second element of a pair:
--
--
-- >>> even <$> (2,2)
-- (2,True)
--
(<$>) :: Functor f => (a -> b) -> f a -> f b
-- | Flipped version of <$.
--
-- Examples
--
-- Replace the contents of a Maybe Int with a
-- constant String:
--
--
-- >>> Nothing $> "foo"
-- Nothing
--
-- >>> Just 90210 $> "foo"
-- Just "foo"
--
--
-- Replace the contents of an Either Int
-- Int with a constant String, resulting in an
-- Either Int String:
--
--
-- >>> Left 8675309 $> "foo"
-- Left 8675309
--
-- >>> Right 8675309 $> "foo"
-- Right "foo"
--
--
-- Replace each element of a list with a constant String:
--
--
-- >>> [1,2,3] $> "foo"
-- ["foo","foo","foo"]
--
--
-- Replace the second element of a pair with a constant String:
--
--
-- >>> (1,2) $> "foo"
-- (1,"foo")
--
($>) :: Functor f => f a -> b -> f b
instance Control.Comonad.Comonad ((,) e)
instance Control.Comonad.Comonad (Data.Semigroup.Arg e)
instance GHC.Base.Monoid m => Control.Comonad.Comonad ((->) m)
instance Control.Comonad.Comonad Data.Functor.Identity.Identity
instance Control.Comonad.Comonad (Data.Tagged.Tagged s)
instance Control.Comonad.Comonad w => Control.Comonad.Comonad (Control.Monad.Trans.Identity.IdentityT w)
instance Control.Comonad.Comonad Data.Tree.Tree
instance Control.Comonad.Comonad Data.List.NonEmpty.NonEmpty
instance (Control.Comonad.Comonad f, Control.Comonad.Comonad g) => Control.Comonad.Comonad (Data.Functor.Sum.Sum f g)
instance Data.Semigroup.Semigroup m => Control.Comonad.ComonadApply ((,) m)
instance Control.Comonad.ComonadApply Data.List.NonEmpty.NonEmpty
instance GHC.Base.Monoid m => Control.Comonad.ComonadApply ((->) m)
instance Control.Comonad.ComonadApply Data.Functor.Identity.Identity
instance Control.Comonad.ComonadApply w => Control.Comonad.ComonadApply (Control.Monad.Trans.Identity.IdentityT w)
instance Control.Comonad.ComonadApply Data.Tree.Tree
instance Control.Comonad.Comonad w => Control.Category.Category (Control.Comonad.Cokleisli w)
instance Control.Comonad.Comonad w => Control.Arrow.Arrow (Control.Comonad.Cokleisli w)
instance Control.Comonad.Comonad w => Control.Arrow.ArrowApply (Control.Comonad.Cokleisli w)
instance Control.Comonad.Comonad w => Control.Arrow.ArrowChoice (Control.Comonad.Cokleisli w)
instance Control.Comonad.ComonadApply w => Control.Arrow.ArrowLoop (Control.Comonad.Cokleisli w)
instance GHC.Base.Functor (Control.Comonad.Cokleisli w a)
instance GHC.Base.Applicative (Control.Comonad.Cokleisli w a)
instance GHC.Base.Monad (Control.Comonad.Cokleisli w a)
module Control.Comonad.Trans.Class
class ComonadTrans t
lower :: (ComonadTrans t, Comonad w) => t w a -> w a
instance Control.Comonad.Trans.Class.ComonadTrans Control.Monad.Trans.Identity.IdentityT
module Control.Comonad.Hoist.Class
class ComonadHoist t
-- | Given any comonad-homomorphism from w to v this
-- yields a comonad homomorphism from t w to t v.
cohoist :: (ComonadHoist t, Comonad w, Comonad v) => (forall x. w x -> v x) -> t w a -> t v a
instance Control.Comonad.Hoist.Class.ComonadHoist Control.Monad.Trans.Identity.IdentityT
-- | The environment comonad holds a value along with some retrievable
-- context.
--
-- This module specifies the environment comonad transformer (aka
-- coreader), which is left adjoint to the reader comonad.
--
-- The following sets up an experiment that retains its initial value in
-- the background:
--
--
-- >>> let initial = env 0 0
--
--
-- Extract simply retrieves the value:
--
--
-- >>> extract initial
-- 0
--
--
-- Play around with the value, in our case producing a negative value:
--
--
-- >>> let experiment = fmap (+ 10) initial
--
-- >>> extract experiment
-- 10
--
--
-- Oh noes, something went wrong, 10 isn't very negative! Better restore
-- the initial value using the default:
--
--
-- >>> let initialRestored = experiment =>> ask
--
-- >>> extract initialRestored
-- 0
--
module Control.Comonad.Trans.Env
type Env e = EnvT e Identity
-- | Create an Env using an environment and a value
env :: e -> a -> Env e a
runEnv :: Env e a -> (e, a)
data EnvT e w a
EnvT :: e -> (w a) -> EnvT e w a
runEnvT :: EnvT e w a -> (e, w a)
-- | Gets rid of the environment. This differs from extract in that
-- it will not continue extracting the value from the contained comonad.
lowerEnvT :: EnvT e w a -> w a
-- | Retrieves the environment.
ask :: EnvT e w a -> e
-- | Like ask, but modifies the resulting value with a function.
--
--
-- asks = f . ask
--
asks :: (e -> f) -> EnvT e w a -> f
-- | Modifies the environment using the specified function.
local :: (e -> e') -> EnvT e w a -> EnvT e' w a
instance (Data.Data.Data e, Data.Typeable.Internal.Typeable w, Data.Data.Data (w a), Data.Data.Data a) => Data.Data.Data (Control.Comonad.Trans.Env.EnvT e w a)
instance GHC.Base.Functor w => GHC.Base.Functor (Control.Comonad.Trans.Env.EnvT e w)
instance Control.Comonad.Comonad w => Control.Comonad.Comonad (Control.Comonad.Trans.Env.EnvT e w)
instance Control.Comonad.Trans.Class.ComonadTrans (Control.Comonad.Trans.Env.EnvT e)
instance (GHC.Base.Monoid e, GHC.Base.Applicative m) => GHC.Base.Applicative (Control.Comonad.Trans.Env.EnvT e m)
instance Control.Comonad.Hoist.Class.ComonadHoist (Control.Comonad.Trans.Env.EnvT e)
instance (Data.Semigroup.Semigroup e, Control.Comonad.ComonadApply w) => Control.Comonad.ComonadApply (Control.Comonad.Trans.Env.EnvT e w)
instance Data.Foldable.Foldable w => Data.Foldable.Foldable (Control.Comonad.Trans.Env.EnvT e w)
instance Data.Traversable.Traversable w => Data.Traversable.Traversable (Control.Comonad.Trans.Env.EnvT e w)
-- | The store comonad holds a constant value along with a modifiable
-- accessor function, which maps the stored value to the
-- focus.
--
-- This module defines the strict store (aka state-in-context/costate)
-- comonad transformer.
--
-- stored value = (1, 5), accessor = fst, resulting
-- focus = 1:
--
--
-- >>> :{
-- let
-- storeTuple :: Store (Int, Int) Int
-- storeTuple = store fst (1, 5)
-- :}
--
--
-- Add something to the focus:
--
--
-- >>> :{
-- let
-- addToFocus :: Int -> Store (Int, Int) Int -> Int
-- addToFocus x wa = x + extract wa
-- :}
--
--
--
-- >>> :{
-- let
-- added3 :: Store (Int, Int) Int
-- added3 = extend (addToFocus 3) storeTuple
-- :}
--
--
-- The focus of added3 is now 1 + 3 = 4. However, this action
-- changed only the accessor function and therefore the focus but not the
-- stored value:
--
--
-- >>> pos added3
-- (1,5)
--
--
--
-- >>> extract added3
-- 4
--
--
-- The strict store (state-in-context/costate) comonad transformer is
-- subject to the laws:
--
--
-- x = seek (pos x) x
-- y = pos (seek y x)
-- seek y x = seek y (seek z x)
--
--
-- Thanks go to Russell O'Connor and Daniel Peebles for their help
-- formulating and proving the laws for this comonad transformer.
module Control.Comonad.Trans.Store
type Store s = StoreT s Identity
-- | Create a Store using an accessor function and a stored value
store :: (s -> a) -> s -> Store s a
runStore :: Store s a -> (s -> a, s)
data StoreT s w a
StoreT :: (w (s -> a)) -> s -> StoreT s w a
runStoreT :: StoreT s w a -> (w (s -> a), s)
-- | Read the stored value
--
--
-- >>> pos $ store fst (1,5)
-- (1,5)
--
pos :: StoreT s w a -> s
-- | Set the stored value
--
--
-- >>> pos . seek (3,7) $ store fst (1,5)
-- (3,7)
--
--
-- Seek satisfies the law
--
--
-- seek s = peek s . duplicate
--
seek :: s -> StoreT s w a -> StoreT s w a
-- | Modify the stored value
--
--
-- >>> pos . seeks swap $ store fst (1,5)
-- (5,1)
--
--
-- Seeks satisfies the law
--
--
-- seeks f = peeks f . duplicate
--
seeks :: (s -> s) -> StoreT s w a -> StoreT s w a
-- | Peek at what the current focus would be for a different stored value
--
-- Peek satisfies the law
--
--
-- peek x . extend (peek y) = peek y
--
peek :: Comonad w => s -> StoreT s w a -> a
-- | Peek at what the current focus would be if the stored value was
-- modified by some function
peeks :: Comonad w => (s -> s) -> StoreT s w a -> a
-- | Applies a functor-valued function to the stored value, and then uses
-- the new accessor to read the resulting focus.
--
--
-- >>> let f x = if x > 0 then Just (x^2) else Nothing
--
-- >>> experiment f $ store (+1) 2
-- Just 5
--
-- >>> experiment f $ store (+1) (-2)
-- Nothing
--
experiment :: (Comonad w, Functor f) => (s -> f s) -> StoreT s w a -> f a
instance GHC.Base.Functor w => GHC.Base.Functor (Control.Comonad.Trans.Store.StoreT s w)
instance (Control.Comonad.ComonadApply w, Data.Semigroup.Semigroup s) => Control.Comonad.ComonadApply (Control.Comonad.Trans.Store.StoreT s w)
instance (GHC.Base.Applicative w, GHC.Base.Monoid s) => GHC.Base.Applicative (Control.Comonad.Trans.Store.StoreT s w)
instance Control.Comonad.Comonad w => Control.Comonad.Comonad (Control.Comonad.Trans.Store.StoreT s w)
instance Control.Comonad.Trans.Class.ComonadTrans (Control.Comonad.Trans.Store.StoreT s)
instance Control.Comonad.Hoist.Class.ComonadHoist (Control.Comonad.Trans.Store.StoreT s)
-- | The trace comonad builds up a result by prepending monoidal values to
-- each other.
--
-- This module specifies the traced comonad transformer (aka the cowriter
-- or exponential comonad transformer).
module Control.Comonad.Trans.Traced
type Traced m = TracedT m Identity
traced :: (m -> a) -> Traced m a
runTraced :: Traced m a -> m -> a
newtype TracedT m w a
TracedT :: w (m -> a) -> TracedT m w a
[runTracedT] :: TracedT m w a -> w (m -> a)
trace :: Comonad w => m -> TracedT m w a -> a
listen :: Functor w => TracedT m w a -> TracedT m w (a, m)
listens :: Functor w => (m -> b) -> TracedT m w a -> TracedT m w (a, b)
censor :: Functor w => (m -> m) -> TracedT m w a -> TracedT m w a
instance GHC.Base.Functor w => GHC.Base.Functor (Control.Comonad.Trans.Traced.TracedT m w)
instance (Control.Comonad.ComonadApply w, GHC.Base.Monoid m) => Control.Comonad.ComonadApply (Control.Comonad.Trans.Traced.TracedT m w)
instance GHC.Base.Applicative w => GHC.Base.Applicative (Control.Comonad.Trans.Traced.TracedT m w)
instance (Control.Comonad.Comonad w, GHC.Base.Monoid m) => Control.Comonad.Comonad (Control.Comonad.Trans.Traced.TracedT m w)
instance GHC.Base.Monoid m => Control.Comonad.Trans.Class.ComonadTrans (Control.Comonad.Trans.Traced.TracedT m)
instance Control.Comonad.Hoist.Class.ComonadHoist (Control.Comonad.Trans.Traced.TracedT m)
instance Data.Distributive.Distributive w => Data.Distributive.Distributive (Control.Comonad.Trans.Traced.TracedT m w)
module Control.Comonad.Env.Class
class Comonad w => ComonadEnv e w | w -> e
ask :: ComonadEnv e w => w a -> e
asks :: ComonadEnv e w => (e -> e') -> w a -> e'
instance Control.Comonad.Comonad w => Control.Comonad.Env.Class.ComonadEnv e (Control.Comonad.Trans.Env.EnvT e w)
instance Control.Comonad.Env.Class.ComonadEnv e ((,) e)
instance Control.Comonad.Env.Class.ComonadEnv e (Data.Semigroup.Arg e)
instance Control.Comonad.Env.Class.ComonadEnv e w => Control.Comonad.Env.Class.ComonadEnv e (Control.Comonad.Trans.Store.StoreT t w)
instance Control.Comonad.Env.Class.ComonadEnv e w => Control.Comonad.Env.Class.ComonadEnv e (Control.Monad.Trans.Identity.IdentityT w)
instance (Control.Comonad.Env.Class.ComonadEnv e w, GHC.Base.Monoid m) => Control.Comonad.Env.Class.ComonadEnv e (Control.Comonad.Trans.Traced.TracedT m w)
-- | The Env comonad (aka the Coreader, Environment, or Product comonad)
--
-- A co-Kleisli arrow in the Env comonad is isomorphic to a Kleisli arrow
-- in the reader monad.
--
-- (a -> e -> m) ~ (a, e) -> m ~ Env e a -> m
module Control.Comonad.Env
class Comonad w => ComonadEnv e w | w -> e
ask :: ComonadEnv e w => w a -> e
asks :: ComonadEnv e w => (e -> e') -> w a -> e'
-- | Modifies the environment using the specified function.
local :: (e -> e') -> EnvT e w a -> EnvT e' w a
type Env e = EnvT e Identity
-- | Create an Env using an environment and a value
env :: e -> a -> Env e a
runEnv :: Env e a -> (e, a)
data EnvT e w a
EnvT :: e -> (w a) -> EnvT e w a
runEnvT :: EnvT e w a -> (e, w a)
module Control.Comonad.Identity
module Control.Comonad.Store.Class
class Comonad w => ComonadStore s w | w -> s where peeks f w = peek (f (pos w)) w seek s = peek s . duplicate seeks f = peeks f . duplicate experiment f w = fmap (`peek` w) (f (pos w))
pos :: ComonadStore s w => w a -> s
peek :: ComonadStore s w => s -> w a -> a
peeks :: ComonadStore s w => (s -> s) -> w a -> a
seek :: ComonadStore s w => s -> w a -> w a
seeks :: ComonadStore s w => (s -> s) -> w a -> w a
experiment :: (ComonadStore s w, Functor f) => (s -> f s) -> w a -> f a
lowerPos :: (ComonadTrans t, ComonadStore s w) => t w a -> s
lowerPeek :: (ComonadTrans t, ComonadStore s w) => s -> t w a -> a
instance Control.Comonad.Comonad w => Control.Comonad.Store.Class.ComonadStore s (Control.Comonad.Trans.Store.StoreT s w)
instance Control.Comonad.Store.Class.ComonadStore s w => Control.Comonad.Store.Class.ComonadStore s (Control.Monad.Trans.Identity.IdentityT w)
instance Control.Comonad.Store.Class.ComonadStore s w => Control.Comonad.Store.Class.ComonadStore s (Control.Comonad.Trans.Env.EnvT e w)
instance (Control.Comonad.Store.Class.ComonadStore s w, GHC.Base.Monoid m) => Control.Comonad.Store.Class.ComonadStore s (Control.Comonad.Trans.Traced.TracedT m w)
module Control.Comonad.Store
class Comonad w => ComonadStore s w | w -> s where peeks f w = peek (f (pos w)) w seek s = peek s . duplicate seeks f = peeks f . duplicate experiment f w = fmap (`peek` w) (f (pos w))
pos :: ComonadStore s w => w a -> s
peek :: ComonadStore s w => s -> w a -> a
peeks :: ComonadStore s w => (s -> s) -> w a -> a
seek :: ComonadStore s w => s -> w a -> w a
seeks :: ComonadStore s w => (s -> s) -> w a -> w a
experiment :: (ComonadStore s w, Functor f) => (s -> f s) -> w a -> f a
type Store s = StoreT s Identity
-- | Create a Store using an accessor function and a stored value
store :: (s -> a) -> s -> Store s a
runStore :: Store s a -> (s -> a, s)
data StoreT s w a
StoreT :: (w (s -> a)) -> s -> StoreT s w a
runStoreT :: StoreT s w a -> (w (s -> a), s)
module Control.Comonad.Traced.Class
class Comonad w => ComonadTraced m w | w -> m
trace :: ComonadTraced m w => m -> w a -> a
traces :: ComonadTraced m w => (a -> m) -> w a -> a
instance (Control.Comonad.Comonad w, GHC.Base.Monoid m) => Control.Comonad.Traced.Class.ComonadTraced m (Control.Comonad.Trans.Traced.TracedT m w)
instance GHC.Base.Monoid m => Control.Comonad.Traced.Class.ComonadTraced m ((->) m)
instance Control.Comonad.Traced.Class.ComonadTraced m w => Control.Comonad.Traced.Class.ComonadTraced m (Control.Monad.Trans.Identity.IdentityT w)
instance Control.Comonad.Traced.Class.ComonadTraced m w => Control.Comonad.Traced.Class.ComonadTraced m (Control.Comonad.Trans.Env.EnvT e w)
instance Control.Comonad.Traced.Class.ComonadTraced m w => Control.Comonad.Traced.Class.ComonadTraced m (Control.Comonad.Trans.Store.StoreT s w)
module Control.Comonad.Traced
class Comonad w => ComonadTraced m w | w -> m
trace :: ComonadTraced m w => m -> w a -> a
traces :: ComonadTraced m w => (a -> m) -> w a -> a
type Traced m = TracedT m Identity
traced :: (m -> a) -> Traced m a
runTraced :: Traced m a -> m -> a
newtype TracedT m w a
TracedT :: w (m -> a) -> TracedT m w a
[runTracedT] :: TracedT m w a -> w (m -> a)