{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE PolyKinds #-}
----------------------------------------------------------------------------
-- |
-- Module     : Data.Functor.Trans.Tagged
-- Copyright  : 2011-2013 Edward Kmett
-- License    : BSD3
--
-- Maintainer  : Edward Kmett <ekmett@gmail.com>
-- Stability   : experimental
-- Portability : portable
--
-------------------------------------------------------------------------------

module Data.Functor.Trans.Tagged
  (
  -- * Tagged values
    TaggedT(..), Tagged
  , tag, tagT
  , untag
  , retag
  , mapTaggedT
  , reflected, reflectedM
  , asTaggedTypeOf
  , proxy, proxyT
  , unproxy, unproxyT
  , tagSelf, tagTSelf
  , untagSelf, untagTSelf
  , tagWith, tagTWith
  , witness, witnessT
  ) where

import Prelude hiding (foldr, foldl, mapM, sequence, foldr1, foldl1)
import Control.Applicative (Alternative(..))
import Control.Monad (liftM, MonadPlus(..))
import Control.Monad.Catch (MonadCatch(..), MonadThrow(..), MonadMask(..))
import Control.Monad.Fix (MonadFix(..))
import Control.Monad.Identity (Identity, runIdentity)
import Control.Monad.Trans (MonadIO(..), MonadTrans(..))
import Control.Monad.Reader (MonadReader(..))
import Control.Monad.Writer (MonadWriter(..))
import Control.Monad.State (MonadState(..))
import Control.Monad.Cont (MonadCont(..))
import Control.Comonad.Trans.Class (ComonadTrans(..))
import Control.Comonad.Hoist.Class (ComonadHoist(..))
import Control.Comonad (Comonad(..))
import Data.Traversable (Traversable(..))
import Data.Foldable (Foldable(..))
import Data.Distributive (Distributive(..))
import Data.Functor.Bind (Apply(..), Bind(..))
import Data.Functor.Extend (Extend(..))
import Data.Functor.Plus (Alt(..), Plus(..))
import Data.Functor.Contravariant (Contravariant(..))
import Data.Proxy (Proxy(..))
import Data.Reflection (Reifies(..))

-- ---------------------------------------------------------------------------
-- | A @'Tagged' s b@ value is a value @b@ with an attached phantom type @s@.
-- This can be used in place of the more traditional but less safe idiom of
-- passing in an undefined value with the type, because unlike an @(s -> b)@,
-- a @'Tagged' s b@ can't try to use the argument @s@ as a real value.
--
-- Moreover, you don't have to rely on the compiler to inline away the extra
-- argument, because the newtype is \"free\"

type Tagged s b = TaggedT s Identity b

-- | Tag a value in Identity monad
tag :: b -> Tagged s b
tag :: forall {k} b (s :: k). b -> Tagged s b
tag = Identity b -> TaggedT s Identity b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (Identity b -> TaggedT s Identity b)
-> (b -> Identity b) -> b -> TaggedT s Identity b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Identity b
forall a. a -> Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return
{-# INLINE tag #-}

-- | Untag a value in Identity monad
untag :: Tagged s b -> b
untag :: forall {k} (s :: k) b. Tagged s b -> b
untag = Identity b -> b
forall a. Identity a -> a
runIdentity (Identity b -> b) -> (Tagged s b -> Identity b) -> Tagged s b -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Tagged s b -> Identity b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
{-# INLINE untag #-}

-- | Convert from a 'Tagged' representation to a representation
-- based on a 'Proxy'.
proxy :: Tagged s b -> Proxy s -> b
proxy :: forall {k} (s :: k) b. Tagged s b -> Proxy s -> b
proxy Tagged s b
x Proxy s
_ = Tagged s b -> b
forall {k} (s :: k) b. Tagged s b -> b
untag Tagged s b
x
{-# INLINE proxy #-}

-- | Convert from a representation based on a 'Proxy' to a 'Tagged'
-- representation.
unproxy :: (Proxy s -> a) -> Tagged s a
unproxy :: forall {k} (s :: k) a. (Proxy s -> a) -> Tagged s a
unproxy Proxy s -> a
f = Identity a -> TaggedT s Identity a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (a -> Identity a
forall a. a -> Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> Identity a) -> a -> Identity a
forall a b. (a -> b) -> a -> b
$ Proxy s -> a
f Proxy s
forall {k} (t :: k). Proxy t
Proxy)
{-# INLINE unproxy #-}

-- | Tag a value with its own type.
tagSelf :: a -> Tagged a a
tagSelf :: forall a. a -> Tagged a a
tagSelf = Identity a -> TaggedT a Identity a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (Identity a -> TaggedT a Identity a)
-> (a -> Identity a) -> a -> TaggedT 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
{-# INLINE tagSelf #-}

-- | 'untagSelf' is a type-restricted version of 'untag'.
untagSelf :: Tagged a a -> a
untagSelf :: forall a. Tagged a a -> a
untagSelf = Tagged a a -> a
forall {k} (s :: k) b. Tagged s b -> b
untag
{-# INLINE untagSelf #-}

-- | Another way to convert a proxy to a tag.
tagWith :: proxy s -> a -> Tagged s a
tagWith :: forall {k} (proxy :: k -> *) (s :: k) a. proxy s -> a -> Tagged s a
tagWith proxy s
_ = Identity a -> TaggedT s Identity a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (Identity a -> TaggedT s Identity a)
-> (a -> Identity a) -> a -> TaggedT s 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
{-# INLINE tagWith #-}

witness :: Tagged a b -> a -> b
witness :: forall a b. Tagged a b -> a -> b
witness Tagged a b
x a
_ = Tagged a b -> b
forall {k} (s :: k) b. Tagged s b -> b
untag Tagged a b
x
{-# INLINE witness #-}


-- ---------------------------------------------------------------------------
-- | A Tagged monad parameterized by:
--
--   * @s@ - the phantom type
--
--   * @m@ - the inner monad
--
--   * @b@ - the tagged value
--
-- | A @'TaggedT' s m b@ value is a monadic value @m b@ with an attached phantom type @s@.
-- This can be used in place of the more traditional but less safe idiom of
-- passing in an undefined value with the type, because unlike an @(s -> m b)@,
-- a @'TaggedT' s m b@ can't try to use the argument @s@ as a real value.
--
-- Moreover, you don't have to rely on the compiler to inline away the extra
-- argument, because the newtype is \"free\"
newtype TaggedT s m b = TagT { forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT :: m b }
  deriving (TaggedT s m b -> TaggedT s m b -> Bool
(TaggedT s m b -> TaggedT s m b -> Bool)
-> (TaggedT s m b -> TaggedT s m b -> Bool) -> Eq (TaggedT s m b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (s :: k) k (m :: k -> *) (b :: k).
Eq (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
$c== :: forall k (s :: k) k (m :: k -> *) (b :: k).
Eq (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
== :: TaggedT s m b -> TaggedT s m b -> Bool
$c/= :: forall k (s :: k) k (m :: k -> *) (b :: k).
Eq (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
/= :: TaggedT s m b -> TaggedT s m b -> Bool
Eq, Eq (TaggedT s m b)
Eq (TaggedT s m b) =>
(TaggedT s m b -> TaggedT s m b -> Ordering)
-> (TaggedT s m b -> TaggedT s m b -> Bool)
-> (TaggedT s m b -> TaggedT s m b -> Bool)
-> (TaggedT s m b -> TaggedT s m b -> Bool)
-> (TaggedT s m b -> TaggedT s m b -> Bool)
-> (TaggedT s m b -> TaggedT s m b -> TaggedT s m b)
-> (TaggedT s m b -> TaggedT s m b -> TaggedT s m b)
-> Ord (TaggedT s m b)
TaggedT s m b -> TaggedT s m b -> Bool
TaggedT s m b -> TaggedT s m b -> Ordering
TaggedT s m b -> TaggedT s m b -> TaggedT s m b
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
Eq (TaggedT s m b)
forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> Ordering
forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> TaggedT s m b
$ccompare :: forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> Ordering
compare :: TaggedT s m b -> TaggedT s m b -> Ordering
$c< :: forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
< :: TaggedT s m b -> TaggedT s m b -> Bool
$c<= :: forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
<= :: TaggedT s m b -> TaggedT s m b -> Bool
$c> :: forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
> :: TaggedT s m b -> TaggedT s m b -> Bool
$c>= :: forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> Bool
>= :: TaggedT s m b -> TaggedT s m b -> Bool
$cmax :: forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> TaggedT s m b
max :: TaggedT s m b -> TaggedT s m b -> TaggedT s m b
$cmin :: forall k (s :: k) k (m :: k -> *) (b :: k).
Ord (m b) =>
TaggedT s m b -> TaggedT s m b -> TaggedT s m b
min :: TaggedT s m b -> TaggedT s m b -> TaggedT s m b
Ord, ReadPrec [TaggedT s m b]
ReadPrec (TaggedT s m b)
Int -> ReadS (TaggedT s m b)
ReadS [TaggedT s m b]
(Int -> ReadS (TaggedT s m b))
-> ReadS [TaggedT s m b]
-> ReadPrec (TaggedT s m b)
-> ReadPrec [TaggedT s m b]
-> Read (TaggedT s m b)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
ReadPrec [TaggedT s m b]
forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
ReadPrec (TaggedT s m b)
forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
Int -> ReadS (TaggedT s m b)
forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
ReadS [TaggedT s m b]
$creadsPrec :: forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
Int -> ReadS (TaggedT s m b)
readsPrec :: Int -> ReadS (TaggedT s m b)
$creadList :: forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
ReadS [TaggedT s m b]
readList :: ReadS [TaggedT s m b]
$creadPrec :: forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
ReadPrec (TaggedT s m b)
readPrec :: ReadPrec (TaggedT s m b)
$creadListPrec :: forall k (s :: k) k (m :: k -> *) (b :: k).
Read (m b) =>
ReadPrec [TaggedT s m b]
readListPrec :: ReadPrec [TaggedT s m b]
Read, Int -> TaggedT s m b -> ShowS
[TaggedT s m b] -> ShowS
TaggedT s m b -> String
(Int -> TaggedT s m b -> ShowS)
-> (TaggedT s m b -> String)
-> ([TaggedT s m b] -> ShowS)
-> Show (TaggedT s m b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (s :: k) k (m :: k -> *) (b :: k).
Show (m b) =>
Int -> TaggedT s m b -> ShowS
forall k (s :: k) k (m :: k -> *) (b :: k).
Show (m b) =>
[TaggedT s m b] -> ShowS
forall k (s :: k) k (m :: k -> *) (b :: k).
Show (m b) =>
TaggedT s m b -> String
$cshowsPrec :: forall k (s :: k) k (m :: k -> *) (b :: k).
Show (m b) =>
Int -> TaggedT s m b -> ShowS
showsPrec :: Int -> TaggedT s m b -> ShowS
$cshow :: forall k (s :: k) k (m :: k -> *) (b :: k).
Show (m b) =>
TaggedT s m b -> String
show :: TaggedT s m b -> String
$cshowList :: forall k (s :: k) k (m :: k -> *) (b :: k).
Show (m b) =>
[TaggedT s m b] -> ShowS
showList :: [TaggedT s m b] -> ShowS
Show)

instance Functor m => Functor (TaggedT s m) where
  fmap :: forall a b. (a -> b) -> TaggedT s m a -> TaggedT s m b
fmap a -> b
f (TagT m a
x) = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT ((a -> b) -> m a -> m b
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f m a
x)
  {-# INLINE fmap #-}
  a
b <$ :: forall a b. a -> TaggedT s m b -> TaggedT s m a
<$ (TagT m b
x) = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (a
b a -> m b -> m a
forall a b. a -> m b -> m a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ m b
x)
  {-# INLINE (<$) #-}

instance Contravariant m => Contravariant (TaggedT s m) where
  contramap :: forall a' a. (a' -> a) -> TaggedT s m a -> TaggedT s m a'
contramap a' -> a
f (TagT m a
x) = m a' -> TaggedT s m a'
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT ((a' -> a) -> m a -> m a'
forall a' a. (a' -> a) -> m a -> m a'
forall (f :: * -> *) a' a.
Contravariant f =>
(a' -> a) -> f a -> f a'
contramap a' -> a
f m a
x)
  {-# INLINE contramap #-}

instance Apply m => Apply (TaggedT s m) where
  TagT m (a -> b)
f <.> :: forall a b. TaggedT s m (a -> b) -> TaggedT s m a -> TaggedT s m b
<.> TagT m a
x = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m (a -> b)
f m (a -> b) -> m a -> m b
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
<.> m a
x)
  {-# INLINE (<.>) #-}
  TagT m a
f  .> :: forall a b. TaggedT s m a -> TaggedT s m b -> TaggedT s m b
.> TagT m b
x = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
f  m a -> m b -> m b
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Apply f => f a -> f b -> f b
.> m b
x)
  {-# INLINE ( .>) #-}
  TagT m a
f <. :: forall a b. TaggedT s m a -> TaggedT s m b -> TaggedT s m a
<.  TagT m b
x = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
f m a -> m b -> m a
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Apply f => f a -> f b -> f a
<.  m b
x)
  {-# INLINE (<. ) #-}

instance Applicative m => Applicative (TaggedT s m) where
  pure :: forall a. a -> TaggedT s m a
pure = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a -> TaggedT s m a) -> (a -> m a) -> a -> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m a
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
  {-# INLINE pure #-}
  TagT m (a -> b)
f <*> :: forall a b. TaggedT s m (a -> b) -> TaggedT s m a -> TaggedT s m b
<*> TagT m a
x = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m (a -> b)
f m (a -> b) -> m a -> m b
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m a
x)
  {-# INLINE (<*>) #-}
  TagT m a
f  *> :: forall a b. TaggedT s m a -> TaggedT s m b -> TaggedT s m b
*> TagT m b
x = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
f  m a -> m b -> m b
forall a b. m a -> m b -> m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> m b
x)
  {-# INLINE ( *>) #-}
  TagT m a
f <* :: forall a b. TaggedT s m a -> TaggedT s m b -> TaggedT s m a
<*  TagT m b
x = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
f m a -> m b -> m a
forall a b. m a -> m b -> m a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*  m b
x)
  {-# INLINE (<* ) #-}

instance Bind m => Bind (TaggedT s m) where
  TagT m a
m >>- :: forall a b. TaggedT s m a -> (a -> TaggedT s m b) -> TaggedT s m b
>>- a -> TaggedT s m b
k = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
m m a -> (a -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
>>- TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT (TaggedT s m b -> m b) -> (a -> TaggedT s m b) -> a -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> TaggedT s m b
k)
  {-# INLINE (>>-) #-}

instance Monad m => Monad (TaggedT s m) where
  TagT m a
m >>= :: forall a b. TaggedT s m a -> (a -> TaggedT s m b) -> TaggedT s m b
>>= a -> TaggedT s m b
k = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
m m a -> (a -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT (TaggedT s m b -> m b) -> (a -> TaggedT s m b) -> a -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> TaggedT s m b
k)
  {-# INLINE (>>=) #-}
#if !(MIN_VERSION_base(4,11,0))
  return = TagT . return
  {-# INLINE return #-}
  TagT m >> TagT n = TagT (m >> n)
  {-# INLINE (>>) #-}
#endif

instance Alt m => Alt (TaggedT s m) where
  TagT m a
a <!> :: forall a. TaggedT s m a -> TaggedT s m a -> TaggedT s m a
<!> TagT m a
b = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
a m a -> m a -> m a
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alt f => f a -> f a -> f a
<!> m a
b)
  {-# INLINE (<!>) #-}

instance Alternative m => Alternative (TaggedT s m) where
  empty :: forall a. TaggedT s m a
empty = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT m a
forall a. m a
forall (f :: * -> *) a. Alternative f => f a
empty
  {-# INLINE empty #-}
  TagT m a
a <|> :: forall a. TaggedT s m a -> TaggedT s m a -> TaggedT s m a
<|> TagT m a
b = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a
a m a -> m a -> m a
forall a. m a -> m a -> m a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> m a
b)
  {-# INLINE (<|>) #-}

instance Plus m => Plus (TaggedT s m) where
  zero :: forall a. TaggedT s m a
zero = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT m a
forall a. m a
forall (f :: * -> *) a. Plus f => f a
zero
  {-# INLINE zero #-}

instance MonadPlus m => MonadPlus (TaggedT s m) where
  mzero :: forall a. TaggedT s m a
mzero = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT m a
forall a. m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
  {-# INLINE mzero #-}
  mplus :: forall a. TaggedT s m a -> TaggedT s m a -> TaggedT s m a
mplus (TagT m a
a) (TagT m a
b) = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a -> m a -> m a
forall a. m a -> m a -> m a
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
mplus m a
a m a
b)
  {-# INLINE mplus #-}

instance MonadFix m => MonadFix (TaggedT s m) where
  mfix :: forall a. (a -> TaggedT s m a) -> TaggedT s m a
mfix a -> TaggedT s m a
f = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a -> TaggedT s m a) -> m a -> TaggedT s m a
forall a b. (a -> b) -> a -> b
$ (a -> m a) -> m a
forall a. (a -> m a) -> m a
forall (m :: * -> *) a. MonadFix m => (a -> m a) -> m a
mfix (TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT (TaggedT s m a -> m a) -> (a -> TaggedT s m a) -> a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> TaggedT s m a
f)
  {-# INLINE mfix #-}

instance MonadTrans (TaggedT s) where
  lift :: forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
lift = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT
  {-# INLINE lift #-}

instance MonadIO m => MonadIO (TaggedT s m) where
  liftIO :: forall a. IO a -> TaggedT s m a
liftIO = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a) -> (IO a -> m a) -> IO a -> TaggedT s 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
  {-# INLINE liftIO #-}

instance MonadWriter w m => MonadWriter w (TaggedT s m) where
  writer :: forall a. (a, w) -> TaggedT s m a
writer = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a)
-> ((a, w) -> m a) -> (a, w) -> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, w) -> m a
forall a. (a, w) -> m a
forall w (m :: * -> *) a. MonadWriter w m => (a, w) -> m a
writer
  {-# INLINE writer #-}
  tell :: w -> TaggedT s m ()
tell = m () -> TaggedT s m ()
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> TaggedT s m ()) -> (w -> m ()) -> w -> TaggedT s m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. w -> m ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell
  {-# INLINE tell #-}
  listen :: forall a. TaggedT s m a -> TaggedT s m (a, w)
listen = m (a, w) -> TaggedT s m (a, w)
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m (a, w) -> TaggedT s m (a, w))
-> (TaggedT s m a -> m (a, w))
-> TaggedT s m a
-> TaggedT s m (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> m (a, w)
forall a. m a -> m (a, w)
forall w (m :: * -> *) a. MonadWriter w m => m a -> m (a, w)
listen (m a -> m (a, w))
-> (TaggedT s m a -> m a) -> TaggedT s m a -> m (a, w)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
  {-# INLINE listen #-}
  pass :: forall a. TaggedT s m (a, w -> w) -> TaggedT s m a
pass = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a)
-> (TaggedT s m (a, w -> w) -> m a)
-> TaggedT s m (a, w -> w)
-> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m (a, w -> w) -> m a
forall a. m (a, w -> w) -> m a
forall w (m :: * -> *) a. MonadWriter w m => m (a, w -> w) -> m a
pass (m (a, w -> w) -> m a)
-> (TaggedT s m (a, w -> w) -> m (a, w -> w))
-> TaggedT s m (a, w -> w)
-> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s m (a, w -> w) -> m (a, w -> w)
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
  {-# INLINE pass #-}

instance MonadReader r m => MonadReader r (TaggedT s m) where
  ask :: TaggedT s m r
ask = m r -> TaggedT s m r
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m r
forall r (m :: * -> *). MonadReader r m => m r
ask
  {-# INLINE ask #-}
  local :: forall a. (r -> r) -> TaggedT s m a -> TaggedT s m a
local r -> r
f = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a)
-> (TaggedT s m a -> m a) -> TaggedT s m a -> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r -> r) -> m a -> m a
forall a. (r -> r) -> m a -> m a
forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
local r -> r
f (m a -> m a) -> (TaggedT s m a -> m a) -> TaggedT s m a -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
  {-# INLINE local #-}
  reader :: forall a. (r -> a) -> TaggedT s m a
reader = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a)
-> ((r -> a) -> m a) -> (r -> a) -> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r -> a) -> m a
forall a. (r -> a) -> m a
forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
reader
  {-# INLINE reader #-}

instance MonadState t m => MonadState t (TaggedT s m) where
  get :: TaggedT s m t
get = m t -> TaggedT s m t
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m t
forall s (m :: * -> *). MonadState s m => m s
get
  {-# INLINE get #-}
  put :: t -> TaggedT s m ()
put = m () -> TaggedT s m ()
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m () -> TaggedT s m ()) -> (t -> m ()) -> t -> TaggedT s m ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> m ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put
  {-# INLINE put #-}
  state :: forall a. (t -> (a, t)) -> TaggedT s m a
state = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a)
-> ((t -> (a, t)) -> m a) -> (t -> (a, t)) -> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (t -> (a, t)) -> m a
forall a. (t -> (a, t)) -> m a
forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
state
  {-# INLINE state #-}

instance MonadCont m => MonadCont (TaggedT s m) where
  callCC :: forall a b.
((a -> TaggedT s m b) -> TaggedT s m a) -> TaggedT s m a
callCC (a -> TaggedT s m b) -> TaggedT s m a
f = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a)
-> (((a -> m b) -> m a) -> m a)
-> ((a -> m b) -> m a)
-> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a -> m b) -> m a) -> m a
forall a b. ((a -> m b) -> m a) -> m a
forall (m :: * -> *) a b. MonadCont m => ((a -> m b) -> m a) -> m a
callCC (((a -> m b) -> m a) -> TaggedT s m a)
-> ((a -> m b) -> m a) -> TaggedT s m a
forall a b. (a -> b) -> a -> b
$ \a -> m b
k -> TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT ((a -> TaggedT s m b) -> TaggedT s m a
f (m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m b -> TaggedT s m b) -> (a -> m b) -> a -> TaggedT s m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m b
k))
  {-# INLINE callCC #-}

instance Foldable f => Foldable (TaggedT s f) where
  foldMap :: forall m a. Monoid m => (a -> m) -> TaggedT s f a -> m
foldMap a -> m
f (TagT f a
x) = (a -> m) -> f a -> m
forall m a. Monoid m => (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap a -> m
f f a
x
  {-# INLINE foldMap #-}
  fold :: forall m. Monoid m => TaggedT s f m -> m
fold (TagT f m
x) = f m -> m
forall m. Monoid m => f m -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold f m
x
  {-# INLINE fold #-}
  foldr :: forall a b. (a -> b -> b) -> b -> TaggedT s f a -> b
foldr a -> b -> b
f b
z (TagT f a
x) = (a -> b -> b) -> b -> f a -> b
forall a b. (a -> b -> b) -> b -> f a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr a -> b -> b
f b
z f a
x
  {-# INLINE foldr #-}
  foldl :: forall b a. (b -> a -> b) -> b -> TaggedT s f a -> b
foldl b -> a -> b
f b
z (TagT f a
x) = (b -> a -> b) -> b -> f a -> b
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl b -> a -> b
f b
z f a
x
  {-# INLINE foldl #-}
  foldl1 :: forall a. (a -> a -> a) -> TaggedT s f a -> a
foldl1 a -> a -> a
f (TagT f a
x) = (a -> a -> a) -> f a -> a
forall a. (a -> a -> a) -> f a -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 a -> a -> a
f f a
x
  {-# INLINE foldl1 #-}
  foldr1 :: forall a. (a -> a -> a) -> TaggedT s f a -> a
foldr1 a -> a -> a
f (TagT f a
x) = (a -> a -> a) -> f a -> a
forall a. (a -> a -> a) -> f a -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldr1 a -> a -> a
f f a
x
  {-# INLINE foldr1 #-}

instance Traversable f => Traversable (TaggedT s f) where
  traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TaggedT s f a -> f (TaggedT s f b)
traverse a -> f b
f (TagT f a
x) = f b -> TaggedT s f b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (f b -> TaggedT s f b) -> f (f b) -> f (TaggedT s f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f b) -> f a -> f (f b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> f a -> f (f b)
traverse a -> f b
f f a
x
  {-# INLINE traverse #-}
  sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TaggedT s f (f a) -> f (TaggedT s f a)
sequenceA (TagT f (f a)
x) = f a -> TaggedT s f a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (f a -> TaggedT s f a) -> f (f a) -> f (TaggedT s f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (f a) -> f (f a)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a. Applicative f => f (f a) -> f (f a)
sequenceA f (f a)
x
  {-# INLINE sequenceA #-}
  mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TaggedT s f a -> m (TaggedT s f b)
mapM a -> m b
f (TagT f a
x) = (f b -> TaggedT s f b) -> m (f b) -> m (TaggedT s f b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM f b -> TaggedT s f b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT ((a -> m b) -> f a -> m (f b)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> f a -> m (f b)
mapM a -> m b
f f a
x)
  {-# INLINE mapM #-}
  sequence :: forall (m :: * -> *) a.
Monad m =>
TaggedT s f (m a) -> m (TaggedT s f a)
sequence (TagT f (m a)
x) = (f a -> TaggedT s f a) -> m (f a) -> m (TaggedT s f a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM f a -> TaggedT s f a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (f (m a) -> m (f a)
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => f (m a) -> m (f a)
sequence f (m a)
x)
  {-# INLINE sequence #-}

instance Distributive f => Distributive (TaggedT s f) where
  distribute :: forall (f :: * -> *) a.
Functor f =>
f (TaggedT s f a) -> TaggedT s f (f a)
distribute = f (f a) -> TaggedT s f (f a)
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (f (f a) -> TaggedT s f (f a))
-> (f (TaggedT s f a) -> f (f a))
-> f (TaggedT s f a)
-> TaggedT s f (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f (f a) -> f (f a)
forall (g :: * -> *) (f :: * -> *) a.
(Distributive g, Functor f) =>
f (g a) -> g (f a)
forall (f :: * -> *) a. Functor f => f (f a) -> f (f a)
distribute (f (f a) -> f (f a))
-> (f (TaggedT s f a) -> f (f a)) -> f (TaggedT s f a) -> f (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (TaggedT s f a -> f a) -> f (TaggedT s f a) -> f (f a)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TaggedT s f a -> f a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
  {-# INLINE distribute #-}

instance Extend f => Extend (TaggedT s f) where
  extended :: forall a b. (TaggedT s f a -> b) -> TaggedT s f a -> TaggedT s f b
extended TaggedT s f a -> b
f (TagT f a
w) = f b -> TaggedT s f b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT ((f a -> b) -> f a -> f b
forall a b. (f a -> b) -> f a -> f b
forall (w :: * -> *) a b. Extend w => (w a -> b) -> w a -> w b
extended (TaggedT s f a -> b
f (TaggedT s f a -> b) -> (f a -> TaggedT s f a) -> f a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> TaggedT s f a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT) f a
w)
  {-# INLINE extended #-}

instance Comonad w => Comonad (TaggedT s w) where
  extract :: forall a. TaggedT s w a -> a
extract (TagT w a
w) = w a -> a
forall a. w a -> a
forall (w :: * -> *) a. Comonad w => w a -> a
extract w a
w
  {-# INLINE extract #-}
  duplicate :: forall a. TaggedT s w a -> TaggedT s w (TaggedT s w a)
duplicate (TagT w a
w) = w (TaggedT s w a) -> TaggedT s w (TaggedT s w a)
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT ((w a -> TaggedT s w a) -> w a -> w (TaggedT s w a)
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 a -> TaggedT s w a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT w a
w)
  {-# INLINE duplicate #-}

instance ComonadTrans (TaggedT s) where
  lower :: forall (w :: * -> *) a. Comonad w => TaggedT s w a -> w a
lower (TagT w a
w) = w a
w
  {-# INLINE lower #-}

instance ComonadHoist (TaggedT s) where
  cohoist :: forall (w :: * -> *) (v :: * -> *) a.
(Comonad w, Comonad v) =>
(forall x. w x -> v x) -> TaggedT s w a -> TaggedT s v a
cohoist forall x. w x -> v x
f = v a -> TaggedT s v a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (v a -> TaggedT s v a)
-> (TaggedT s w a -> v a) -> TaggedT s w a -> TaggedT s v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. w a -> v a
forall x. w x -> v x
f (w a -> v a) -> (TaggedT s w a -> w a) -> TaggedT s w a -> v a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s w a -> w a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
  {-# INLINE cohoist #-}

instance MonadThrow m => MonadThrow (TaggedT s m) where
  throwM :: forall e a. (HasCallStack, Exception e) => e -> TaggedT s m a
throwM e
e = m a -> TaggedT s m a
forall (m :: * -> *) a. Monad m => m a -> TaggedT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> TaggedT s m a) -> m a -> TaggedT s m a
forall a b. (a -> b) -> a -> b
$ e -> m a
forall e a. (HasCallStack, Exception e) => e -> m a
forall (m :: * -> *) e a.
(MonadThrow m, HasCallStack, Exception e) =>
e -> m a
throwM e
e
  {-# INLINE throwM #-}

instance MonadCatch m => MonadCatch (TaggedT s m) where
  catch :: forall e a.
(HasCallStack, Exception e) =>
TaggedT s m a -> (e -> TaggedT s m a) -> TaggedT s m a
catch TaggedT s m a
m e -> TaggedT s m a
f = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a -> (e -> m a) -> m a
forall e a. (HasCallStack, Exception e) => m a -> (e -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatch m, HasCallStack, Exception e) =>
m a -> (e -> m a) -> m a
catch (TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT TaggedT s m a
m) (TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT (TaggedT s m a -> m a) -> (e -> TaggedT s m a) -> e -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> TaggedT s m a
f))
  {-# INLINE catch #-}

instance MonadMask m => MonadMask (TaggedT s m) where
  mask :: forall b.
HasCallStack =>
((forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b)
-> TaggedT s m b
mask (forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b
a = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m b -> TaggedT s m b) -> m b -> TaggedT s m b
forall a b. (a -> b) -> a -> b
$ ((forall a. m a -> m a) -> m b) -> m b
forall b. HasCallStack => ((forall a. m a -> m a) -> m b) -> m b
forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. m a -> m a) -> m b) -> m b
mask (((forall a. m a -> m a) -> m b) -> m b)
-> ((forall a. m a -> m a) -> m b) -> m b
forall a b. (a -> b) -> a -> b
$ \forall a. m a -> m a
u -> TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT ((forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b
a ((forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b)
-> (forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b
forall a b. (a -> b) -> a -> b
$ (m a -> m a) -> TaggedT s m a -> TaggedT s m a
forall {k} {k} {k} {k} {m :: k -> *} {b :: k} {m :: k -> *}
       {b :: k} {s :: k} {s :: k}.
(m b -> m b) -> TaggedT s m b -> TaggedT s m b
q m a -> m a
forall a. m a -> m a
u)
    where q :: (m b -> m b) -> TaggedT s m b -> TaggedT s m b
q m b -> m b
u = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m b -> TaggedT s m b)
-> (TaggedT s m b -> m b) -> TaggedT s m b -> TaggedT s m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m b -> m b
u (m b -> m b) -> (TaggedT s m b -> m b) -> TaggedT s m b -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
  {-# INLINE mask #-}
  uninterruptibleMask :: forall b.
HasCallStack =>
((forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b)
-> TaggedT s m b
uninterruptibleMask (forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b
a = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m b -> TaggedT s m b) -> m b -> TaggedT s m b
forall a b. (a -> b) -> a -> b
$ ((forall a. m a -> m a) -> m b) -> m b
forall b. HasCallStack => ((forall a. m a -> m a) -> m b) -> m b
forall (m :: * -> *) b.
(MonadMask m, HasCallStack) =>
((forall a. m a -> m a) -> m b) -> m b
uninterruptibleMask (((forall a. m a -> m a) -> m b) -> m b)
-> ((forall a. m a -> m a) -> m b) -> m b
forall a b. (a -> b) -> a -> b
$ \forall a. m a -> m a
u -> TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT ((forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b
a ((forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b)
-> (forall a. TaggedT s m a -> TaggedT s m a) -> TaggedT s m b
forall a b. (a -> b) -> a -> b
$ (m a -> m a) -> TaggedT s m a -> TaggedT s m a
forall {k} {k} {k} {k} {m :: k -> *} {b :: k} {m :: k -> *}
       {b :: k} {s :: k} {s :: k}.
(m b -> m b) -> TaggedT s m b -> TaggedT s m b
q m a -> m a
forall a. m a -> m a
u)
    where q :: (m b -> m b) -> TaggedT s m b -> TaggedT s m b
q m b -> m b
u = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m b -> TaggedT s m b)
-> (TaggedT s m b -> m b) -> TaggedT s m b -> TaggedT s m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m b -> m b
u (m b -> m b) -> (TaggedT s m b -> m b) -> TaggedT s m b -> m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
  {-# INLINE uninterruptibleMask#-}
  generalBracket :: forall a b c.
HasCallStack =>
TaggedT s m a
-> (a -> ExitCase b -> TaggedT s m c)
-> (a -> TaggedT s m b)
-> TaggedT s m (b, c)
generalBracket TaggedT s m a
acquire a -> ExitCase b -> TaggedT s m c
release a -> TaggedT s m b
use = m (b, c) -> TaggedT s m (b, c)
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m (b, c) -> TaggedT s m (b, c)) -> m (b, c) -> TaggedT s m (b, c)
forall a b. (a -> b) -> a -> b
$
    m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
forall a b c.
HasCallStack =>
m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
forall (m :: * -> *) a b c.
(MonadMask m, HasCallStack) =>
m a -> (a -> ExitCase b -> m c) -> (a -> m b) -> m (b, c)
generalBracket
      (TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT TaggedT s m a
acquire)
      (\a
resource ExitCase b
exitCase -> TaggedT s m c -> m c
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT (a -> ExitCase b -> TaggedT s m c
release a
resource ExitCase b
exitCase))
      (\a
resource -> TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT (a -> TaggedT s m b
use a
resource))

-- | Easier to type alias for 'TagT'
tagT :: m b -> TaggedT s m b
tagT :: forall {k} {k} (m :: k -> *) (b :: k) (s :: k).
m b -> TaggedT s m b
tagT = m b -> TaggedT s m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT
{-# INLINE tagT #-}

-- | Some times you need to change the tag you have lying around.
-- Idiomatic usage is to make a new combinator for the relationship between the
-- tags that you want to enforce, and define that combinator using 'retag'.
--
-- > data Succ n
-- > retagSucc :: Tagged n a -> Tagged (Succ n) a
-- > retagSucc = retag
retag :: TaggedT s m b -> TaggedT t m b
retag :: forall {k} {k} {k} (s :: k) (m :: k -> *) (b :: k) (t :: k).
TaggedT s m b -> TaggedT t m b
retag = m b -> TaggedT t m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m b -> TaggedT t m b)
-> (TaggedT s m b -> m b) -> TaggedT s m b -> TaggedT t m b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
{-# INLINE retag #-}

-- | Lift an operation on underlying monad
mapTaggedT :: (m a -> n b) -> TaggedT s m a -> TaggedT s n b
mapTaggedT :: forall {k} {k} {k} (m :: k -> *) (a :: k) (n :: k -> *) (b :: k)
       (s :: k).
(m a -> n b) -> TaggedT s m a -> TaggedT s n b
mapTaggedT m a -> n b
f = n b -> TaggedT s n b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (n b -> TaggedT s n b)
-> (TaggedT s m a -> n b) -> TaggedT s m a -> TaggedT s n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. m a -> n b
f (m a -> n b) -> (TaggedT s m a -> m a) -> TaggedT s m a -> n b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TaggedT s m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
{-# INLINE mapTaggedT #-}

-- | Reflect reified value back in 'Applicative' context
reflected :: forall s m a. (Applicative m, Reifies s a) => TaggedT s m a
reflected :: forall {k} (s :: k) (m :: * -> *) a.
(Applicative m, Reifies s a) =>
TaggedT s m a
reflected = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a -> TaggedT s m a)
-> (Proxy s -> m a) -> Proxy s -> TaggedT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> m a
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> m a) -> (Proxy s -> a) -> Proxy s -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy s -> a
forall {k} (s :: k) a (proxy :: k -> *).
Reifies s a =>
proxy s -> a
forall (proxy :: k -> *). proxy s -> a
reflect (Proxy s -> TaggedT s m a) -> Proxy s -> TaggedT s m a
forall a b. (a -> b) -> a -> b
$ (Proxy s
forall {k} (t :: k). Proxy t
Proxy :: Proxy s)
{-# INLINE reflected #-}

-- | Reflect reified value back in 'Monad' context
reflectedM :: forall s m a. (Monad m, Reifies s a) => TaggedT s m a
reflectedM :: forall {k} (s :: k) (m :: * -> *) a.
(Monad m, Reifies s a) =>
TaggedT s m a
reflectedM = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (m a -> TaggedT s m a)
-> (Proxy s -> m a) -> Proxy s -> TaggedT s 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 (a -> m a) -> (Proxy s -> a) -> Proxy s -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy s -> a
forall {k} (s :: k) a (proxy :: k -> *).
Reifies s a =>
proxy s -> a
forall (proxy :: k -> *). proxy s -> a
reflect (Proxy s -> TaggedT s m a) -> Proxy s -> TaggedT s m a
forall a b. (a -> b) -> a -> b
$ (Proxy s
forall {k} (t :: k). Proxy t
Proxy :: Proxy s)
{-# INLINE reflectedM #-}

-- | 'asTaggedTypeOf' is a type-restricted version of 'const'. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the tag of the second.
asTaggedTypeOf :: s -> TaggedT s m b -> s
asTaggedTypeOf :: forall {k} s (m :: k -> *) (b :: k). s -> TaggedT s m b -> s
asTaggedTypeOf = s -> TaggedT s m b -> s
forall a b. a -> b -> a
const
{-# INLINE asTaggedTypeOf #-}

-- | Convert from a 'TaggedT' representation to a representation
-- based on a 'Proxy'.
proxyT :: TaggedT s m b -> Proxy s -> m b
proxyT :: forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> Proxy s -> m b
proxyT TaggedT s m b
x Proxy s
_ = TaggedT s m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT TaggedT s m b
x
{-# INLINE proxyT #-}

-- | Convert from a representation based on a 'Proxy' to a 'TaggedT'
-- representation.
unproxyT :: (Proxy s -> m a) -> TaggedT s m a
unproxyT :: forall {k} {k} (s :: k) (m :: k -> *) (a :: k).
(Proxy s -> m a) -> TaggedT s m a
unproxyT Proxy s -> m a
f = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT (Proxy s -> m a
f Proxy s
forall {k} (t :: k). Proxy t
Proxy)
{-# INLINE unproxyT #-}

-- | Tag a value with its own type.
tagTSelf :: m a -> TaggedT a m a
tagTSelf :: forall {k} (m :: k -> *) (a :: k). m a -> TaggedT a m a
tagTSelf = m a -> TaggedT a m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT
{-# INLINE tagTSelf #-}

-- | 'untagSelf' is a type-restricted version of 'untag'.
untagTSelf :: TaggedT a m a -> m a
untagTSelf :: forall {k} (a :: k) (m :: k -> *). TaggedT a m a -> m a
untagTSelf = TaggedT a m a -> m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT
{-# INLINE untagTSelf #-}

-- | Another way to convert a proxy to a tag.
tagTWith :: proxy s -> m a -> TaggedT s m a
tagTWith :: forall {k} {k} (proxy :: k -> *) (s :: k) (m :: k -> *) (a :: k).
proxy s -> m a -> TaggedT s m a
tagTWith proxy s
_ = m a -> TaggedT s m a
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
m b -> TaggedT s m b
TagT
{-# INLINE tagTWith #-}

witnessT :: TaggedT a m b -> a -> m b
witnessT :: forall {k} a (m :: k -> *) (b :: k). TaggedT a m b -> a -> m b
witnessT TaggedT a m b
x a
_ = TaggedT a m b -> m b
forall {k} {k} (s :: k) (m :: k -> *) (b :: k).
TaggedT s m b -> m b
untagT TaggedT a m b
x
{-# INLINE witnessT #-}