{-# LANGUAGE CPP #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
#if __GLASGOW_HASKELL__ >= 706
{-# LANGUAGE PolyKinds #-}
#endif
#if __GLASGOW_HASKELL__ >= 702 && __GLASGOW_HASKELL__ < 710
{-# LANGUAGE Trustworthy #-}
#endif
-----------------------------------------------------------------------------
-- |
-- Copyright   :  (C) 2011-2016 Edward Kmett
-- License     :  BSD-style (see the file LICENSE)
--
-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
-- Stability   :  provisional
-- Portability :  non-portable (rank-2 polymorphism)
--
-- Monads from Comonads
--
-- <http://comonad.com/reader/2011/monads-from-comonads/>
--
-- 'Co' can be viewed as a right Kan lift along a 'Comonad'.
--
-- In general you can \"sandwich\" a monad in between two halves of an adjunction.
-- That is to say, if you have an adjunction @F -| G : C -> D @ then not only does @GF@
-- form a monad, but @GMF@ forms a monad for @M@ a monad in @D@. Therefore if we
-- have an adjunction @F -| G : Hask -> Hask^op@ then we can lift a 'Comonad' in @Hask@
-- which is a 'Monad' in @Hask^op@ to a 'Monad' in 'Hask'.
--
-- For any @r@, the 'Contravariant' functor / presheaf @(-> r)@ :: Hask^op -> Hask is adjoint to the \"same\"
-- 'Contravariant' functor @(-> r) :: Hask -> Hask^op@. So we can sandwich a
-- Monad in Hask^op in the middle to obtain @w (a -> r-) -> r+@, and then take a coend over
-- @r@ to obtain @forall r. w (a -> r) -> r@. This gives rise to 'Co'. If we observe that
-- we didn't care what the choices we made for @r@ were to finish this construction, we can
-- upgrade to @forall r. w (a -> m r) -> m r@ in a manner similar to how @ContT@ is constructed
-- yielding 'CoT'.
--
-- We could consider unifying the definition of 'Co' and 'Rift', but
-- there are many other arguments for which 'Rift' can form a 'Monad', and this
-- wouldn't give rise to 'CoT'.
----------------------------------------------------------------------------
module Control.Monad.Co
  (
  -- * Monads from Comonads
    Co, co, runCo
  -- * Monad Transformers from Comonads
  , CoT(..)
  -- * Klesili from CoKleisli
  , liftCoT0, liftCoT0M, lowerCoT0, lowerCo0
  , liftCoT1, liftCoT1M, lowerCoT1, lowerCo1
  , diter, dctrlM
  , posW, peekW, peeksW
  , askW, asksW, traceW
  )where

#if __GLASGOW_HASKELL__ < 710
import Control.Applicative
#endif
import Control.Comonad
import Control.Comonad.Cofree
import Control.Comonad.Density
import Control.Comonad.Env.Class as Env
import Control.Comonad.Store.Class
import Control.Comonad.Traced.Class as Traced
import Control.Monad ((<=<), liftM)
import Control.Monad.Error.Class
import qualified Control.Monad.Fail as Fail
import Control.Monad.IO.Class
import Control.Monad.Identity (Identity(..))
import Control.Monad.Reader.Class as Reader
import Control.Monad.State.Class
import Control.Monad.Trans.Class
import Control.Monad.Writer.Class as Writer
import Data.Functor.Bind
import Data.Functor.Extend

type Co w = CoT w Identity

co :: Functor w => (forall r. w (a -> r) -> r) -> Co w a
co :: forall (w :: * -> *) a.
Functor w =>
(forall r. w (a -> r) -> r) -> Co w a
co forall r. w (a -> r) -> r
f = (forall r. w (a -> Identity r) -> Identity r) -> CoT w Identity a
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (r -> Identity r
forall a. a -> Identity a
Identity (r -> Identity r)
-> (w (a -> Identity r) -> r) -> w (a -> Identity r) -> Identity r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. w (a -> r) -> r
forall r. w (a -> r) -> r
f (w (a -> r) -> r)
-> (w (a -> Identity r) -> w (a -> r)) -> w (a -> Identity r) -> r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a -> Identity r) -> a -> r) -> w (a -> Identity r) -> w (a -> r)
forall a b. (a -> b) -> w a -> w b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Identity r -> r) -> (a -> Identity r) -> a -> r
forall a b. (a -> b) -> (a -> a) -> a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Identity r -> r
forall a. Identity a -> a
runIdentity))

runCo :: Functor w => Co w a -> w (a -> r) -> r
runCo :: forall (w :: * -> *) a r. Functor w => Co w a -> w (a -> r) -> r
runCo Co w a
m = Identity r -> r
forall a. Identity a -> a
runIdentity (Identity r -> r) -> (w (a -> r) -> Identity r) -> w (a -> r) -> r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Co w a -> forall r. w (a -> Identity r) -> Identity r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT Co w a
m (w (a -> Identity r) -> Identity r)
-> (w (a -> r) -> w (a -> Identity r)) -> w (a -> r) -> Identity r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a -> r) -> a -> Identity r) -> w (a -> r) -> w (a -> Identity r)
forall a b. (a -> b) -> w a -> w b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((r -> Identity r) -> (a -> r) -> a -> Identity r
forall a b. (a -> b) -> (a -> a) -> a -> b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap r -> Identity r
forall a. a -> Identity a
Identity)

-- |
-- @
-- 'Co' w a ~ 'Data.Functor.Kan.Rift.Rift' w 'Identity' a
-- @
newtype CoT w m a = CoT { forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT :: forall r. w (a -> m r) -> m r }

instance Functor w => Functor (CoT w m) where
  fmap :: forall a b. (a -> b) -> CoT w m a -> CoT w m b
fmap a -> b
f (CoT forall (r :: k). w (a -> m r) -> m r
w) = (forall (r :: k). w (b -> m r) -> m r) -> CoT w m b
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (w (a -> m r) -> m r
forall (r :: k). w (a -> m r) -> m r
w (w (a -> m r) -> m r)
-> (w (b -> m r) -> w (a -> m r)) -> w (b -> m r) -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((b -> m r) -> a -> m r) -> w (b -> m r) -> w (a -> m r)
forall a b. (a -> b) -> w a -> w b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> m r) -> (a -> b) -> a -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
f))

instance Extend w => Apply (CoT w m) where
  CoT w m (a -> b)
mf <.> :: forall a b. CoT w m (a -> b) -> CoT w m a -> CoT w m b
<.> CoT w m a
ma = CoT w m (a -> b)
mf CoT w m (a -> b) -> ((a -> b) -> CoT w m b) -> CoT w m b
forall a b. CoT w m a -> (a -> CoT w m b) -> CoT w m b
forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
>>- \a -> b
f -> (a -> b) -> CoT w m a -> CoT w m b
forall a b. (a -> b) -> CoT w m a -> CoT w m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f CoT w m a
ma

instance Extend w => Bind (CoT w m) where
  CoT forall (r :: k). w (a -> m r) -> m r
k >>- :: forall a b. CoT w m a -> (a -> CoT w m b) -> CoT w m b
>>- a -> CoT w m b
f = (forall (r :: k). w (b -> m r) -> m r) -> CoT w m b
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (w (a -> m r) -> m r
forall (r :: k). w (a -> m r) -> m r
k (w (a -> m r) -> m r)
-> (w (b -> m r) -> w (a -> m r)) -> w (b -> m r) -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (w (b -> m r) -> a -> m r) -> w (b -> m r) -> w (a -> m r)
forall a b. (w a -> b) -> w a -> w b
forall (w :: * -> *) a b. Extend w => (w a -> b) -> w a -> w b
extended (\w (b -> m r)
wa a
a -> CoT w m b -> forall (r :: k). w (b -> m r) -> m r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT (a -> CoT w m b
f a
a) w (b -> m r)
wa))

instance Comonad w => Applicative (CoT w m) where
  pure :: forall a. a -> CoT w m a
pure a
a = (forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (w (a -> m r) -> a -> m r
forall a. w a -> a
forall (w :: * -> *) a. Comonad w => w a -> a
`extract` a
a)
  CoT w m (a -> b)
mf <*> :: forall a b. CoT w m (a -> b) -> CoT w m a -> CoT w m b
<*> CoT w m a
ma = CoT w m (a -> b)
mf CoT w m (a -> b) -> ((a -> b) -> CoT w m b) -> CoT w m b
forall a b. CoT w m a -> (a -> CoT w m b) -> CoT w m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a -> b
f -> (a -> b) -> CoT w m a -> CoT w m b
forall a b. (a -> b) -> CoT w m a -> CoT w m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f CoT w m a
ma

instance Comonad w => Monad (CoT w m) where
  return :: forall a. a -> CoT w m a
return = a -> CoT w m a
forall a. a -> CoT w m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  CoT forall (r :: k). w (a -> m r) -> m r
k >>= :: forall a b. CoT w m a -> (a -> CoT w m b) -> CoT w m b
>>= a -> CoT w m b
f = (forall (r :: k). w (b -> m r) -> m r) -> CoT w m b
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (w (a -> m r) -> m r
forall (r :: k). w (a -> m r) -> m r
k (w (a -> m r) -> m r)
-> (w (b -> m r) -> w (a -> m r)) -> w (b -> m r) -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (w (b -> m r) -> a -> m r) -> w (b -> m r) -> w (a -> m r)
forall a b. (w a -> b) -> w a -> w b
forall (w :: * -> *) a b. Comonad w => (w a -> b) -> w a -> w b
extend (\w (b -> m r)
wa a
a -> CoT w m b -> forall (r :: k). w (b -> m r) -> m r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT (a -> CoT w m b
f a
a) w (b -> m r)
wa))

instance (Comonad w, Fail.MonadFail m) => Fail.MonadFail (CoT w m) where
  fail :: forall a. String -> CoT w m a
fail String
msg = (forall r. w (a -> m r) -> m r) -> CoT w m a
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT ((forall r. w (a -> m r) -> m r) -> CoT w m a)
-> (forall r. w (a -> m r) -> m r) -> CoT w m a
forall a b. (a -> b) -> a -> b
$ \ w (a -> m r)
_ -> String -> m r
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
Fail.fail String
msg

instance Comonad w => MonadTrans (CoT w) where
  lift :: forall (m :: * -> *) a. Monad m => m a -> CoT w m a
lift m a
m = (forall r. w (a -> m r) -> m r) -> CoT w m a
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (w (m r) -> m r
forall a. w a -> a
forall (w :: * -> *) a. Comonad w => w a -> a
extract (w (m r) -> m r)
-> (w (a -> m r) -> w (m r)) -> w (a -> m r) -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a -> m r) -> m r) -> w (a -> m r) -> w (m r)
forall a b. (a -> b) -> w a -> w b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (m a
m m a -> (a -> m r) -> m r
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=))

instance (Comonad w, MonadIO m) => MonadIO (CoT w m) where
  liftIO :: forall a. IO a -> CoT w m a
liftIO = m a -> CoT w m a
forall (m :: * -> *) a. Monad m => m a -> CoT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> CoT w m a) -> (IO a -> m a) -> IO a -> CoT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IO a -> m a
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO

liftCoT0 :: Comonad w => (forall a. w a -> s) -> CoT w m s
liftCoT0 :: forall {k} (w :: * -> *) s (m :: k -> *).
Comonad w =>
(forall a. w a -> s) -> CoT w m s
liftCoT0 forall a. w a -> s
f = (forall (r :: k). w (s -> m r) -> m r) -> CoT w m s
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (w (s -> m r) -> s -> m r
forall a. w a -> a
forall (w :: * -> *) a. Comonad w => w a -> a
extract (w (s -> m r) -> s -> m r)
-> (w (s -> m r) -> s) -> w (s -> m r) -> m r
forall a b.
(w (s -> m r) -> a -> b)
-> (w (s -> m r) -> a) -> w (s -> m r) -> b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> w (s -> m r) -> s
forall a. w a -> s
f)

lowerCoT0 :: (Functor w, Monad m) => CoT w m s -> w a -> m s
lowerCoT0 :: forall (w :: * -> *) (m :: * -> *) s a.
(Functor w, Monad m) =>
CoT w m s -> w a -> m s
lowerCoT0 CoT w m s
m = CoT w m s -> forall r. w (s -> m r) -> m r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT CoT w m s
m (w (s -> m s) -> m s) -> (w a -> w (s -> m s)) -> w a -> m s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s -> m s
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (s -> m s) -> w a -> w (s -> m s)
forall a b. a -> w b -> w a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$)

lowerCo0 :: Functor w => Co w s -> w a -> s
lowerCo0 :: forall (w :: * -> *) s a. Functor w => Co w s -> w a -> s
lowerCo0 Co w s
m = Identity s -> s
forall a. Identity a -> a
runIdentity (Identity s -> s) -> (w a -> Identity s) -> w a -> s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Co w s -> forall r. w (s -> Identity r) -> Identity r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT Co w s
m (w (s -> Identity s) -> Identity s)
-> (w a -> w (s -> Identity s)) -> w a -> Identity s
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (s -> Identity s
forall a. a -> Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (s -> Identity s) -> w a -> w (s -> Identity s)
forall a b. a -> w b -> w a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$)

liftCoT1 :: (forall a. w a -> a) -> CoT w m ()
liftCoT1 :: forall {k} (w :: * -> *) (m :: k -> *).
(forall a. w a -> a) -> CoT w m ()
liftCoT1 forall a. w a -> a
f = (forall (r :: k). w (() -> m r) -> m r) -> CoT w m ()
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (w (() -> m r) -> () -> m r
forall a. w a -> a
`f` ())

lowerCoT1 :: (Functor w, Monad m) => CoT w m () -> w a -> m a
lowerCoT1 :: forall (w :: * -> *) (m :: * -> *) a.
(Functor w, Monad m) =>
CoT w m () -> w a -> m a
lowerCoT1 CoT w m ()
m = CoT w m () -> forall r. w (() -> m r) -> m r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT CoT w m ()
m (w (() -> m a) -> m a) -> (w a -> w (() -> m a)) -> w a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> () -> m a) -> w a -> w (() -> m a)
forall a b. (a -> b) -> w a -> w b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (m a -> () -> m a
forall a b. a -> b -> a
const (m a -> () -> m a) -> (a -> m a) -> a -> () -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return)

lowerCo1 :: Functor w => Co w () -> w a -> a
lowerCo1 :: forall (w :: * -> *) a. Functor w => Co w () -> w a -> a
lowerCo1 Co w ()
m = Identity a -> a
forall a. Identity a -> a
runIdentity (Identity a -> a) -> (w a -> Identity a) -> w a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Co w () -> forall r. w (() -> Identity r) -> Identity r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT Co w ()
m (w (() -> Identity a) -> Identity a)
-> (w a -> w (() -> Identity a)) -> w a -> Identity a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> () -> Identity a) -> w a -> w (() -> Identity a)
forall a b. (a -> b) -> w a -> w b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Identity a -> () -> Identity a
forall a b. a -> b -> a
const (Identity a -> () -> Identity a)
-> (a -> Identity a) -> a -> () -> Identity a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Identity a
forall a. a -> Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return)

posW :: ComonadStore s w => CoT w m s
posW :: forall {k} s (w :: * -> *) (m :: k -> *).
ComonadStore s w =>
CoT w m s
posW = (forall a. w a -> s) -> CoT w m s
forall {k} (w :: * -> *) s (m :: k -> *).
Comonad w =>
(forall a. w a -> s) -> CoT w m s
liftCoT0 w a -> s
forall a. w a -> s
forall s (w :: * -> *) a. ComonadStore s w => w a -> s
pos

peekW :: ComonadStore s w => s -> CoT w m ()
peekW :: forall {k} s (w :: * -> *) (m :: k -> *).
ComonadStore s w =>
s -> CoT w m ()
peekW s
s = (forall a. w a -> a) -> CoT w m ()
forall {k} (w :: * -> *) (m :: k -> *).
(forall a. w a -> a) -> CoT w m ()
liftCoT1 (s -> w a -> a
forall a. s -> w a -> a
forall s (w :: * -> *) a. ComonadStore s w => s -> w a -> a
peek s
s)

peeksW :: ComonadStore s w => (s -> s) -> CoT w m ()
peeksW :: forall {k} s (w :: * -> *) (m :: k -> *).
ComonadStore s w =>
(s -> s) -> CoT w m ()
peeksW s -> s
f = (forall a. w a -> a) -> CoT w m ()
forall {k} (w :: * -> *) (m :: k -> *).
(forall a. w a -> a) -> CoT w m ()
liftCoT1 ((s -> s) -> w a -> a
forall a. (s -> s) -> w a -> a
forall s (w :: * -> *) a. ComonadStore s w => (s -> s) -> w a -> a
peeks s -> s
f)

askW :: ComonadEnv e w => CoT w m e
askW :: forall {k} e (w :: * -> *) (m :: k -> *).
ComonadEnv e w =>
CoT w m e
askW = (forall a. w a -> e) -> CoT w m e
forall {k} (w :: * -> *) s (m :: k -> *).
Comonad w =>
(forall a. w a -> s) -> CoT w m s
liftCoT0 (w a -> e
forall a. w a -> e
forall e (w :: * -> *) a. ComonadEnv e w => w a -> e
Env.ask)

asksW :: ComonadEnv e w => (e -> a) -> CoT w m a
asksW :: forall {k} e (w :: * -> *) a (m :: k -> *).
ComonadEnv e w =>
(e -> a) -> CoT w m a
asksW e -> a
f = (forall a. w a -> a) -> CoT w m a
forall {k} (w :: * -> *) s (m :: k -> *).
Comonad w =>
(forall a. w a -> s) -> CoT w m s
liftCoT0 ((e -> a) -> w a -> a
forall e (w :: * -> *) e' a.
ComonadEnv e w =>
(e -> e') -> w a -> e'
Env.asks e -> a
f)

traceW :: ComonadTraced e w => e -> CoT w m ()
traceW :: forall {k} e (w :: * -> *) (m :: k -> *).
ComonadTraced e w =>
e -> CoT w m ()
traceW e
e = (forall a. w a -> a) -> CoT w m ()
forall {k} (w :: * -> *) (m :: k -> *).
(forall a. w a -> a) -> CoT w m ()
liftCoT1 (e -> w a -> a
forall a. e -> w a -> a
forall m (w :: * -> *) a. ComonadTraced m w => m -> w a -> a
Traced.trace e
e)

liftCoT0M :: (Comonad w, Monad m) => (forall a. w a -> m s) -> CoT w m s
liftCoT0M :: forall (w :: * -> *) (m :: * -> *) s.
(Comonad w, Monad m) =>
(forall a. w a -> m s) -> CoT w m s
liftCoT0M forall a. w a -> m s
f = (forall r. w (s -> m r) -> m r) -> CoT w m s
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (\w (s -> m r)
wa -> w (s -> m r) -> s -> m r
forall a. w a -> a
forall (w :: * -> *) a. Comonad w => w a -> a
extract w (s -> m r)
wa (s -> m r) -> m s -> m r
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< w (s -> m r) -> m s
forall a. w a -> m s
f w (s -> m r)
wa)

liftCoT1M :: Monad m => (forall a. w a -> m a) -> CoT w m ()
liftCoT1M :: forall (m :: * -> *) (w :: * -> *).
Monad m =>
(forall a. w a -> m a) -> CoT w m ()
liftCoT1M forall a. w a -> m a
f = (forall r. w (() -> m r) -> m r) -> CoT w m ()
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (((() -> m r) -> () -> m r
forall a b. (a -> b) -> a -> b
$ ()) ((() -> m r) -> m r)
-> (w (() -> m r) -> m (() -> m r)) -> w (() -> m r) -> m r
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< w (() -> m r) -> m (() -> m r)
forall a. w a -> m a
f)

diter :: Functor f => a -> (a -> f a) -> Density (Cofree f) a
diter :: forall (f :: * -> *) a.
Functor f =>
a -> (a -> f a) -> Density (Cofree f) a
diter a
x a -> f a
y = Cofree f a -> Density (Cofree f) a
forall (w :: * -> *) a. Comonad w => w a -> Density w a
liftDensity (Cofree f a -> Density (Cofree f) a)
-> (a -> Cofree f a) -> a -> Density (Cofree f) a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f a) -> a -> Cofree f a
forall (f :: * -> *) a. Functor f => (a -> f a) -> a -> Cofree f a
coiter a -> f a
y (a -> Density (Cofree f) a) -> a -> Density (Cofree f) a
forall a b. (a -> b) -> a -> b
$ a
x

dctrlM :: Monad m => (forall a. w a -> m (w a)) -> CoT (Density w) m ()
dctrlM :: forall {k} (m :: * -> *) (w :: k -> *).
Monad m =>
(forall (a :: k). w a -> m (w a)) -> CoT (Density w) m ()
dctrlM forall (a :: k). w a -> m (w a)
k = (forall a. Density w a -> m a) -> CoT (Density w) m ()
forall (m :: * -> *) (w :: * -> *).
Monad m =>
(forall a. w a -> m a) -> CoT w m ()
liftCoT1M (\(Density w b -> a
w w b
a) -> (w b -> a) -> m (w b) -> m a
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM w b -> a
w (w b -> m (w b)
forall (a :: k). w a -> m (w a)
k w b
a))

instance (Comonad w, MonadReader e m) => MonadReader e (CoT w m) where
  ask :: CoT w m e
ask = m e -> CoT w m e
forall (m :: * -> *) a. Monad m => m a -> CoT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m e
forall r (m :: * -> *). MonadReader r m => m r
Reader.ask
  local :: forall a. (e -> e) -> CoT w m a -> CoT w m a
local e -> e
f CoT w m a
m = (forall r. w (a -> m r) -> m r) -> CoT w m a
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT ((e -> e) -> m r -> m r
forall a. (e -> e) -> m a -> m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local e -> e
f (m r -> m r) -> (w (a -> m r) -> m r) -> w (a -> m r) -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoT w m a -> forall r. w (a -> m r) -> m r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT CoT w m a
m)

instance (Comonad w, MonadState s m) => MonadState s (CoT w m) where
  get :: CoT w m s
get = m s -> CoT w m s
forall (m :: * -> *) a. Monad m => m a -> CoT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m s
forall s (m :: * -> *). MonadState s m => m s
get
  put :: s -> CoT w m ()
put = m () -> CoT w m ()
forall (m :: * -> *) a. Monad m => m a -> CoT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> CoT w m ()) -> (s -> m ()) -> s -> CoT w m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put

instance (Comonad w, MonadWriter e m) => MonadWriter e (CoT w m) where
  tell :: e -> CoT w m ()
tell = m () -> CoT w m ()
forall (m :: * -> *) a. Monad m => m a -> CoT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> CoT w m ()) -> (e -> m ()) -> e -> CoT w m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
  pass :: forall a. CoT w m (a, e -> e) -> CoT w m a
pass CoT w m (a, e -> e)
m = (forall r. w (a -> m r) -> m r) -> CoT w m a
forall {k} (w :: * -> *) (m :: k -> *) a.
(forall (r :: k). w (a -> m r) -> m r) -> CoT w m a
CoT (m (r, e -> e) -> m r
forall a. m (a, e -> e) -> m a
forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
pass (m (r, e -> e) -> m r)
-> (w (a -> m r) -> m (r, e -> e)) -> w (a -> m r) -> m r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CoT w m (a, e -> e) -> forall r. w ((a, e -> e) -> m r) -> m r
forall {k} (w :: * -> *) (m :: k -> *) a.
CoT w m a -> forall (r :: k). w (a -> m r) -> m r
runCoT CoT w m (a, e -> e)
m (w ((a, e -> e) -> m (r, e -> e)) -> m (r, e -> e))
-> (w (a -> m r) -> w ((a, e -> e) -> m (r, e -> e)))
-> w (a -> m r)
-> m (r, e -> e)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a -> m r) -> (a, e -> e) -> m (r, e -> e))
-> w (a -> m r) -> w ((a, e -> e) -> m (r, e -> e))
forall a b. (a -> b) -> w a -> w b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> m r) -> (a, e -> e) -> m (r, e -> e)
forall {m :: * -> *} {t} {a} {b}.
Monad m =>
(t -> m a) -> (t, b) -> m (a, b)
aug) where
    aug :: (t -> m a) -> (t, b) -> m (a, b)
aug t -> m a
f (t
a,b
e) = (a -> (a, b)) -> m a -> m (a, b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM (\a
r -> (a
r,b
e)) (t -> m a
f t
a)
  listen :: forall a. CoT w m a -> CoT w m (a, e)
listen = String -> CoT w m a -> CoT w m (a, e)
forall a. HasCallStack => String -> a
error String
"Control.Monad.Co.listen: TODO"

instance (Comonad w, MonadError e m) => MonadError e (CoT w m) where
  throwError :: forall a. e -> CoT w m a
throwError = m a -> CoT w m a
forall (m :: * -> *) a. Monad m => m a -> CoT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> CoT w m a) -> (e -> m a) -> e -> CoT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
  catchError :: forall a. CoT w m a -> (e -> CoT w m a) -> CoT w m a
catchError = String -> CoT w m a -> (e -> CoT w m a) -> CoT w m a
forall a. HasCallStack => String -> a
error String
"Control.Monad.Co.catchError: TODO"