{-| This is an internal module, meaning that it is unsafe to import unless you
    understand the risks.

    This module provides a fast implementation by weakening the monad
    transformer laws.  These laws do not hold if you can pattern match on the
    constructors, as the following counter-example illustrates:

@
'lift' '.' 'return' = 'M' '.' 'return' '.' 'Pure'

'return' = 'Pure'

'lift' '.' 'return' /= 'return'
@

    You do not need to worry about this if you do not import this module, since
    the other modules in this library do not export the constructors or export
    any functions which can violate the monad transformer laws.
-}

{-# LANGUAGE CPP                   #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes            #-}
{-# LANGUAGE UndecidableInstances  #-}
{-# LANGUAGE Trustworthy           #-}

module Pipes.Internal (
    -- * Internal
      Proxy(..)
    , unsafeHoist
    , observe
    , X
    , closed
    ) where

import qualified Control.Monad.Fail as F (MonadFail(fail))
import Control.Monad.IO.Class (MonadIO(liftIO))
import Control.Monad.Trans.Class (MonadTrans(lift))
import Control.Monad.Morph (MFunctor(hoist), MMonad(embed))
import Control.Monad.Except (MonadError(..))
import Control.Monad.Catch (MonadThrow(..), MonadCatch(..))
import Control.Monad.Reader (MonadReader(..))
import Control.Monad.State (MonadState(..))
import Control.Monad.Writer (MonadWriter(..), censor)
import Data.Void (Void)

#if MIN_VERSION_base(4,8,0)
import Control.Applicative (Alternative(..))
#else
import Control.Applicative
#endif
import Data.Semigroup

import qualified Data.Void

{-| A 'Proxy' is a monad transformer that receives and sends information on both
    an upstream and downstream interface.

    The type variables signify:

    * @a'@ and @a@ - The upstream interface, where @(a')@s go out and @(a)@s
      come in

    * @b'@ and @b@ - The downstream interface, where @(b)@s go out and @(b')@s
      come in

    * @m @ - The base monad

    * @r @ - The return value
-}
data Proxy a' a b' b m r
    = Request a' (a  -> Proxy a' a b' b m r )
    | Respond b  (b' -> Proxy a' a b' b m r )
    | M          (m    (Proxy a' a b' b m r))
    | Pure    r

instance Functor m => Functor (Proxy a' a b' b m) where
    fmap :: forall a b. (a -> b) -> Proxy a' a b' b m a -> Proxy a' a b' b m b
fmap a -> b
f Proxy a' a b' b m a
p0 = forall {m :: * -> *} {a'} {a} {b'} {b}.
Functor m =>
Proxy a' a b' b m a -> Proxy a' a b' b m b
go Proxy a' a b' b m a
p0 where
        go :: Proxy a' a b' b m a -> Proxy a' a b' b m b
go Proxy a' a b' b m a
p = case Proxy a' a b' b m a
p of
            Request a'
a' a -> Proxy a' a b' b m a
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m a -> Proxy a' a b' b m b
go (a -> Proxy a' a b' b m a
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m a
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m a -> Proxy a' a b' b m b
go (b' -> Proxy a' a b' b m a
fb' b'
b'))
            M          m (Proxy a' a b' b m a)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (Proxy a' a b' b m a -> Proxy a' a b' b m b
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Proxy a' a b' b m a)
m)
            Pure    a
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure (a -> b
f a
r)

instance Functor m => Applicative (Proxy a' a b' b m) where
    pure :: forall a. a -> Proxy a' a b' b m a
pure      = forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure
    Proxy a' a b' b m (a -> b)
pf <*> :: forall a b.
Proxy a' a b' b m (a -> b)
-> Proxy a' a b' b m a -> Proxy a' a b' b m b
<*> Proxy a' a b' b m a
px = forall {r}. Proxy a' a b' b m (a -> r) -> Proxy a' a b' b m r
go Proxy a' a b' b m (a -> b)
pf where
        go :: Proxy a' a b' b m (a -> r) -> Proxy a' a b' b m r
go Proxy a' a b' b m (a -> r)
p = case Proxy a' a b' b m (a -> r)
p of
            Request a'
a' a -> Proxy a' a b' b m (a -> r)
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m (a -> r) -> Proxy a' a b' b m r
go (a -> Proxy a' a b' b m (a -> r)
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m (a -> r)
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m (a -> r) -> Proxy a' a b' b m r
go (b' -> Proxy a' a b' b m (a -> r)
fb' b'
b'))
            M          m (Proxy a' a b' b m (a -> r))
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (Proxy a' a b' b m (a -> r) -> Proxy a' a b' b m r
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Proxy a' a b' b m (a -> r))
m)
            Pure    a -> r
f      -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> r
f Proxy a' a b' b m a
px
    Proxy a' a b' b m a
l *> :: forall a b.
Proxy a' a b' b m a -> Proxy a' a b' b m b -> Proxy a' a b' b m b
*> Proxy a' a b' b m b
r = forall {r}. Proxy a' a b' b m r -> Proxy a' a b' b m b
go Proxy a' a b' b m a
l where
        go :: Proxy a' a b' b m r -> Proxy a' a b' b m b
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
            Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m r -> Proxy a' a b' b m b
go (a -> Proxy a' a b' b m r
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b m b
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
            M          m (Proxy a' a b' b m r)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (Proxy a' a b' b m r -> Proxy a' a b' b m b
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Proxy a' a b' b m r)
m)
            Pure    r
_      -> Proxy a' a b' b m b
r

instance Functor m => Monad (Proxy a' a b' b m) where
    return :: forall a. a -> Proxy a' a b' b m a
return = forall (f :: * -> *) a. Applicative f => a -> f a
pure
    >>= :: forall a b.
Proxy a' a b' b m a
-> (a -> Proxy a' a b' b m b) -> Proxy a' a b' b m b
(>>=)  = forall (m :: * -> *) a' a b' b r r'.
Functor m =>
Proxy a' a b' b m r
-> (r -> Proxy a' a b' b m r') -> Proxy a' a b' b m r'
_bind

_bind
    :: Functor m
    => Proxy a' a b' b m r
    -> (r -> Proxy a' a b' b m r')
    -> Proxy a' a b' b m r'
Proxy a' a b' b m r
p0 _bind :: forall (m :: * -> *) a' a b' b r r'.
Functor m =>
Proxy a' a b' b m r
-> (r -> Proxy a' a b' b m r') -> Proxy a' a b' b m r'
`_bind` r -> Proxy a' a b' b m r'
f = Proxy a' a b' b m r -> Proxy a' a b' b m r'
go Proxy a' a b' b m r
p0 where
    go :: Proxy a' a b' b m r -> Proxy a' a b' b m r'
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
        Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m r -> Proxy a' a b' b m r'
go (a -> Proxy a' a b' b m r
fa  a
a ))
        Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b m r'
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
        M          m (Proxy a' a b' b m r)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (Proxy a' a b' b m r -> Proxy a' a b' b m r'
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Proxy a' a b' b m r)
m)
        Pure    r
r      -> r -> Proxy a' a b' b m r'
f r
r
{-# NOINLINE[1] _bind #-}

{-# RULES
    "_bind (Request a' k) f" forall a' k f .
        _bind (Request a' k) f = Request a' (\a  -> _bind (k a)  f);
    "_bind (Respond b  k) f" forall b  k f .
        _bind (Respond b  k) f = Respond b  (\b' -> _bind (k b') f);
    "_bind (M          m) f" forall m    f .
        _bind (M          m) f = M ((\p -> _bind p f) <$> m);
    "_bind (Pure    r   ) f" forall r    f .
        _bind (Pure    r   ) f = f r;
  #-}

instance (Functor m, Semigroup r) => Semigroup (Proxy a' a b' b m r) where
    Proxy a' a b' b m r
p1 <> :: Proxy a' a b' b m r -> Proxy a' a b' b m r -> Proxy a' a b' b m r
<> Proxy a' a b' b m r
p2 = Proxy a' a b' b m r -> Proxy a' a b' b m r
go Proxy a' a b' b m r
p1 where
        go :: Proxy a' a b' b m r -> Proxy a' a b' b m r
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
            Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m r -> Proxy a' a b' b m r
go (a -> Proxy a' a b' b m r
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b m r
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
            M          m (Proxy a' a b' b m r)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (Proxy a' a b' b m r -> Proxy a' a b' b m r
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Proxy a' a b' b m r)
m)
            Pure    r
r1     -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (r
r1 forall a. Semigroup a => a -> a -> a
<>) Proxy a' a b' b m r
p2

instance (Functor m, Monoid r, Semigroup r) => Monoid (Proxy a' a b' b m r) where
    mempty :: Proxy a' a b' b m r
mempty        = forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure forall a. Monoid a => a
mempty
#if !(MIN_VERSION_base(4,11,0))
    mappend = (<>)
#endif

instance MonadTrans (Proxy a' a b' b) where
    lift :: forall (m :: * -> *) a. Monad m => m a -> Proxy a' a b' b m a
lift m a
m = forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
m)

{-| 'unsafeHoist' is like 'hoist', but faster.

    This is labeled as unsafe because you will break the monad transformer laws
    if you do not pass a monad morphism as the first argument.  This function is
    safe if you pass a monad morphism as the first argument.
-}
unsafeHoist
    :: Functor m
    => (forall x . m x -> n x) -> Proxy a' a b' b m r -> Proxy a' a b' b n r
unsafeHoist :: forall (m :: * -> *) (n :: * -> *) a' a b' b r.
Functor m =>
(forall x. m x -> n x)
-> Proxy a' a b' b m r -> Proxy a' a b' b n r
unsafeHoist forall x. m x -> n x
nat = forall {a'} {a} {b'} {b} {r}.
Proxy a' a b' b m r -> Proxy a' a b' b n r
go
  where
    go :: Proxy a' a b' b m r -> Proxy a' a b' b n r
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
        Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m r -> Proxy a' a b' b n r
go (a -> Proxy a' a b' b m r
fa  a
a ))
        Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b n r
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
        M          m (Proxy a' a b' b m r)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (forall x. m x -> n x
nat (Proxy a' a b' b m r -> Proxy a' a b' b n r
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Proxy a' a b' b m r)
m))
        Pure    r
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r
{-# INLINABLE unsafeHoist #-}

instance MFunctor (Proxy a' a b' b) where
    hoist :: forall (m :: * -> *) (n :: * -> *) b.
Monad m =>
(forall a. m a -> n a)
-> Proxy a' a b' b m b -> Proxy a' a b' b n b
hoist forall a. m a -> n a
nat Proxy a' a b' b m b
p0 = forall {a'} {a} {b'} {b} {r}.
Proxy a' a b' b m r -> Proxy a' a b' b n r
go (forall (m :: * -> *) a' a b' b r.
Monad m =>
Proxy a' a b' b m r -> Proxy a' a b' b m r
observe Proxy a' a b' b m b
p0)
      where
        go :: Proxy a' a b' b m r -> Proxy a' a b' b n r
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
            Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m r -> Proxy a' a b' b n r
go (a -> Proxy a' a b' b m r
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b n r
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
            M          m (Proxy a' a b' b m r)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (forall a. m a -> n a
nat (Proxy a' a b' b m r -> Proxy a' a b' b n r
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (Proxy a' a b' b m r)
m))
            Pure    r
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r

instance MMonad (Proxy a' a b' b) where
    embed :: forall (n :: * -> *) (m :: * -> *) b.
Monad n =>
(forall a. m a -> Proxy a' a b' b n a)
-> Proxy a' a b' b m b -> Proxy a' a b' b n b
embed forall a. m a -> Proxy a' a b' b n a
f = forall {r}. Proxy a' a b' b m r -> Proxy a' a b' b n r
go
      where
        go :: Proxy a' a b' b m r -> Proxy a' a b' b n r
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
            Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m r -> Proxy a' a b' b n r
go (a -> Proxy a' a b' b m r
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b n r
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
            M          m (Proxy a' a b' b m r)
m   -> forall a. m a -> Proxy a' a b' b n a
f m (Proxy a' a b' b m r)
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Proxy a' a b' b m r -> Proxy a' a b' b n r
go
            Pure    r
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r

instance F.MonadFail m => F.MonadFail (Proxy a' a b' b m) where
    fail :: forall a. String -> Proxy a' a b' b m a
fail = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a. MonadFail m => String -> m a
F.fail

instance MonadIO m => MonadIO (Proxy a' a b' b m) where
    liftIO :: forall a. IO a -> Proxy a' a b' b m a
liftIO IO a
m = forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO a
m))

instance MonadReader r m => MonadReader r (Proxy a' a b' b m) where
    ask :: Proxy a' a b' b m r
ask = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall r (m :: * -> *). MonadReader r m => m r
ask
    local :: forall a. (r -> r) -> Proxy a' a b' b m a -> Proxy a' a b' b m a
local r -> r
f = forall {m :: * -> *} {a'} {a} {b'} {b} {r}.
MonadReader r m =>
Proxy a' a b' b m r -> Proxy a' a b' b m r
go
        where
          go :: Proxy a' a b' b m r -> Proxy a' a b' b m r
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
              Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m r -> Proxy a' a b' b m r
go (a -> Proxy a' a b' b m r
fa  a
a ))
              Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m r -> Proxy a' a b' b m r
go (b' -> Proxy a' a b' b m r
fb' b'
b'))
              Pure    r
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r
              M       m (Proxy a' a b' b m r)
m      -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (Proxy a' a b' b m r -> Proxy a' a b' b m r
go forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f m (Proxy a' a b' b m r)
m)
    reader :: forall a. (r -> a) -> Proxy a' a b' b m a
reader = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader

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

instance MonadWriter w m => MonadWriter w (Proxy a' a b' b m) where
    writer :: forall a. (a, w) -> Proxy a' a b' b m a
writer = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall w (m :: * -> *) a. MonadWriter w m => (a, w) -> m a
writer
    tell :: w -> Proxy a' a b' b m ()
tell = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
    listen :: forall a. Proxy a' a b' b m a -> Proxy a' a b' b m (a, w)
listen Proxy a' a b' b m a
p0 = forall {m :: * -> *} {b} {a'} {a} {b'} {b} {a}.
MonadWriter b m =>
Proxy a' a b' b m a -> b -> Proxy a' a b' b m (a, b)
go Proxy a' a b' b m a
p0 forall a. Monoid a => a
mempty
      where
        go :: Proxy a' a b' b m a -> b -> Proxy a' a b' b m (a, b)
go Proxy a' a b' b m a
p b
w = case Proxy a' a b' b m a
p of
            Request a'
a' a -> Proxy a' a b' b m a
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m a -> b -> Proxy a' a b' b m (a, b)
go (a -> Proxy a' a b' b m a
fa  a
a ) b
w)
            Respond b
b  b' -> Proxy a' a b' b m a
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m a -> b -> Proxy a' a b' b m (a, b)
go (b' -> Proxy a' a b' b m a
fb' b'
b') b
w)
            M       m (Proxy a' a b' b m a)
m      -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (do
                (Proxy a' a b' b m a
p', b
w') <- forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
listen m (Proxy a' a b' b m a)
m
                forall (m :: * -> *) a. Monad m => a -> m a
return (Proxy a' a b' b m a -> b -> Proxy a' a b' b m (a, b)
go Proxy a' a b' b m a
p' forall a b. (a -> b) -> a -> b
$! forall a. Monoid a => a -> a -> a
mappend b
w b
w') )
            Pure    a
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure (a
r, b
w)

    pass :: forall a. Proxy a' a b' b m (a, w -> w) -> Proxy a' a b' b m a
pass Proxy a' a b' b m (a, w -> w)
p0 = forall {w} {m :: * -> *} {a'} {a} {b'} {b} {r}.
MonadWriter w m =>
Proxy a' a b' b m (r, w -> w) -> w -> Proxy a' a b' b m r
go Proxy a' a b' b m (a, w -> w)
p0 forall a. Monoid a => a
mempty
      where
        go :: Proxy a' a b' b m (r, w -> w) -> w -> Proxy a' a b' b m r
go Proxy a' a b' b m (r, w -> w)
p w
w = case Proxy a' a b' b m (r, w -> w)
p of
            Request a'
a' a -> Proxy a' a b' b m (r, w -> w)
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m (r, w -> w) -> w -> Proxy a' a b' b m r
go (a -> Proxy a' a b' b m (r, w -> w)
fa  a
a ) w
w)
            Respond b
b  b' -> Proxy a' a b' b m (r, w -> w)
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m (r, w -> w) -> w -> Proxy a' a b' b m r
go (b' -> Proxy a' a b' b m (r, w -> w)
fb' b'
b') w
w)
            M       m (Proxy a' a b' b m (r, w -> w))
m      -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (do
                (Proxy a' a b' b m (r, w -> w)
p', w
w') <- forall w (m :: * -> *) a. MonadWriter w m => (w -> w) -> m a -> m a
censor (forall a b. a -> b -> a
const forall a. Monoid a => a
mempty) (forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
listen m (Proxy a' a b' b m (r, w -> w))
m)
                forall (m :: * -> *) a. Monad m => a -> m a
return (Proxy a' a b' b m (r, w -> w) -> w -> Proxy a' a b' b m r
go Proxy a' a b' b m (r, w -> w)
p' forall a b. (a -> b) -> a -> b
$! forall a. Monoid a => a -> a -> a
mappend w
w w
w') )
            Pure   (r
r, w -> w
f)  -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
pass (forall (m :: * -> *) a. Monad m => a -> m a
return (forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r, \w
_ -> w -> w
f w
w)))

instance MonadError e m => MonadError e (Proxy a' a b' b m) where
    throwError :: forall a. e -> Proxy a' a b' b m a
throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
    catchError :: forall a.
Proxy a' a b' b m a
-> (e -> Proxy a' a b' b m a) -> Proxy a' a b' b m a
catchError Proxy a' a b' b m a
p0 e -> Proxy a' a b' b m a
f = Proxy a' a b' b m a -> Proxy a' a b' b m a
go Proxy a' a b' b m a
p0
      where
        go :: Proxy a' a b' b m a -> Proxy a' a b' b m a
go Proxy a' a b' b m a
p = case Proxy a' a b' b m a
p of
            Request a'
a' a -> Proxy a' a b' b m a
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m a -> Proxy a' a b' b m a
go (a -> Proxy a' a b' b m a
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m a
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m a -> Proxy a' a b' b m a
go (b' -> Proxy a' a b' b m a
fb' b'
b'))
            Pure    a
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure a
r
            M          m (Proxy a' a b' b m a)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M ((do
                Proxy a' a b' b m a
p' <- m (Proxy a' a b' b m a)
m
                forall (m :: * -> *) a. Monad m => a -> m a
return (Proxy a' a b' b m a -> Proxy a' a b' b m a
go Proxy a' a b' b m a
p') ) forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
`catchError` (\e
e -> forall (m :: * -> *) a. Monad m => a -> m a
return (e -> Proxy a' a b' b m a
f e
e)) )

instance MonadThrow m => MonadThrow (Proxy a' a b' b m) where
    throwM :: forall e a. Exception e => e -> Proxy a' a b' b m a
throwM = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM
    {-# INLINE throwM #-}

instance MonadCatch m => MonadCatch (Proxy a' a b' b m) where
    catch :: forall e a.
Exception e =>
Proxy a' a b' b m a
-> (e -> Proxy a' a b' b m a) -> Proxy a' a b' b m a
catch Proxy a' a b' b m a
p0 e -> Proxy a' a b' b m a
f = Proxy a' a b' b m a -> Proxy a' a b' b m a
go Proxy a' a b' b m a
p0
      where
        go :: Proxy a' a b' b m a -> Proxy a' a b' b m a
go Proxy a' a b' b m a
p = case Proxy a' a b' b m a
p of
            Request a'
a' a -> Proxy a' a b' b m a
fa  -> forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> Proxy a' a b' b m a -> Proxy a' a b' b m a
go (a -> Proxy a' a b' b m a
fa  a
a ))
            Respond b
b  b' -> Proxy a' a b' b m a
fb' -> forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> Proxy a' a b' b m a -> Proxy a' a b' b m a
go (b' -> Proxy a' a b' b m a
fb' b'
b'))
            Pure    a
r      -> forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure a
r
            M          m (Proxy a' a b' b m a)
m   -> forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M ((do
                Proxy a' a b' b m a
p' <- m (Proxy a' a b' b m a)
m
                forall (m :: * -> *) a. Monad m => a -> m a
return (Proxy a' a b' b m a -> Proxy a' a b' b m a
go Proxy a' a b' b m a
p') ) forall (m :: * -> *) e a.
(MonadCatch m, Exception e) =>
m a -> (e -> m a) -> m a
`Control.Monad.Catch.catch` (\e
e -> forall (m :: * -> *) a. Monad m => a -> m a
return (e -> Proxy a' a b' b m a
f e
e)) )

{-| The monad transformer laws are correct when viewed through the 'observe'
    function:

@
'observe' ('lift' ('return' r)) = 'observe' ('return' r)

'observe' ('lift' (m '>>=' f)) = 'observe' ('lift' m '>>=' 'lift' '.' f)
@

    This correctness comes at a small cost to performance, so use this function
    sparingly.

    This function is a convenience for low-level @pipes@ implementers.  You do
    not need to use 'observe' if you stick to the safe API.
-}
observe :: Monad m => Proxy a' a b' b m r -> Proxy a' a b' b m r
observe :: forall (m :: * -> *) a' a b' b r.
Monad m =>
Proxy a' a b' b m r -> Proxy a' a b' b m r
observe Proxy a' a b' b m r
p0 = forall a' a b' b (m :: * -> *) r.
m (Proxy a' a b' b m r) -> Proxy a' a b' b m r
M (forall {m :: * -> *} {a'} {a} {b'} {b} {r}.
Monad m =>
Proxy a' a b' b m r -> m (Proxy a' a b' b m r)
go Proxy a' a b' b m r
p0) where
    go :: Proxy a' a b' b m r -> m (Proxy a' a b' b m r)
go Proxy a' a b' b m r
p = case Proxy a' a b' b m r
p of
        Request a'
a' a -> Proxy a' a b' b m r
fa  -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a' a b' b (m :: * -> *) r.
a' -> (a -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Request a'
a' (\a
a  -> forall (m :: * -> *) a' a b' b r.
Monad m =>
Proxy a' a b' b m r -> Proxy a' a b' b m r
observe (a -> Proxy a' a b' b m r
fa  a
a )))
        Respond b
b  b' -> Proxy a' a b' b m r
fb' -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a' a b' b (m :: * -> *) r.
b -> (b' -> Proxy a' a b' b m r) -> Proxy a' a b' b m r
Respond b
b  (\b'
b' -> forall (m :: * -> *) a' a b' b r.
Monad m =>
Proxy a' a b' b m r -> Proxy a' a b' b m r
observe (b' -> Proxy a' a b' b m r
fb' b'
b')))
        M          m (Proxy a' a b' b m r)
m'  -> m (Proxy a' a b' b m r)
m' forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Proxy a' a b' b m r -> m (Proxy a' a b' b m r)
go
        Pure    r
r      -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a' a b' b (m :: * -> *) r. r -> Proxy a' a b' b m r
Pure r
r)
{-# INLINABLE observe #-}

-- | The empty type, used to close output ends
type X = Void

-- | Use 'closed' to \"handle\" impossible outputs
closed :: X -> a
closed :: forall a. X -> a
closed = forall a. X -> a
Data.Void.absurd
{-# INLINABLE closed #-}