{-# LANGUAGE TemplateHaskell #-}
-----------------------------------------------------------------------------

-- |

-- Module      :  Control.Effect.RWS

-- Copyright   :  (c) Michael Szvetits, 2020

-- License     :  BSD3 (see the file LICENSE)

-- Maintainer  :  typedbyte@qualified.name

-- Stability   :  stable

-- Portability :  portable

--

-- The effect that combines the reader, writer and state effect, similar to the

-- @MonadRWS@ type class from the @mtl@ library.

--

-- Lazy and strict interpretations of the effect are available here:

-- "Control.Effect.RWS.Lazy" and "Control.Effect.RWS.Strict".

-----------------------------------------------------------------------------

module Control.Effect.RWS
  ( -- * Tagged RWS Effect

    RWS'
    -- * Untagged RWS Effect

    -- | If you don't require disambiguation of multiple RWS effects

    -- (i.e., you only have one RWS effect in your monadic context),

    -- it is recommended to always use the untagged RWS effect.

  , RWS
    -- * Interpretations

  , Separation
  , runSeparatedRWS'
  , runSeparatedRWS
    -- * Tagging and Untagging

  , Tagger
    -- | Conversion functions between the tagged and untagged RWS effect,

    -- usually used in combination with type applications, like:

    --

    -- @

    --     'tagRWS'' \@\"newTag\" program

    --     'retagRWS'' \@\"oldTag\" \@\"newTag\" program

    --     'untagRWS'' \@\"erasedTag\" program

    -- @

    -- 

  , tagRWS'
  , retagRWS'
  , untagRWS'
  ) where

-- base

import Data.Coerce (coerce)

-- transformers

import qualified Control.Monad.Trans.RWS.CPS  as Strict
import qualified Control.Monad.Trans.RWS.Lazy as Lazy

import qualified Control.Effect.Reader as R
import qualified Control.Effect.State  as S
import qualified Control.Effect.Writer as W

import Control.Effect.Machinery hiding (Tagger)

-- | An effect that adds the following features to a given computation:

--

--     * (R) an immutable environment (the \"reader\" part)

--     * (W) a write-only, accumulated output (the \"writer\" part)

--     * (S) a mutable state (the \"state\" part)

--

-- @since 0.2.0.0

class (R.Reader' tag r m, W.Writer' tag w m, S.State' tag s m) => RWS' tag r w s m | tag m -> r w s

type RWS r w s = RWS' G r w s

instance ( Monad (t m),
           R.Reader' tag r (EachVia effs t m),
           W.Writer' tag w (EachVia effs t m),
           S.State' tag s (EachVia effs t m)
         ) => RWS' tag r w s (EachVia (RWS' tag r w s : effs) t m)

instance {-# OVERLAPPABLE #-}
         Find (RWS' tag r w s) effs t m => RWS' tag r w s (EachVia (other : effs) t m)

instance Control (RWS' tag r w s) t m => RWS' tag r w s (EachVia '[] t m)

instance (Monad m, Monoid w) => RWS' tag r w s (Lazy.RWST r w s m)
instance (Monad m, Monoid w) => RWS' tag r w s (Strict.RWST r w s m)

-- | The separation interpreter of the RWS effect. This type implements the 'RWS''

-- type class by splitting the effect into separate 'R.Reader'', 'W.Writer'' and

-- 'S.State'' effects which can then be interpreted individually.

--

-- When interpreting the effect, you usually don\'t interact with this type directly,

-- but instead use one of its corresponding interpretation functions.

newtype Separation m a =
  Separation { Separation m a -> m a
_runSeparation :: m a }
    deriving (Functor (Separation m)
a -> Separation m a
Functor (Separation m) =>
(forall a. a -> Separation m a)
-> (forall a b.
    Separation m (a -> b) -> Separation m a -> Separation m b)
-> (forall a b c.
    (a -> b -> c)
    -> Separation m a -> Separation m b -> Separation m c)
-> (forall a b. Separation m a -> Separation m b -> Separation m b)
-> (forall a b. Separation m a -> Separation m b -> Separation m a)
-> Applicative (Separation m)
Separation m a -> Separation m b -> Separation m b
Separation m a -> Separation m b -> Separation m a
Separation m (a -> b) -> Separation m a -> Separation m b
(a -> b -> c) -> Separation m a -> Separation m b -> Separation m c
forall a. a -> Separation m a
forall a b. Separation m a -> Separation m b -> Separation m a
forall a b. Separation m a -> Separation m b -> Separation m b
forall a b.
Separation m (a -> b) -> Separation m a -> Separation m b
forall a b c.
(a -> b -> c) -> Separation m a -> Separation m b -> Separation m c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall (m :: * -> *). Applicative m => Functor (Separation m)
forall (m :: * -> *) a. Applicative m => a -> Separation m a
forall (m :: * -> *) a b.
Applicative m =>
Separation m a -> Separation m b -> Separation m a
forall (m :: * -> *) a b.
Applicative m =>
Separation m a -> Separation m b -> Separation m b
forall (m :: * -> *) a b.
Applicative m =>
Separation m (a -> b) -> Separation m a -> Separation m b
forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> Separation m a -> Separation m b -> Separation m c
<* :: Separation m a -> Separation m b -> Separation m a
$c<* :: forall (m :: * -> *) a b.
Applicative m =>
Separation m a -> Separation m b -> Separation m a
*> :: Separation m a -> Separation m b -> Separation m b
$c*> :: forall (m :: * -> *) a b.
Applicative m =>
Separation m a -> Separation m b -> Separation m b
liftA2 :: (a -> b -> c) -> Separation m a -> Separation m b -> Separation m c
$cliftA2 :: forall (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c) -> Separation m a -> Separation m b -> Separation m c
<*> :: Separation m (a -> b) -> Separation m a -> Separation m b
$c<*> :: forall (m :: * -> *) a b.
Applicative m =>
Separation m (a -> b) -> Separation m a -> Separation m b
pure :: a -> Separation m a
$cpure :: forall (m :: * -> *) a. Applicative m => a -> Separation m a
$cp1Applicative :: forall (m :: * -> *). Applicative m => Functor (Separation m)
Applicative, a -> Separation m b -> Separation m a
(a -> b) -> Separation m a -> Separation m b
(forall a b. (a -> b) -> Separation m a -> Separation m b)
-> (forall a b. a -> Separation m b -> Separation m a)
-> Functor (Separation m)
forall a b. a -> Separation m b -> Separation m a
forall a b. (a -> b) -> Separation m a -> Separation m b
forall (m :: * -> *) a b.
Functor m =>
a -> Separation m b -> Separation m a
forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> Separation m a -> Separation m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Separation m b -> Separation m a
$c<$ :: forall (m :: * -> *) a b.
Functor m =>
a -> Separation m b -> Separation m a
fmap :: (a -> b) -> Separation m a -> Separation m b
$cfmap :: forall (m :: * -> *) a b.
Functor m =>
(a -> b) -> Separation m a -> Separation m b
Functor, Applicative (Separation m)
a -> Separation m a
Applicative (Separation m) =>
(forall a b.
 Separation m a -> (a -> Separation m b) -> Separation m b)
-> (forall a b. Separation m a -> Separation m b -> Separation m b)
-> (forall a. a -> Separation m a)
-> Monad (Separation m)
Separation m a -> (a -> Separation m b) -> Separation m b
Separation m a -> Separation m b -> Separation m b
forall a. a -> Separation m a
forall a b. Separation m a -> Separation m b -> Separation m b
forall a b.
Separation m a -> (a -> Separation m b) -> Separation m b
forall (m :: * -> *). Monad m => Applicative (Separation m)
forall (m :: * -> *) a. Monad m => a -> Separation m a
forall (m :: * -> *) a b.
Monad m =>
Separation m a -> Separation m b -> Separation m b
forall (m :: * -> *) a b.
Monad m =>
Separation m a -> (a -> Separation m b) -> Separation m b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Separation m a
$creturn :: forall (m :: * -> *) a. Monad m => a -> Separation m a
>> :: Separation m a -> Separation m b -> Separation m b
$c>> :: forall (m :: * -> *) a b.
Monad m =>
Separation m a -> Separation m b -> Separation m b
>>= :: Separation m a -> (a -> Separation m b) -> Separation m b
$c>>= :: forall (m :: * -> *) a b.
Monad m =>
Separation m a -> (a -> Separation m b) -> Separation m b
$cp1Monad :: forall (m :: * -> *). Monad m => Applicative (Separation m)
Monad, Monad (Separation m)
Monad (Separation m) =>
(forall a. IO a -> Separation m a) -> MonadIO (Separation m)
IO a -> Separation m a
forall a. IO a -> Separation m a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
forall (m :: * -> *). MonadIO m => Monad (Separation m)
forall (m :: * -> *) a. MonadIO m => IO a -> Separation m a
liftIO :: IO a -> Separation m a
$cliftIO :: forall (m :: * -> *) a. MonadIO m => IO a -> Separation m a
$cp1MonadIO :: forall (m :: * -> *). MonadIO m => Monad (Separation m)
MonadIO)
    deriving (m a -> Separation m a
(forall (m :: * -> *) a. Monad m => m a -> Separation m a)
-> MonadTrans Separation
forall (m :: * -> *) a. Monad m => m a -> Separation m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> Separation m a
$clift :: forall (m :: * -> *) a. Monad m => m a -> Separation m a
MonadTrans, MonadTrans Separation
m (StT Separation a) -> Separation m a
MonadTrans Separation =>
(forall (m :: * -> *) a.
 Monad m =>
 (Run Separation -> m a) -> Separation m a)
-> (forall (m :: * -> *) a.
    Monad m =>
    m (StT Separation a) -> Separation m a)
-> MonadTransControl Separation
(Run Separation -> m a) -> Separation m a
forall (m :: * -> *) a.
Monad m =>
m (StT Separation a) -> Separation m a
forall (m :: * -> *) a.
Monad m =>
(Run Separation -> m a) -> Separation m a
forall (t :: (* -> *) -> * -> *).
MonadTrans t =>
(forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
restoreT :: m (StT Separation a) -> Separation m a
$crestoreT :: forall (m :: * -> *) a.
Monad m =>
m (StT Separation a) -> Separation m a
liftWith :: (Run Separation -> m a) -> Separation m a
$cliftWith :: forall (m :: * -> *) a.
Monad m =>
(Run Separation -> m a) -> Separation m a
$cp1MonadTransControl :: MonadTrans Separation
MonadTransControl) via Default
    deriving (MonadBase b, MonadBaseControl b)
    deriving (R.Reader' tag r, W.Writer' tag w, S.State' tag s)

instance (R.Reader' tag r m, W.Writer' tag w m, S.State' tag s m) => RWS' tag r w s (Separation m)

-- | Runs the RWS effect via separation.

runSeparatedRWS'
  :: ('[RWS' tag r w s, R.Reader' tag r, W.Writer' tag w, S.State' tag s] `EachVia` Separation) m a
  -- ^ The program whose RWS effect should be handled.

  -> m a
  -- ^ The program with its RWS effect handled.

runSeparatedRWS' :: EachVia
  '[RWS' tag r w s, Reader' tag r, Writer' tag w, State' tag s]
  Separation
  m
  a
-> m a
runSeparatedRWS' = EachVia
  '[RWS' tag r w s, Reader' tag r, Writer' tag w, State' tag s]
  Separation
  m
  a
-> m a
forall a b. Coercible a b => a -> b
coerce
{-# INLINE runSeparatedRWS' #-}

-- | The untagged version of 'runSeparatedRWS''.

runSeparatedRWS :: ('[RWS r w s, R.Reader r, W.Writer w, S.State s] `EachVia` Separation) m a -> m a
runSeparatedRWS :: EachVia '[RWS r w s, Reader r, Writer w, State s] Separation m a
-> m a
runSeparatedRWS = EachVia '[RWS r w s, Reader r, Writer w, State s] Separation m a
-> m a
forall a b. Coercible a b => a -> b
coerce
{-# INLINE runSeparatedRWS #-}

-- | The tagging interpreter of the RWS effect. This type implements the

-- 'RWS'' type class by tagging\/retagging\/untagging its reader, writer and state

-- components.

--

-- When interpreting the effect, you usually don\'t interact with this type directly,

-- but instead use one of its corresponding interpretation functions.

--

-- @since 0.2.0.0

newtype Tagger tag new m a =
  Tagger { Tagger tag new m a -> m a
runRWSTagger :: m a }
    deriving (Functor (Tagger tag new m)
a -> Tagger tag new m a
Functor (Tagger tag new m) =>
(forall a. a -> Tagger tag new m a)
-> (forall a b.
    Tagger tag new m (a -> b)
    -> Tagger tag new m a -> Tagger tag new m b)
-> (forall a b c.
    (a -> b -> c)
    -> Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m c)
-> (forall a b.
    Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b)
-> (forall a b.
    Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m a)
-> Applicative (Tagger tag new m)
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m a
Tagger tag new m (a -> b)
-> Tagger tag new m a -> Tagger tag new m b
(a -> b -> c)
-> Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m c
forall a. a -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *).
Applicative m =>
Functor (Tagger tag new m)
forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Applicative m =>
a -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Applicative m =>
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Applicative m =>
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Applicative m =>
Tagger tag new m (a -> b)
-> Tagger tag new m a -> Tagger tag new m b
forall k (tag :: k) k (new :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m c
forall a b.
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m a
forall a b.
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
forall a b.
Tagger tag new m (a -> b)
-> Tagger tag new m a -> Tagger tag new m b
forall a b c.
(a -> b -> c)
-> Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m c
forall (f :: * -> *).
Functor f =>
(forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m a
$c<* :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Applicative m =>
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m a
*> :: Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
$c*> :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Applicative m =>
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
liftA2 :: (a -> b -> c)
-> Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m c
$cliftA2 :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b c.
Applicative m =>
(a -> b -> c)
-> Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m c
<*> :: Tagger tag new m (a -> b)
-> Tagger tag new m a -> Tagger tag new m b
$c<*> :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Applicative m =>
Tagger tag new m (a -> b)
-> Tagger tag new m a -> Tagger tag new m b
pure :: a -> Tagger tag new m a
$cpure :: forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Applicative m =>
a -> Tagger tag new m a
$cp1Applicative :: forall k (tag :: k) k (new :: k) (m :: * -> *).
Applicative m =>
Functor (Tagger tag new m)
Applicative, a -> Tagger tag new m b -> Tagger tag new m a
(a -> b) -> Tagger tag new m a -> Tagger tag new m b
(forall a b. (a -> b) -> Tagger tag new m a -> Tagger tag new m b)
-> (forall a b. a -> Tagger tag new m b -> Tagger tag new m a)
-> Functor (Tagger tag new m)
forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Functor m =>
a -> Tagger tag new m b -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> Tagger tag new m a -> Tagger tag new m b
forall a b. a -> Tagger tag new m b -> Tagger tag new m a
forall a b. (a -> b) -> Tagger tag new m a -> Tagger tag new m b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Tagger tag new m b -> Tagger tag new m a
$c<$ :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Functor m =>
a -> Tagger tag new m b -> Tagger tag new m a
fmap :: (a -> b) -> Tagger tag new m a -> Tagger tag new m b
$cfmap :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Functor m =>
(a -> b) -> Tagger tag new m a -> Tagger tag new m b
Functor, Applicative (Tagger tag new m)
a -> Tagger tag new m a
Applicative (Tagger tag new m) =>
(forall a b.
 Tagger tag new m a
 -> (a -> Tagger tag new m b) -> Tagger tag new m b)
-> (forall a b.
    Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b)
-> (forall a. a -> Tagger tag new m a)
-> Monad (Tagger tag new m)
Tagger tag new m a
-> (a -> Tagger tag new m b) -> Tagger tag new m b
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
forall a. a -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *).
Monad m =>
Applicative (Tagger tag new m)
forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
a -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Monad m =>
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Monad m =>
Tagger tag new m a
-> (a -> Tagger tag new m b) -> Tagger tag new m b
forall a b.
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
forall a b.
Tagger tag new m a
-> (a -> Tagger tag new m b) -> Tagger tag new m b
forall (m :: * -> *).
Applicative m =>
(forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: a -> Tagger tag new m a
$creturn :: forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
a -> Tagger tag new m a
>> :: Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
$c>> :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Monad m =>
Tagger tag new m a -> Tagger tag new m b -> Tagger tag new m b
>>= :: Tagger tag new m a
-> (a -> Tagger tag new m b) -> Tagger tag new m b
$c>>= :: forall k (tag :: k) k (new :: k) (m :: * -> *) a b.
Monad m =>
Tagger tag new m a
-> (a -> Tagger tag new m b) -> Tagger tag new m b
$cp1Monad :: forall k (tag :: k) k (new :: k) (m :: * -> *).
Monad m =>
Applicative (Tagger tag new m)
Monad, Monad (Tagger tag new m)
Monad (Tagger tag new m) =>
(forall a. IO a -> Tagger tag new m a)
-> MonadIO (Tagger tag new m)
IO a -> Tagger tag new m a
forall a. IO a -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *).
MonadIO m =>
Monad (Tagger tag new m)
forall k (tag :: k) k (new :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> Tagger tag new m a
forall (m :: * -> *).
Monad m =>
(forall a. IO a -> m a) -> MonadIO m
liftIO :: IO a -> Tagger tag new m a
$cliftIO :: forall k (tag :: k) k (new :: k) (m :: * -> *) a.
MonadIO m =>
IO a -> Tagger tag new m a
$cp1MonadIO :: forall k (tag :: k) k (new :: k) (m :: * -> *).
MonadIO m =>
Monad (Tagger tag new m)
MonadIO)
    deriving (m a -> Tagger tag new m a
(forall (m :: * -> *) a. Monad m => m a -> Tagger tag new m a)
-> MonadTrans (Tagger tag new)
forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
m a -> Tagger tag new m a
forall (m :: * -> *) a. Monad m => m a -> Tagger tag new m a
forall (t :: (* -> *) -> * -> *).
(forall (m :: * -> *) a. Monad m => m a -> t m a) -> MonadTrans t
lift :: m a -> Tagger tag new m a
$clift :: forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
m a -> Tagger tag new m a
MonadTrans, MonadTrans (Tagger tag new)
m (StT (Tagger tag new) a) -> Tagger tag new m a
MonadTrans (Tagger tag new) =>
(forall (m :: * -> *) a.
 Monad m =>
 (Run (Tagger tag new) -> m a) -> Tagger tag new m a)
-> (forall (m :: * -> *) a.
    Monad m =>
    m (StT (Tagger tag new) a) -> Tagger tag new m a)
-> MonadTransControl (Tagger tag new)
(Run (Tagger tag new) -> m a) -> Tagger tag new m a
forall k (tag :: k) k (new :: k). MonadTrans (Tagger tag new)
forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
m (StT (Tagger tag new) a) -> Tagger tag new m a
forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
(Run (Tagger tag new) -> m a) -> Tagger tag new m a
forall (m :: * -> *) a.
Monad m =>
m (StT (Tagger tag new) a) -> Tagger tag new m a
forall (m :: * -> *) a.
Monad m =>
(Run (Tagger tag new) -> m a) -> Tagger tag new m a
forall (t :: (* -> *) -> * -> *).
MonadTrans t =>
(forall (m :: * -> *) a. Monad m => (Run t -> m a) -> t m a)
-> (forall (m :: * -> *) a. Monad m => m (StT t a) -> t m a)
-> MonadTransControl t
restoreT :: m (StT (Tagger tag new) a) -> Tagger tag new m a
$crestoreT :: forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
m (StT (Tagger tag new) a) -> Tagger tag new m a
liftWith :: (Run (Tagger tag new) -> m a) -> Tagger tag new m a
$cliftWith :: forall k (tag :: k) k (new :: k) (m :: * -> *) a.
Monad m =>
(Run (Tagger tag new) -> m a) -> Tagger tag new m a
$cp1MonadTransControl :: forall k (tag :: k) k (new :: k). MonadTrans (Tagger tag new)
MonadTransControl) via Default
    deriving (MonadBase b, MonadBaseControl b)

instance RWS' new r w s m => RWS' tag r w s (Tagger tag new m)

instance RWS' new r w s m => R.Reader' tag r (Tagger tag new m) where
  ask' :: Tagger tag new m r
ask' = m r -> Tagger tag new m r
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger (forall k (tag :: k) r (m :: * -> *). Reader' tag r m => m r
forall r (m :: * -> *). Reader' new r m => m r
R.ask' @new)
  {-# INLINE ask' #-}
  local' :: (r -> r) -> Tagger tag new m a -> Tagger tag new m a
local' f :: r -> r
f m :: Tagger tag new m a
m = m a -> Tagger tag new m a
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger ((r -> r) -> m a -> m a
forall k (tag :: k) r (m :: * -> *) a.
Reader' tag r m =>
(r -> r) -> m a -> m a
R.local' @new r -> r
f (Tagger tag new m a -> m a
forall k (tag :: k) k (new :: k) k (m :: k -> *) (a :: k).
Tagger tag new m a -> m a
runRWSTagger Tagger tag new m a
m))
  {-# INLINE local' #-}
  reader' :: (r -> a) -> Tagger tag new m a
reader' f :: r -> a
f = m a -> Tagger tag new m a
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger ((r -> a) -> m a
forall k (tag :: k) r (m :: * -> *) a.
Reader' tag r m =>
(r -> a) -> m a
R.reader' @new r -> a
f)
  {-# INLINE reader' #-}

instance RWS' new r w s m => W.Writer' tag w (Tagger tag new m) where
  tell' :: w -> Tagger tag new m ()
tell' w :: w
w = m () -> Tagger tag new m ()
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger (w -> m ()
forall k (tag :: k) w (m :: * -> *). Writer' tag w m => w -> m ()
W.tell' @new w
w)
  {-# INLINE tell' #-}
  listen' :: Tagger tag new m a -> Tagger tag new m (w, a)
listen' m :: Tagger tag new m a
m = m (w, a) -> Tagger tag new m (w, a)
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger (m a -> m (w, a)
forall k (tag :: k) w (m :: * -> *) a.
Writer' tag w m =>
m a -> m (w, a)
W.listen' @new (Tagger tag new m a -> m a
forall k (tag :: k) k (new :: k) k (m :: k -> *) (a :: k).
Tagger tag new m a -> m a
runRWSTagger Tagger tag new m a
m))
  {-# INLINE listen' #-}
  censor' :: (w -> w) -> Tagger tag new m a -> Tagger tag new m a
censor' f :: w -> w
f m :: Tagger tag new m a
m = m a -> Tagger tag new m a
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger ((w -> w) -> m a -> m a
forall k (tag :: k) w (m :: * -> *) a.
Writer' tag w m =>
(w -> w) -> m a -> m a
W.censor' @new w -> w
f (Tagger tag new m a -> m a
forall k (tag :: k) k (new :: k) k (m :: k -> *) (a :: k).
Tagger tag new m a -> m a
runRWSTagger Tagger tag new m a
m))
  {-# INLINE censor' #-}

instance RWS' new r w s m => S.State' tag s (Tagger tag new m) where
  get' :: Tagger tag new m s
get' = m s -> Tagger tag new m s
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger (forall k (tag :: k) s (m :: * -> *). State' tag s m => m s
forall s (m :: * -> *). State' new s m => m s
S.get' @new)
  {-# INLINE get' #-}
  put' :: s -> Tagger tag new m ()
put' s :: s
s = m () -> Tagger tag new m ()
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger (s -> m ()
forall k (tag :: k) s (m :: * -> *). State' tag s m => s -> m ()
S.put' @new s
s)
  {-# INLINE put' #-}
  state' :: (s -> (s, a)) -> Tagger tag new m a
state' f :: s -> (s, a)
f = m a -> Tagger tag new m a
forall k k k (tag :: k) (new :: k) (m :: k -> *) (a :: k).
m a -> Tagger tag new m a
Tagger ((s -> (s, a)) -> m a
forall k (tag :: k) s (m :: * -> *) a.
State' tag s m =>
(s -> (s, a)) -> m a
S.state' @new s -> (s, a)
f)
  {-# INLINE state' #-}

tagRWS' :: forall new r w s m a. ('[RWS' G r w s, R.Reader' G r, W.Writer' G w, S.State' G s] `EachVia` Tagger G new) m a -> m a
tagRWS' :: EachVia
  '[RWS' G r w s, Reader' G r, Writer' G w, State' G s]
  (Tagger G new)
  m
  a
-> m a
tagRWS' = EachVia
  '[RWS' G r w s, Reader' G r, Writer' G w, State' G s]
  (Tagger G new)
  m
  a
-> m a
forall a b. Coercible a b => a -> b
coerce
{-# INLINE tagRWS' #-}

retagRWS' :: forall tag new r w s m a. ('[RWS' tag r w s, R.Reader' tag r, W.Writer' tag w, S.State' tag s] `EachVia` Tagger tag new) m a -> m a
retagRWS' :: EachVia
  '[RWS' tag r w s, Reader' tag r, Writer' tag w, State' tag s]
  (Tagger tag new)
  m
  a
-> m a
retagRWS' = EachVia
  '[RWS' tag r w s, Reader' tag r, Writer' tag w, State' tag s]
  (Tagger tag new)
  m
  a
-> m a
forall a b. Coercible a b => a -> b
coerce
{-# INLINE retagRWS' #-}

untagRWS' :: forall tag r w s m a. ('[RWS' tag r w s, R.Reader' tag r, W.Writer' tag w, S.State' tag s] `EachVia` Tagger tag G) m a -> m a
untagRWS' :: EachVia
  '[RWS' tag r w s, Reader' tag r, Writer' tag w, State' tag s]
  (Tagger tag G)
  m
  a
-> m a
untagRWS' = EachVia
  '[RWS' tag r w s, Reader' tag r, Writer' tag w, State' tag s]
  (Tagger tag G)
  m
  a
-> m a
forall a b. Coercible a b => a -> b
coerce
{-# INLINE untagRWS' #-}