{-# LANGUAGE Unsafe #-}
{-# LANGUAGE DataKinds, MagicHash, RoleAnnotations, UnboxedTuples, DerivingVia #-}
{-# OPTIONS_HADDOCK hide #-}
module Text.Gigaparsec.Internal.RT (module Text.Gigaparsec.Internal.RT) where

import GHC.Base (MutVar#, RealWorld, State#, runRW#, newMutVar#, readMutVar#, writeMutVar#)

import Data.Coerce (coerce)
import GHC.IO (IO(IO))
import GHC.IORef (IORef(IORef))
import GHC.STRef (STRef(STRef))

type Reg :: * -> * -> *
type role Reg phantom representational
-- Don't even expose the constructor, then it's pretty much safe
data Reg r a = Reg (MutVar# RealWorld a)

type RT :: * -> *
newtype RT a = RT (State# RealWorld -> (# State# RealWorld, a #))
  deriving (forall a b. a -> RT b -> RT a
forall a b. (a -> b) -> RT a -> RT b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> RT b -> RT a
$c<$ :: forall a b. a -> RT b -> RT a
fmap :: forall a b. (a -> b) -> RT a -> RT b
$cfmap :: forall a b. (a -> b) -> RT a -> RT b
Functor, Functor RT
forall a. a -> RT a
forall a b. RT a -> RT b -> RT a
forall a b. RT a -> RT b -> RT b
forall a b. RT (a -> b) -> RT a -> RT b
forall a b c. (a -> b -> c) -> RT a -> RT b -> RT c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
<* :: forall a b. RT a -> RT b -> RT a
$c<* :: forall a b. RT a -> RT b -> RT a
*> :: forall a b. RT a -> RT b -> RT b
$c*> :: forall a b. RT a -> RT b -> RT b
liftA2 :: forall a b c. (a -> b -> c) -> RT a -> RT b -> RT c
$cliftA2 :: forall a b c. (a -> b -> c) -> RT a -> RT b -> RT c
<*> :: forall a b. RT (a -> b) -> RT a -> RT b
$c<*> :: forall a b. RT (a -> b) -> RT a -> RT b
pure :: forall a. a -> RT a
$cpure :: forall a. a -> RT a
Applicative, Applicative RT
forall a. a -> RT a
forall a b. RT a -> RT b -> RT b
forall a b. RT a -> (a -> RT b) -> RT b
forall (m :: * -> *).
Applicative m
-> (forall a b. m a -> (a -> m b) -> m b)
-> (forall a b. m a -> m b -> m b)
-> (forall a. a -> m a)
-> Monad m
return :: forall a. a -> RT a
$creturn :: forall a. a -> RT a
>> :: forall a b. RT a -> RT b -> RT b
$c>> :: forall a b. RT a -> RT b -> RT b
>>= :: forall a b. RT a -> (a -> RT b) -> RT b
$c>>= :: forall a b. RT a -> (a -> RT b) -> RT b
Monad) via IO

{-# INLINE runRT #-}
runRT :: RT a -> a
runRT :: forall a. RT a -> a
runRT (RT State# RealWorld -> (# State# RealWorld, a #)
mx) = case forall o. (State# RealWorld -> o) -> o
runRW# State# RealWorld -> (# State# RealWorld, a #)
mx of (# State# RealWorld
_, a
x #) -> a
x

{-# INLINABLE newReg #-}
newReg :: a -> (forall r. Reg r a -> RT b) -> RT b
newReg :: forall a b. a -> (forall r. Reg r a -> RT b) -> RT b
newReg a
x forall r. Reg r a -> RT b
k = forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> RT a
RT forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s# ->
  case forall a d. a -> State# d -> (# State# d, MutVar# d a #)
newMutVar# a
x State# RealWorld
s# of
    (# State# RealWorld
s'#, MutVar# RealWorld a
reg# #) -> let RT State# RealWorld -> (# State# RealWorld, b #)
k' = forall r. Reg r a -> RT b
k (forall r a. MutVar# RealWorld a -> Reg r a
Reg MutVar# RealWorld a
reg#) in State# RealWorld -> (# State# RealWorld, b #)
k' State# RealWorld
s'#

{-# INLINE readReg #-}
readReg :: Reg r a -> RT a
readReg :: forall r a. Reg r a -> RT a
readReg (Reg MutVar# RealWorld a
reg#) = forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> RT a
RT forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s# -> forall d a. MutVar# d a -> State# d -> (# State# d, a #)
readMutVar# MutVar# RealWorld a
reg# State# RealWorld
s#

{-# INLINABLE writeReg #-}
writeReg :: Reg r a -> a -> RT ()
writeReg :: forall r a. Reg r a -> a -> RT ()
writeReg (Reg MutVar# RealWorld a
reg#) a
x = forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> RT a
RT forall a b. (a -> b) -> a -> b
$ \State# RealWorld
s# ->
  case forall d a. MutVar# d a -> a -> State# d -> State# d
writeMutVar# MutVar# RealWorld a
reg# a
x State# RealWorld
s# of
    State# RealWorld
s'# -> (# State# RealWorld
s'#, () #)

{-# INLINE unsafeIOToRT #-}
unsafeIOToRT :: IO a -> RT a
unsafeIOToRT :: forall a. IO a -> RT a
unsafeIOToRT = coerce :: forall a b. Coercible a b => a -> b
coerce

{-# INLINE rtToIO #-}
rtToIO :: RT a -> IO a
rtToIO :: forall a. RT a -> IO a
rtToIO = coerce :: forall a b. Coercible a b => a -> b
coerce

{-# INLINE fromIORef #-}
fromIORef :: IORef a -> Reg r a
fromIORef :: forall a r. IORef a -> Reg r a
fromIORef (IORef (STRef MutVar# RealWorld a
reg#)) = forall r a. MutVar# RealWorld a -> Reg r a
Reg MutVar# RealWorld a
reg#