    {-# LANGUAGE CPP, MagicHash, UnboxedTuples, TypeFamilies #-}
    {-# LANGUAGE FlexibleContexts, FlexibleInstances, UndecidableInstances #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE DataKinds #-}
    #if __GLASGOW_HASKELL__ < 806
    {-# LANGUAGE TypeInType #-}
    #endif
    {-# OPTIONS_GHC -fno-warn-deprecations #-}

    -- |
    -- Module      : Control.Monad.Primitive
    -- Copyright   : (c) Roman Leshchinskiy 2009
    -- License     : BSD-style
    --
    -- Maintainer  : Roman Leshchinskiy <rl@cse.unsw.edu.au>
    -- Portability : non-portable
    --
    -- Primitive state-transformer monads.

    module Control.Monad.Primitive (
      PrimMonad(..), RealWorld, primitive_,
      PrimBase(..),
      MonadPrim,
      MonadPrimBase,
      liftPrim, primToPrim, primToIO, primToST, ioToPrim, stToPrim,
      unsafePrimToPrim, unsafePrimToIO, unsafePrimToST, unsafeIOToPrim,
      unsafeSTToPrim, unsafeInlinePrim, unsafeInlineIO, unsafeInlineST,
      touch, touchUnlifted,
      keepAlive, keepAliveUnlifted,
      evalPrim, unsafeInterleave, unsafeDupableInterleave, noDuplicate
    ) where

    import Data.Kind (Type)

    import GHC.Exts   ( State#, RealWorld, noDuplicate#, touch#
                      , unsafeCoerce#, realWorld#, seq# )
    import Data.Primitive.Internal.Operations (UnliftedType)
    #if defined(HAVE_KEEPALIVE)
    import Data.Primitive.Internal.Operations (keepAliveLiftedLifted#,keepAliveUnliftedLifted#)
    #endif
    import GHC.IO     ( IO(..) )
    import GHC.ST     ( ST(..) )

    #if __GLASGOW_HASKELL__ >= 802
    import qualified Control.Monad.ST.Lazy as L
    #endif

    import Control.Monad.Trans.Class (lift)

    import Control.Monad.Trans.Cont     ( ContT    )
    import Control.Monad.Trans.Identity ( IdentityT (IdentityT) )
    import Control.Monad.Trans.Maybe    ( MaybeT   )
    import Control.Monad.Trans.Reader   ( ReaderT  )
    import Control.Monad.Trans.State    ( StateT   )
    import Control.Monad.Trans.Writer   ( WriterT  )
    import Control.Monad.Trans.RWS      ( RWST     )

    #if !MIN_VERSION_transformers(0,6,0)
    import Control.Monad.Trans.List     ( ListT    )
    import Control.Monad.Trans.Error    ( ErrorT, Error)
    #endif

    import Control.Monad.Trans.Except   ( ExceptT  )

    #if MIN_VERSION_transformers(0,5,3)
    import Control.Monad.Trans.Accum    ( AccumT   )
    import Control.Monad.Trans.Select   ( SelectT  )
    #endif

    #if MIN_VERSION_transformers(0,5,6)
    import qualified Control.Monad.Trans.Writer.CPS as CPS
    import qualified Control.Monad.Trans.RWS.CPS as CPS
    #endif

    import qualified Control.Monad.Trans.RWS.Strict    as Strict ( RWST   )
    import qualified Control.Monad.Trans.State.Strict  as Strict ( StateT )
    import qualified Control.Monad.Trans.Writer.Strict as Strict ( WriterT )

    -- | Class of monads which can perform primitive state-transformer actions.
    class Monad m => PrimMonad m where
      -- | State token type.
      type PrimState m

      -- | Execute a primitive operation.
      primitive :: (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a

    -- | Class of primitive monads for state-transformer actions.
    --
    -- Unlike 'PrimMonad', this typeclass requires that the @Monad@ be fully
    -- expressed as a state transformer, therefore disallowing other monad
    -- transformers on top of the base @IO@ or @ST@.
    --
    -- @since 0.6.0.0
    class PrimMonad m => PrimBase m where
      -- | Expose the internal structure of the monad.
      internal :: m a -> State# (PrimState m) -> (# State# (PrimState m), a #)

    -- | Execute a primitive operation with no result.
    primitive_ :: PrimMonad m
                  => (State# (PrimState m) -> State# (PrimState m)) -> m ()
    {-# INLINE primitive_ #-}
    primitive_ :: forall (m :: * -> *).
    PrimMonad m =>
    (State# (PrimState m) -> State# (PrimState m)) -> m ()
    primitive_ State# (PrimState m) -> State# (PrimState m)
    f = (State# (PrimState m) -> (# State# (PrimState m), () #)) -> m ()
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive (\State# (PrimState m)
    s# ->
        case State# (PrimState m) -> State# (PrimState m)
    f State# (PrimState m)
    s# of
            State# (PrimState m)
    s'# -> (# State# (PrimState m)
    s'#, () #))

    instance PrimMonad IO where
      type PrimState IO = RealWorld
      primitive :: forall a.
    (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a
    primitive = (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
    (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a
    forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
    IO
      {-# INLINE primitive #-}

    instance PrimBase IO where
      internal :: forall a.
    IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #)
    internal (IO State# RealWorld -> (# State# RealWorld, a #)
    p) = State# RealWorld -> (# State# RealWorld, a #)
    State# (PrimState IO) -> (# State# (PrimState IO), a #)
    p
      {-# INLINE internal #-}

    -- | @since 0.6.3.0
    instance PrimMonad m => PrimMonad (ContT r m) where
      type PrimState (ContT r m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (ContT r m))
     -> (# State# (PrimState (ContT r m)), a #))
    -> ContT r m a
    primitive = m a -> ContT r m a
    forall (m :: * -> *) a. Monad m => m a -> ContT r m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> ContT r m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> ContT r m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance PrimMonad m => PrimMonad (IdentityT m) where
      type PrimState (IdentityT m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (IdentityT m))
     -> (# State# (PrimState (IdentityT m)), a #))
    -> IdentityT m a
    primitive = m a -> IdentityT m a
    forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> IdentityT m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> IdentityT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    -- | @since 0.6.2.0
    instance PrimBase m => PrimBase (IdentityT m) where
      internal :: forall a.
    IdentityT m a
    -> State# (PrimState (IdentityT m))
    -> (# State# (PrimState (IdentityT m)), a #)
    internal (IdentityT m a
    m) = m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    forall a.
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal m a
    m
      {-# INLINE internal #-}

    #if !MIN_VERSION_transformers(0,6,0)
    instance PrimMonad m => PrimMonad (ListT m) where
      type PrimState (ListT m) = PrimState m
      primitive = lift . primitive
      {-# INLINE primitive #-}

    instance (Error e, PrimMonad m) => PrimMonad (ErrorT e m) where
      type PrimState (ErrorT e m) = PrimState m
      primitive = lift . primitive
      {-# INLINE primitive #-}
    #endif

    instance PrimMonad m => PrimMonad (MaybeT m) where
      type PrimState (MaybeT m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (MaybeT m))
     -> (# State# (PrimState (MaybeT m)), a #))
    -> MaybeT m a
    primitive = m a -> MaybeT m a
    forall (m :: * -> *) a. Monad m => m a -> MaybeT m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> MaybeT m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> MaybeT m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance PrimMonad m => PrimMonad (ReaderT r m) where
      type PrimState (ReaderT r m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (ReaderT r m))
     -> (# State# (PrimState (ReaderT r m)), a #))
    -> ReaderT r m a
    primitive = m a -> ReaderT r m a
    forall (m :: * -> *) a. Monad m => m a -> ReaderT r m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> ReaderT r m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> ReaderT r m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance PrimMonad m => PrimMonad (StateT s m) where
      type PrimState (StateT s m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (StateT s m))
     -> (# State# (PrimState (StateT s m)), a #))
    -> StateT s m a
    primitive = m a -> StateT s m a
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> StateT s m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> StateT s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance (Monoid w, PrimMonad m) => PrimMonad (WriterT w m) where
      type PrimState (WriterT w m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (WriterT w m))
     -> (# State# (PrimState (WriterT w m)), a #))
    -> WriterT w m a
    primitive = m a -> WriterT w m a
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> WriterT w m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> WriterT w m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    #if MIN_VERSION_transformers(0,5,6)
    instance (Monoid w, PrimMonad m) => PrimMonad (CPS.WriterT w m) where
      type PrimState (CPS.WriterT w m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (WriterT w m))
     -> (# State# (PrimState (WriterT w m)), a #))
    -> WriterT w m a
    primitive = m a -> WriterT w m a
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> WriterT w m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> WriterT w m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}
    #endif

    instance (Monoid w, PrimMonad m) => PrimMonad (RWST r w s m) where
      type PrimState (RWST r w s m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (RWST r w s m))
     -> (# State# (PrimState (RWST r w s m)), a #))
    -> RWST r w s m a
    primitive = m a -> RWST r w s m a
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> RWST r w s m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> RWST r w s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    #if MIN_VERSION_transformers(0,5,6)
    instance (Monoid w, PrimMonad m) => PrimMonad (CPS.RWST r w s m) where
      type PrimState (CPS.RWST r w s m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (RWST r w s m))
     -> (# State# (PrimState (RWST r w s m)), a #))
    -> RWST r w s m a
    primitive = m a -> RWST r w s m a
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> RWST r w s m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> RWST r w s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}
    #endif

    instance PrimMonad m => PrimMonad (ExceptT e m) where
      type PrimState (ExceptT e m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (ExceptT e m))
     -> (# State# (PrimState (ExceptT e m)), a #))
    -> ExceptT e m a
    primitive = m a -> ExceptT e m a
    forall (m :: * -> *) a. Monad m => m a -> ExceptT e m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> ExceptT e m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> ExceptT e m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    #if MIN_VERSION_transformers(0,5,3)
    -- | @since 0.6.3.0
    instance ( Monoid w
             , PrimMonad m
             ) => PrimMonad (AccumT w m) where
      type PrimState (AccumT w m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (AccumT w m))
     -> (# State# (PrimState (AccumT w m)), a #))
    -> AccumT w m a
    primitive = m a -> AccumT w m a
    forall (m :: * -> *) a. Monad m => m a -> AccumT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> AccumT w m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> AccumT w m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance PrimMonad m => PrimMonad (SelectT r m) where
      type PrimState (SelectT r m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (SelectT r m))
     -> (# State# (PrimState (SelectT r m)), a #))
    -> SelectT r m a
    primitive = m a -> SelectT r m a
    forall (m :: * -> *) a. Monad m => m a -> SelectT r m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> SelectT r m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> SelectT r m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}
    #endif

    instance PrimMonad m => PrimMonad (Strict.StateT s m) where
      type PrimState (Strict.StateT s m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (StateT s m))
     -> (# State# (PrimState (StateT s m)), a #))
    -> StateT s m a
    primitive = m a -> StateT s m a
    forall (m :: * -> *) a. Monad m => m a -> StateT s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> StateT s m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> StateT s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance (Monoid w, PrimMonad m) => PrimMonad (Strict.WriterT w m) where
      type PrimState (Strict.WriterT w m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (WriterT w m))
     -> (# State# (PrimState (WriterT w m)), a #))
    -> WriterT w m a
    primitive = m a -> WriterT w m a
    forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> WriterT w m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> WriterT w m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance (Monoid w, PrimMonad m) => PrimMonad (Strict.RWST r w s m) where
      type PrimState (Strict.RWST r w s m) = PrimState m
      primitive :: forall a.
    (State# (PrimState (RWST r w s m))
     -> (# State# (PrimState (RWST r w s m)), a #))
    -> RWST r w s m a
    primitive = m a -> RWST r w s m a
    forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> RWST r w s m a)
    -> ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #))
    -> RWST r w s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    instance PrimMonad (ST s) where
      type PrimState (ST s) = s
      primitive :: forall a.
    (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #))
    -> ST s a
    primitive = STRep s a -> ST s a
    (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #))
    -> ST s a
    forall s a. STRep s a -> ST s a
    ST
      {-# INLINE primitive #-}

    instance PrimBase (ST s) where
      internal :: forall a.
    ST s a
    -> State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)
    internal (ST STRep s a
    p) = STRep s a
    State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)
    p
      {-# INLINE internal #-}

    -- see https://gitlab.haskell.org/ghc/ghc/commit/2f5cb3d44d05e581b75a47fec222577dfa7a533e
    -- for why we only support an instance for ghc >= 8.2
    #if __GLASGOW_HASKELL__ >= 802
    -- @since 0.7.1.0
    instance PrimMonad (L.ST s) where
      type PrimState (L.ST s) = s
      primitive :: forall a.
    (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #))
    -> ST s a
    primitive = ST s a -> ST s a
    forall s a. ST s a -> ST s a
    L.strictToLazyST (ST s a -> ST s a)
    -> ((State# s -> (# State# s, a #)) -> ST s a)
    -> (State# s -> (# State# s, a #))
    -> ST s a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (State# s -> (# State# s, a #)) -> ST s a
    (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #))
    -> ST s a
    forall a.
    (State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #))
    -> ST s a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive
      {-# INLINE primitive #-}

    -- @since 0.7.1.0
    instance PrimBase (L.ST s) where
      internal :: forall a.
    ST s a
    -> State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)
    internal = ST s a -> State# s -> (# State# s, a #)
    ST s a
    -> State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)
    forall a.
    ST s a
    -> State# (PrimState (ST s)) -> (# State# (PrimState (ST s)), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal (ST s a -> State# s -> (# State# s, a #))
    -> (ST s a -> ST s a) -> ST s a -> State# s -> (# State# s, a #)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ST s a -> ST s a
    forall s a. ST s a -> ST s a
    L.lazyToStrictST
      {-# INLINE internal #-}
    #endif

    -- | 'PrimMonad'\'s state token type can be annoying to handle
    --   in constraints. This typeclass lets users (visually) notice
    --   'PrimState' equality constraints less, by witnessing that
    --   @s ~ 'PrimState' m@.
    class (PrimMonad m, s ~ PrimState m) => MonadPrim s m
    instance (PrimMonad m, s ~ PrimState m) => MonadPrim s m

    -- | 'PrimBase'\'s state token type can be annoying to handle
    --   in constraints. This typeclass lets users (visually) notice
    --   'PrimState' equality constraints less, by witnessing that
    --   @s ~ 'PrimState' m@.
    class (PrimBase m, MonadPrim s m) => MonadPrimBase s m
    instance (PrimBase m, MonadPrim s m) => MonadPrimBase s m

    -- | Lifts a 'PrimBase' into another 'PrimMonad' with the same underlying state
    -- token type.
    liftPrim
      :: (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) => m1 a -> m2 a
    {-# INLINE liftPrim #-}
    liftPrim :: forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) =>
    m1 a -> m2 a
    liftPrim = m1 a -> m2 a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) =>
    m1 a -> m2 a
    primToPrim

    -- | Convert a 'PrimBase' to another monad with the same state token.
    primToPrim :: (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2)
            => m1 a -> m2 a
    {-# INLINE primToPrim #-}
    primToPrim :: forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) =>
    m1 a -> m2 a
    primToPrim m1 a
    m = (State# (PrimState m2) -> (# State# (PrimState m2), a #)) -> m2 a
    forall a.
    (State# (PrimState m2) -> (# State# (PrimState m2), a #)) -> m2 a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive (m1 a -> State# (PrimState m1) -> (# State# (PrimState m1), a #)
    forall a.
    m1 a -> State# (PrimState m1) -> (# State# (PrimState m1), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal m1 a
    m)

    -- | Convert a 'PrimBase' with a 'RealWorld' state token to 'IO'
    primToIO :: (PrimBase m, PrimState m ~ RealWorld) => m a -> IO a
    {-# INLINE primToIO #-}
    primToIO :: forall (m :: * -> *) a.
    (PrimBase m, PrimState m ~ RealWorld) =>
    m a -> IO a
    primToIO = m a -> IO a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) =>
    m1 a -> m2 a
    primToPrim

    -- | Convert a 'PrimBase' to 'ST'
    primToST :: PrimBase m => m a -> ST (PrimState m) a
    {-# INLINE primToST #-}
    primToST :: forall (m :: * -> *) a. PrimBase m => m a -> ST (PrimState m) a
    primToST = m a -> ST (PrimState m) a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) =>
    m1 a -> m2 a
    primToPrim

    -- | Convert an 'IO' action to a 'PrimMonad'.
    --
    -- @since 0.6.2.0
    ioToPrim :: (PrimMonad m, PrimState m ~ RealWorld) => IO a -> m a
    {-# INLINE ioToPrim #-}
    ioToPrim :: forall (m :: * -> *) a.
    (PrimMonad m, PrimState m ~ RealWorld) =>
    IO a -> m a
    ioToPrim = IO a -> m a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) =>
    m1 a -> m2 a
    primToPrim

    -- | Convert an 'ST' action to a 'PrimMonad'.
    --
    -- @since 0.6.2.0
    stToPrim :: PrimMonad m => ST (PrimState m) a -> m a
    {-# INLINE stToPrim #-}
    stToPrim :: forall (m :: * -> *) a. PrimMonad m => ST (PrimState m) a -> m a
    stToPrim = ST (PrimState m) a -> m a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2, PrimState m1 ~ PrimState m2) =>
    m1 a -> m2 a
    primToPrim

    -- | Convert a 'PrimBase' to another monad with a possibly different state
    -- token. This operation is highly unsafe!
    unsafePrimToPrim :: (PrimBase m1, PrimMonad m2) => m1 a -> m2 a
    {-# INLINE unsafePrimToPrim #-}
    unsafePrimToPrim :: forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2) =>
    m1 a -> m2 a
    unsafePrimToPrim m1 a
    m = (State# (PrimState m2) -> (# State# (PrimState m2), a #)) -> m2 a
    forall a.
    (State# (PrimState m2) -> (# State# (PrimState m2), a #)) -> m2 a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive ((State# (PrimState m1) -> (# State# (PrimState m1), a #))
    -> State# (PrimState m2) -> (# State# (PrimState m2), a #)
    forall a b. a -> b
    unsafeCoerce# (m1 a -> State# (PrimState m1) -> (# State# (PrimState m1), a #)
    forall a.
    m1 a -> State# (PrimState m1) -> (# State# (PrimState m1), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal m1 a
    m))

    -- | Convert any 'PrimBase' to 'ST' with an arbitrary state token. This
    -- operation is highly unsafe!
    unsafePrimToST :: PrimBase m => m a -> ST s a
    {-# INLINE unsafePrimToST #-}
    unsafePrimToST :: forall (m :: * -> *) a s. PrimBase m => m a -> ST s a
    unsafePrimToST = m a -> ST s a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2) =>
    m1 a -> m2 a
    unsafePrimToPrim

    -- | Convert any 'PrimBase' to 'IO'. This operation is highly unsafe!
    unsafePrimToIO :: PrimBase m => m a -> IO a
    {-# INLINE unsafePrimToIO #-}
    unsafePrimToIO :: forall (m :: * -> *) a. PrimBase m => m a -> IO a
    unsafePrimToIO = m a -> IO a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2) =>
    m1 a -> m2 a
    unsafePrimToPrim

    -- | Convert an 'ST' action with an arbitrary state token to any 'PrimMonad'.
    -- This operation is highly unsafe!
    --
    -- @since 0.6.2.0
    unsafeSTToPrim :: PrimMonad m => ST s a -> m a
    {-# INLINE unsafeSTToPrim #-}
    unsafeSTToPrim :: forall (m :: * -> *) s a. PrimMonad m => ST s a -> m a
    unsafeSTToPrim = ST s a -> m a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2) =>
    m1 a -> m2 a
    unsafePrimToPrim

    -- | Convert an 'IO' action to any 'PrimMonad'. This operation is highly
    -- unsafe!
    --
    -- @since 0.6.2.0
    unsafeIOToPrim :: PrimMonad m => IO a -> m a
    {-# INLINE unsafeIOToPrim #-}
    unsafeIOToPrim :: forall (m :: * -> *) a. PrimMonad m => IO a -> m a
    unsafeIOToPrim = IO a -> m a
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2) =>
    m1 a -> m2 a
    unsafePrimToPrim

    -- | See 'unsafeInlineIO'. This function is not recommended for the same
    -- reasons.
    unsafeInlinePrim :: PrimBase m => m a -> a
    {-# INLINE unsafeInlinePrim #-}
    unsafeInlinePrim :: forall (m :: * -> *) a. PrimBase m => m a -> a
    unsafeInlinePrim m a
    m = IO a -> a
    forall a. IO a -> a
    unsafeInlineIO (m a -> IO a
    forall (m :: * -> *) a. PrimBase m => m a -> IO a
    unsafePrimToIO m a
    m)

    -- | Generally, do not use this function. It is the same as
    -- @accursedUnutterablePerformIO@ from @bytestring@ and is well behaved under
    -- narrow conditions. See the documentation of that function to get an idea
    -- of when this is sound. In most cases @GHC.IO.Unsafe.unsafeDupablePerformIO@
    -- should be preferred.
    unsafeInlineIO :: IO a -> a
    {-# INLINE unsafeInlineIO #-}
    unsafeInlineIO :: forall a. IO a -> a
    unsafeInlineIO IO a
    m = case IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #)
    forall a.
    IO a -> State# (PrimState IO) -> (# State# (PrimState IO), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal IO a
    m State# RealWorld
    State# (PrimState IO)
    realWorld# of (# State# (PrimState IO)
    _, a
    r #) -> a
    r

    -- | See 'unsafeInlineIO'. This function is not recommended for the same
    -- reasons. Prefer @runST@ when @s@ is free.
    unsafeInlineST :: ST s a -> a
    {-# INLINE unsafeInlineST #-}
    unsafeInlineST :: forall s a. ST s a -> a
    unsafeInlineST = ST s a -> a
    forall (m :: * -> *) a. PrimBase m => m a -> a
    unsafeInlinePrim

    -- | Ensure that the value is considered alive by the garbage collection.
    -- Warning: GHC has optimization passes that can erase @touch@ if it is
    -- certain that an exception is thrown afterward. Prefer 'keepAlive'.
    touch :: PrimMonad m => a -> m ()
    {-# INLINE touch #-}
    touch :: forall (m :: * -> *) a. PrimMonad m => a -> m ()
    touch a
    x = IO () -> m ()
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2) =>
    m1 a -> m2 a
    unsafePrimToPrim
            (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ((State# (PrimState IO) -> (# State# (PrimState IO), () #)) -> IO ()
    forall a.
    (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive (\State# (PrimState IO)
    s -> case a -> State# RealWorld -> State# RealWorld
    forall a d. a -> State# d -> State# d
    touch# a
    x State# RealWorld
    State# (PrimState IO)
    s of { State# RealWorld
    s' -> (# State# RealWorld
    State# (PrimState IO)
    s', () #) }) :: IO ())

    -- | Variant of 'touch' that keeps a value of an unlifted type
    -- (e.g. @MutableByteArray#@) alive.
    touchUnlifted :: forall (m :: Type -> Type) (a :: UnliftedType). PrimMonad m => a -> m ()
    {-# INLINE touchUnlifted #-}
    touchUnlifted :: forall (m :: * -> *) (a :: UnliftedType). PrimMonad m => a -> m ()
    touchUnlifted a
    x = IO () -> m ()
    forall (m1 :: * -> *) (m2 :: * -> *) a.
    (PrimBase m1, PrimMonad m2) =>
    m1 a -> m2 a
    unsafePrimToPrim
            (IO () -> m ()) -> IO () -> m ()
    forall a b. (a -> b) -> a -> b
    $ ((State# (PrimState IO) -> (# State# (PrimState IO), () #)) -> IO ()
    forall a.
    (State# (PrimState IO) -> (# State# (PrimState IO), a #)) -> IO a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive (\State# (PrimState IO)
    s -> case a -> State# RealWorld -> State# RealWorld
    forall a d. a -> State# d -> State# d
    touch# a
    x State# RealWorld
    State# (PrimState IO)
    s of { State# RealWorld
    s' -> (# State# RealWorld
    State# (PrimState IO)
    s', () #) }) :: IO ())

    -- | Keep value @x@ alive until computation @k@ completes.
    -- Warning: This primop exists for completeness, but it is difficult to use
    -- correctly. Prefer 'keepAliveUnlifted' if the value to keep alive is simply
    -- a wrapper around an unlifted type (e.g. @ByteArray@).
    keepAlive :: PrimBase m
      => a -- ^ Value @x@ to keep alive while computation @k@ runs.
      -> m r -- ^ Computation @k@
      -> m r
    #if defined(HAVE_KEEPALIVE)
    {-# INLINE keepAlive #-}
    keepAlive :: forall (m :: * -> *) a r. PrimBase m => a -> m r -> m r
    keepAlive a
    x m r
    k =
      (State# (PrimState m) -> (# State# (PrimState m), r #)) -> m r
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive ((State# (PrimState m) -> (# State# (PrimState m), r #)) -> m r)
    -> (State# (PrimState m) -> (# State# (PrimState m), r #)) -> m r
    forall a b. (a -> b) -> a -> b
    $ \State# (PrimState m)
    s0 -> a
    -> State# (PrimState m)
    -> (State# (PrimState m) -> (# State# (PrimState m), r #))
    -> (# State# (PrimState m), r #)
    forall s a b.
    a
    -> State# s -> (State# s -> (# State# s, b #)) -> (# State# s, b #)
    keepAliveLiftedLifted# a
    x State# (PrimState m)
    s0 (m r -> State# (PrimState m) -> (# State# (PrimState m), r #)
    forall a.
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal m r
    k)

    #else
    {-# NOINLINE keepAlive #-}
    keepAlive x k = k <* touch x
    #endif

    -- | Variant of 'keepAlive' in which the value kept alive is of an unlifted
    -- boxed type.
    keepAliveUnlifted :: forall (m :: Type -> Type) (a :: UnliftedType) (r :: Type). PrimBase m => a -> m r -> m r
    #if defined(HAVE_KEEPALIVE)
    {-# INLINE keepAliveUnlifted #-}
    keepAliveUnlifted :: forall (m :: * -> *) (a :: UnliftedType) r.
    PrimBase m =>
    a -> m r -> m r
    keepAliveUnlifted a
    x m r
    k =
      (State# (PrimState m) -> (# State# (PrimState m), r #)) -> m r
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive ((State# (PrimState m) -> (# State# (PrimState m), r #)) -> m r)
    -> (State# (PrimState m) -> (# State# (PrimState m), r #)) -> m r
    forall a b. (a -> b) -> a -> b
    $ \State# (PrimState m)
    s0 -> a
    -> State# (PrimState m)
    -> (State# (PrimState m) -> (# State# (PrimState m), r #))
    -> (# State# (PrimState m), r #)
    forall s (a :: UnliftedType) b.
    a
    -> State# s -> (State# s -> (# State# s, b #)) -> (# State# s, b #)
    keepAliveUnliftedLifted# a
    x State# (PrimState m)
    s0 (m r -> State# (PrimState m) -> (# State# (PrimState m), r #)
    forall a.
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal m r
    k)

    #else
    {-# NOINLINE keepAliveUnlifted #-}
    keepAliveUnlifted x k = k <* touchUnlifted x
    #endif

    -- | Create an action to force a value; generalizes 'Control.Exception.evaluate'
    --
    -- @since 0.6.2.0
    evalPrim :: forall a m . PrimMonad m => a -> m a
    evalPrim :: forall a (m :: * -> *). PrimMonad m => a -> m a
    evalPrim a
    a = (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive (\State# (PrimState m)
    s -> a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    forall a d. a -> State# d -> (# State# d, a #)
    seq# a
    a State# (PrimState m)
    s)

    noDuplicate :: PrimMonad m => m ()
    #if __GLASGOW_HASKELL__ >= 802
    noDuplicate :: forall (m :: * -> *). PrimMonad m => m ()
    noDuplicate = (State# (PrimState m) -> (# State# (PrimState m), () #)) -> m ()
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive ((State# (PrimState m) -> (# State# (PrimState m), () #)) -> m ())
    -> (State# (PrimState m) -> (# State# (PrimState m), () #)) -> m ()
    forall a b. (a -> b) -> a -> b
    $ \ State# (PrimState m)
    s -> (# State# (PrimState m) -> State# (PrimState m)
    forall d. State# d -> State# d
    noDuplicate# State# (PrimState m)
    s, () #)
    #else
    -- noDuplicate# was limited to RealWorld
    noDuplicate = unsafeIOToPrim $ primitive $ \s -> (# noDuplicate# s, () #)
    #endif

    unsafeInterleave, unsafeDupableInterleave :: PrimBase m => m a -> m a
    unsafeInterleave :: forall (m :: * -> *) a. PrimBase m => m a -> m a
    unsafeInterleave m a
    x = m a -> m a
    forall (m :: * -> *) a. PrimBase m => m a -> m a
    unsafeDupableInterleave (m ()
    forall (m :: * -> *). PrimMonad m => m ()
    noDuplicate m () -> m a -> m a
    forall a b. m a -> m b -> m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> m a
    x)
    unsafeDupableInterleave :: forall (m :: * -> *) a. PrimBase m => m a -> m a
    unsafeDupableInterleave m a
    x = (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a.
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall (m :: * -> *) a.
    PrimMonad m =>
    (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    primitive ((State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a)
    -> (State# (PrimState m) -> (# State# (PrimState m), a #)) -> m a
    forall a b. (a -> b) -> a -> b
    $ \ State# (PrimState m)
    s -> let r' :: a
    r' = case m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    forall a.
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    forall (m :: * -> *) a.
    PrimBase m =>
    m a -> State# (PrimState m) -> (# State# (PrimState m), a #)
    internal m a
    x State# (PrimState m)
    s of (# State# (PrimState m)
    _, a
    r #) -> a
    r in (# State# (PrimState m)
    s, a
    r' #)
    {-# INLINE unsafeInterleave #-}
    {-# NOINLINE unsafeDupableInterleave #-}
    -- See Note [unsafeDupableInterleaveIO should not be inlined]
    -- in GHC.IO.Unsafe