{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternSynonyms #-}

module Unison.Runtime.MCode.Serialize
  ( putComb,
    getComb,
    putCombIx,
    getCombIx,
  )
where

import Data.ByteString.Builder (Builder)
import Data.ByteString.Builder qualified as BU
import Data.Bytes.Get
import Data.Bytes.Serial
import Data.Bytes.VarInt
import Data.Void (Void)
import Data.Word (Word64)
import GHC.Exts (IsList (..))
import Unison.Runtime.ANF (PackedTag (..))
import Unison.Runtime.Array (PrimArray)
import Unison.Runtime.Foreign.Function.Type (ForeignFunc)
import Unison.Runtime.MCode hiding (MatchT)
import Unison.Runtime.Serialize
import Unison.Util.Text qualified as Util.Text
import Prelude hiding (getChar, putChar)

data CombT = LamT | CachedClosureT

instance Tag CombT where
  tag2word :: CombT -> Word8
tag2word CombT
LamT = Word8
0
  tag2word CombT
CachedClosureT = Word8
1

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m CombT
word2tag Word8
0 = CombT -> m CombT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CombT
LamT
  word2tag Word8
1 = CombT -> m CombT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure CombT
CachedClosureT
  word2tag Word8
n = String -> Word8 -> m CombT
forall (m :: * -> *) a. MonadGet m => String -> Word8 -> m a
unknownTag String
"CombT" Word8
n

putPackedTag :: PackedTag -> Builder
putPackedTag :: PackedTag -> Builder
putPackedTag (PackedTag Word64
w) = Word64 -> Builder
pWord Word64
w

getPackedTag :: (MonadGet m) => m PackedTag
getPackedTag :: forall (m :: * -> *). MonadGet m => m PackedTag
getPackedTag = Word64 -> PackedTag
PackedTag (Word64 -> PackedTag) -> m Word64 -> m PackedTag
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord

putComb :: (clos -> Builder) -> GComb clos comb -> Builder
putComb :: forall clos comb. (clos -> Builder) -> GComb clos comb -> Builder
putComb clos -> Builder
pClos = \case
  (Lam Int
a Int
f GSection comb
body) ->
    CombT -> Builder
forall t. Tag t => t -> Builder
putTag CombT
LamT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
a Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
f Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection comb -> Builder
forall cix. GSection cix -> Builder
putSection GSection comb
body
  (CachedVal Word64
w clos
v) ->
    CombT -> Builder
forall t. Tag t => t -> Builder
putTag CombT
CachedClosureT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
putNat Word64
w Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> clos -> Builder
pClos clos
v

getComb :: (MonadGet m) => m (GComb Void CombIx)
getComb :: forall (m :: * -> *). MonadGet m => m (GComb Void CombIx)
getComb =
  m CombT
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m CombT
-> (CombT -> m (GComb Void CombIx)) -> m (GComb Void CombIx)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    CombT
LamT ->
      Int -> Int -> GSection CombIx -> GComb Void CombIx
forall comb val. Int -> Int -> GSection comb -> GComb val comb
Lam (Int -> Int -> GSection CombIx -> GComb Void CombIx)
-> m Int -> m (Int -> GSection CombIx -> GComb Void CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Int -> GSection CombIx -> GComb Void CombIx)
-> m Int -> m (GSection CombIx -> GComb Void CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (GSection CombIx -> GComb Void CombIx)
-> m (GSection CombIx) -> m (GComb Void CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
    CombT
CachedClosureT -> String -> m (GComb Void CombIx)
forall a. HasCallStack => String -> a
error String
"getComb: Unexpected serialized Cached Closure"

getMForeignFunc :: (MonadGet m) => m ForeignFunc
getMForeignFunc :: forall (m :: * -> *). MonadGet m => m ForeignFunc
getMForeignFunc = do
  Int -> ForeignFunc
forall a. Enum a => Int -> a
toEnum (Int -> ForeignFunc) -> m Int -> m ForeignFunc
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt

putMForeignFunc :: ForeignFunc -> Builder
putMForeignFunc :: ForeignFunc -> Builder
putMForeignFunc = Int -> Builder
pInt (Int -> Builder) -> (ForeignFunc -> Int) -> ForeignFunc -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ForeignFunc -> Int
forall a. Enum a => a -> Int
fromEnum

data SectionT
  = AppT
  | CallT
  | JumpT
  | MatchT
  | YieldT
  | InsT
  | LetT
  | DieT
  | ExitT
  | DMatchT
  | NMatchT
  | RMatchT

instance Tag SectionT where
  tag2word :: SectionT -> Word8
tag2word SectionT
AppT = Word8
0
  tag2word SectionT
CallT = Word8
1
  tag2word SectionT
JumpT = Word8
2
  tag2word SectionT
MatchT = Word8
3
  tag2word SectionT
YieldT = Word8
4
  tag2word SectionT
InsT = Word8
5
  tag2word SectionT
LetT = Word8
6
  tag2word SectionT
DieT = Word8
7
  tag2word SectionT
ExitT = Word8
8
  tag2word SectionT
DMatchT = Word8
9
  tag2word SectionT
NMatchT = Word8
10
  tag2word SectionT
RMatchT = Word8
11

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m SectionT
word2tag Word8
0 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
AppT
  word2tag Word8
1 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
CallT
  word2tag Word8
2 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
JumpT
  word2tag Word8
3 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
MatchT
  word2tag Word8
4 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
YieldT
  word2tag Word8
5 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
InsT
  word2tag Word8
6 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
LetT
  word2tag Word8
7 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
DieT
  word2tag Word8
8 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
ExitT
  word2tag Word8
9 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
DMatchT
  word2tag Word8
10 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
NMatchT
  word2tag Word8
11 = SectionT -> m SectionT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SectionT
RMatchT
  word2tag Word8
i = String -> Word8 -> m SectionT
forall (m :: * -> *) a. MonadGet m => String -> Word8 -> m a
unknownTag String
"SectionT" Word8
i

putSection :: GSection cix -> Builder
putSection :: forall cix. GSection cix -> Builder
putSection = \case
  App Bool
b GRef cix
r Args
a -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
AppT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Bool -> Builder
putBool Bool
b Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GRef cix -> Builder
forall cix. GRef cix -> Builder
putRef GRef cix
r Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  Call Bool
b CombIx
cix cix
_comb Args
a -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
CallT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Bool -> Builder
putBool Bool
b Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> CombIx -> Builder
putCombIx CombIx
cix Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  Jump Int
i Args
a -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
JumpT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  Match Int
i GBranch cix
b -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
MatchT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GBranch cix -> Builder
forall cix. GBranch cix -> Builder
putBranch GBranch cix
b
  Yield Args
a -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
YieldT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  Ins GInstr cix
i GSection cix
s -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
InsT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GInstr cix -> Builder
forall cix. GInstr cix -> Builder
putInstr GInstr cix
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
s
  Let GSection cix
s CombIx
ci Int
f GSection cix
bd ->
    SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
LetT
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
s
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> CombIx -> Builder
putCombIx CombIx
ci
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
f
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
bd
  Die String
s -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
DieT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> String -> Builder
putString String
s
  GSection cix
Exit -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
ExitT
  DMatch Maybe Reference
mr Int
i GBranch cix
b -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
DMatchT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Maybe Reference -> (Reference -> Builder) -> Builder
forall a. Maybe a -> (a -> Builder) -> Builder
putMaybe Maybe Reference
mr Reference -> Builder
putReference Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GBranch cix -> Builder
forall cix. GBranch cix -> Builder
putBranch GBranch cix
b
  NMatch Maybe Reference
mr Int
i GBranch cix
b -> SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
NMatchT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Maybe Reference -> (Reference -> Builder) -> Builder
forall a. Maybe a -> (a -> Builder) -> Builder
putMaybe Maybe Reference
mr Reference -> Builder
putReference Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GBranch cix -> Builder
forall cix. GBranch cix -> Builder
putBranch GBranch cix
b
  RMatch Int
i GSection cix
pu EnumMap Word64 (GBranch cix)
bs ->
    SectionT -> Builder
forall t. Tag t => t -> Builder
putTag SectionT
RMatchT
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
pu
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Word64 -> Builder)
-> (GBranch cix -> Builder)
-> EnumMap Word64 (GBranch cix)
-> Builder
forall k v.
EnumKey k =>
(k -> Builder) -> (v -> Builder) -> EnumMap k v -> Builder
putEnumMap Word64 -> Builder
pWord GBranch cix -> Builder
forall cix. GBranch cix -> Builder
putBranch EnumMap Word64 (GBranch cix)
bs

getSection :: (MonadGet m) => m Section
getSection :: forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection =
  m SectionT
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m SectionT
-> (SectionT -> m (GSection CombIx)) -> m (GSection CombIx)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    SectionT
AppT -> Bool -> GRef CombIx -> Args -> GSection CombIx
forall comb. Bool -> GRef comb -> Args -> GSection comb
App (Bool -> GRef CombIx -> Args -> GSection CombIx)
-> m Bool -> m (GRef CombIx -> Args -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Bool
forall (m :: * -> *). MonadGet m => m Bool
getBool m (GRef CombIx -> Args -> GSection CombIx)
-> m (GRef CombIx) -> m (Args -> GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GRef CombIx)
forall (m :: * -> *). MonadGet m => m (GRef CombIx)
getRef m (Args -> GSection CombIx) -> m Args -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
    SectionT
CallT -> do
      Bool
skipCheck <- m Bool
forall (m :: * -> *). MonadGet m => m Bool
getBool
      CombIx
cix <- m CombIx
forall (m :: * -> *). MonadGet m => m CombIx
getCombIx
      Args
args <- m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
      pure $ Bool -> CombIx -> CombIx -> Args -> GSection CombIx
forall comb. Bool -> CombIx -> comb -> Args -> GSection comb
Call Bool
skipCheck CombIx
cix CombIx
cix Args
args
    SectionT
JumpT -> Int -> Args -> GSection CombIx
forall comb. Int -> Args -> GSection comb
Jump (Int -> Args -> GSection CombIx)
-> m Int -> m (Args -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Args -> GSection CombIx) -> m Args -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
    SectionT
MatchT -> Int -> GBranch CombIx -> GSection CombIx
forall comb. Int -> GBranch comb -> GSection comb
Match (Int -> GBranch CombIx -> GSection CombIx)
-> m Int -> m (GBranch CombIx -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (GBranch CombIx -> GSection CombIx)
-> m (GBranch CombIx) -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GBranch CombIx)
forall (m :: * -> *). MonadGet m => m (GBranch CombIx)
getBranch
    SectionT
YieldT -> Args -> GSection CombIx
forall comb. Args -> GSection comb
Yield (Args -> GSection CombIx) -> m Args -> m (GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
    SectionT
InsT -> GInstr CombIx -> GSection CombIx -> GSection CombIx
forall comb. GInstr comb -> GSection comb -> GSection comb
Ins (GInstr CombIx -> GSection CombIx -> GSection CombIx)
-> m (GInstr CombIx) -> m (GSection CombIx -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (GInstr CombIx)
forall (m :: * -> *). MonadGet m => m (GInstr CombIx)
getInstr m (GSection CombIx -> GSection CombIx)
-> m (GSection CombIx) -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
    SectionT
LetT ->
      GSection CombIx
-> CombIx -> Int -> GSection CombIx -> GSection CombIx
forall comb.
GSection comb -> CombIx -> Int -> GSection comb -> GSection comb
Let (GSection CombIx
 -> CombIx -> Int -> GSection CombIx -> GSection CombIx)
-> m (GSection CombIx)
-> m (CombIx -> Int -> GSection CombIx -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection m (CombIx -> Int -> GSection CombIx -> GSection CombIx)
-> m CombIx -> m (Int -> GSection CombIx -> GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m CombIx
forall (m :: * -> *). MonadGet m => m CombIx
getCombIx m (Int -> GSection CombIx -> GSection CombIx)
-> m Int -> m (GSection CombIx -> GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (GSection CombIx -> GSection CombIx)
-> m (GSection CombIx) -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
    SectionT
DieT -> String -> GSection CombIx
forall comb. String -> GSection comb
Die (String -> GSection CombIx) -> m String -> m (GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m String
forall (m :: * -> *). MonadGet m => m String
getString
    SectionT
ExitT -> GSection CombIx -> m (GSection CombIx)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure GSection CombIx
forall comb. GSection comb
Exit
    SectionT
DMatchT -> Maybe Reference -> Int -> GBranch CombIx -> GSection CombIx
forall comb.
Maybe Reference -> Int -> GBranch comb -> GSection comb
DMatch (Maybe Reference -> Int -> GBranch CombIx -> GSection CombIx)
-> m (Maybe Reference)
-> m (Int -> GBranch CombIx -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Reference -> m (Maybe Reference)
forall (m :: * -> *) a. MonadGet m => m a -> m (Maybe a)
getMaybe m Reference
forall (m :: * -> *). MonadGet m => m Reference
getReference m (Int -> GBranch CombIx -> GSection CombIx)
-> m Int -> m (GBranch CombIx -> GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (GBranch CombIx -> GSection CombIx)
-> m (GBranch CombIx) -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GBranch CombIx)
forall (m :: * -> *). MonadGet m => m (GBranch CombIx)
getBranch
    SectionT
NMatchT -> Maybe Reference -> Int -> GBranch CombIx -> GSection CombIx
forall comb.
Maybe Reference -> Int -> GBranch comb -> GSection comb
NMatch (Maybe Reference -> Int -> GBranch CombIx -> GSection CombIx)
-> m (Maybe Reference)
-> m (Int -> GBranch CombIx -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Reference -> m (Maybe Reference)
forall (m :: * -> *) a. MonadGet m => m a -> m (Maybe a)
getMaybe m Reference
forall (m :: * -> *). MonadGet m => m Reference
getReference m (Int -> GBranch CombIx -> GSection CombIx)
-> m Int -> m (GBranch CombIx -> GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (GBranch CombIx -> GSection CombIx)
-> m (GBranch CombIx) -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GBranch CombIx)
forall (m :: * -> *). MonadGet m => m (GBranch CombIx)
getBranch
    SectionT
RMatchT ->
      Int
-> GSection CombIx
-> EnumMap Word64 (GBranch CombIx)
-> GSection CombIx
forall comb.
Int
-> GSection comb -> EnumMap Word64 (GBranch comb) -> GSection comb
RMatch (Int
 -> GSection CombIx
 -> EnumMap Word64 (GBranch CombIx)
 -> GSection CombIx)
-> m Int
-> m (GSection CombIx
      -> EnumMap Word64 (GBranch CombIx) -> GSection CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (GSection CombIx
   -> EnumMap Word64 (GBranch CombIx) -> GSection CombIx)
-> m (GSection CombIx)
-> m (EnumMap Word64 (GBranch CombIx) -> GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection m (EnumMap Word64 (GBranch CombIx) -> GSection CombIx)
-> m (EnumMap Word64 (GBranch CombIx)) -> m (GSection CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Word64
-> m (GBranch CombIx) -> m (EnumMap Word64 (GBranch CombIx))
forall (m :: * -> *) k v.
(MonadGet m, EnumKey k) =>
m k -> m v -> m (EnumMap k v)
getEnumMap m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord m (GBranch CombIx)
forall (m :: * -> *). MonadGet m => m (GBranch CombIx)
getBranch

data InstrT
  = Prim1T
  | Prim2T
  | ForeignCallT
  | SetAffT
  | CaptureT
  | NameT
  | InfoT
  | PackT
  | LitT
  | PrintT
  | ResetT
  | ForkT
  | AtomicallyT
  | SeqT
  | TryForceT
  | RefCAST
  | SandboxingFailureT
  | DiscardT
  | InLocalT

instance Tag InstrT where
  tag2word :: InstrT -> Word8
tag2word InstrT
Prim1T = Word8
0
  tag2word InstrT
Prim2T = Word8
1
  tag2word InstrT
ForeignCallT = Word8
4
  tag2word InstrT
SetAffT = Word8
5
  tag2word InstrT
CaptureT = Word8
6
  tag2word InstrT
NameT = Word8
7
  tag2word InstrT
InfoT = Word8
8
  tag2word InstrT
PackT = Word8
9
  tag2word InstrT
LitT = Word8
10
  tag2word InstrT
PrintT = Word8
11
  tag2word InstrT
ResetT = Word8
12
  tag2word InstrT
ForkT = Word8
13
  tag2word InstrT
AtomicallyT = Word8
14
  tag2word InstrT
SeqT = Word8
15
  tag2word InstrT
TryForceT = Word8
16
  tag2word InstrT
RefCAST = Word8
17
  tag2word InstrT
SandboxingFailureT = Word8
18
  tag2word InstrT
DiscardT = Word8
19
  tag2word InstrT
InLocalT = Word8
20

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m InstrT
word2tag Word8
0 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
Prim1T
  word2tag Word8
1 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
Prim2T
  word2tag Word8
4 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
ForeignCallT
  word2tag Word8
5 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
SetAffT
  word2tag Word8
6 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
CaptureT
  word2tag Word8
7 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
NameT
  word2tag Word8
8 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
InfoT
  word2tag Word8
9 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
PackT
  word2tag Word8
10 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
LitT
  word2tag Word8
11 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
PrintT
  word2tag Word8
12 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
ResetT
  word2tag Word8
13 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
ForkT
  word2tag Word8
14 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
AtomicallyT
  word2tag Word8
15 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
SeqT
  word2tag Word8
16 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
TryForceT
  word2tag Word8
17 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
RefCAST
  word2tag Word8
18 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
SandboxingFailureT
  word2tag Word8
19 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
DiscardT
  word2tag Word8
20 = InstrT -> m InstrT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure InstrT
InLocalT
  word2tag Word8
n = String -> Word8 -> m InstrT
forall (m :: * -> *) a. MonadGet m => String -> Word8 -> m a
unknownTag String
"InstrT" Word8
n

putInstr :: GInstr cix -> Builder
putInstr :: forall cix. GInstr cix -> Builder
putInstr = \case
  (Prim1 Prim1
up Int
i) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
Prim1T Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Prim1 -> Builder
forall t. Tag t => t -> Builder
putTag Prim1
up Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
  (Prim2 Prim2
up Int
i Int
j) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
Prim2T Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Prim2 -> Builder
forall t. Tag t => t -> Builder
putTag Prim2
up Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
j
  (RefCAS Int
i Int
j Int
k) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
RefCAST Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
j Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
k
  (ForeignCall Bool
b ForeignFunc
ff Args
a) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
ForeignCallT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Bool -> Builder
putBool Bool
b Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ForeignFunc -> Builder
putMForeignFunc ForeignFunc
ff Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  (SetAff Bool
u Int
i Int
j) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
SetAffT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Bool -> Builder
pBool Bool
u Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
j
  (Capture Word64
w) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
CaptureT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
w
  (Discard Int
i) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
DiscardT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
  (Name GRef cix
r Args
a) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
NameT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GRef cix -> Builder
forall cix. GRef cix -> Builder
putRef GRef cix
r Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  (Info String
s) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
InfoT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> String -> Builder
putString String
s
  (Pack Reference
r PackedTag
w Args
a) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
PackT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Reference -> Builder
putReference Reference
r Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> PackedTag -> Builder
putPackedTag PackedTag
w Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  (Lit MLit
l) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
LitT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> MLit -> Builder
putLit MLit
l
  (Print Int
i) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
PrintT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
  (Reset EnumSet Word64
s Int
nh Maybe Int
ah) ->
    InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
ResetT
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Word64 -> Builder) -> EnumSet Word64 -> Builder
forall k. EnumKey k => (k -> Builder) -> EnumSet k -> Builder
putEnumSet Word64 -> Builder
pWord EnumSet Word64
s
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
nh
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Maybe Int -> (Int -> Builder) -> Builder
forall a. Maybe a -> (a -> Builder) -> Builder
putMaybe Maybe Int
ah Int -> Builder
pInt
  (Fork Int
i) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
ForkT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
  (Atomically Int
i) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
AtomicallyT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
  (Seq Args
a) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
SeqT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Args -> Builder
putArgs Args
a
  (TryForce Int
i) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
TryForceT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
  (InLocal Int
i) -> InstrT -> Builder
forall t. Tag t => t -> Builder
putTag InstrT
InLocalT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
  (SandboxingFailure {}) ->
    -- Sandboxing failures should only exist in code we're actively running, it shouldn't be serialized.
    String -> Builder
forall a. HasCallStack => String -> a
error String
"putInstr: Unexpected serialized Sandboxing Failure"

getInstr :: (MonadGet m) => m Instr
getInstr :: forall (m :: * -> *). MonadGet m => m (GInstr CombIx)
getInstr =
  m InstrT
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m InstrT -> (InstrT -> m (GInstr CombIx)) -> m (GInstr CombIx)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    InstrT
Prim1T -> Prim1 -> Int -> GInstr CombIx
forall comb. Prim1 -> Int -> GInstr comb
Prim1 (Prim1 -> Int -> GInstr CombIx)
-> m Prim1 -> m (Int -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Prim1
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
Prim2T -> Prim2 -> Int -> Int -> GInstr CombIx
forall comb. Prim2 -> Int -> Int -> GInstr comb
Prim2 (Prim2 -> Int -> Int -> GInstr CombIx)
-> m Prim2 -> m (Int -> Int -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Prim2
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m (Int -> Int -> GInstr CombIx)
-> m Int -> m (Int -> GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
RefCAST -> Int -> Int -> Int -> GInstr CombIx
forall comb. Int -> Int -> Int -> GInstr comb
RefCAS (Int -> Int -> Int -> GInstr CombIx)
-> m Int -> m (Int -> Int -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Int -> Int -> GInstr CombIx)
-> m Int -> m (Int -> GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
ForeignCallT -> Bool -> ForeignFunc -> Args -> GInstr CombIx
forall comb. Bool -> ForeignFunc -> Args -> GInstr comb
ForeignCall (Bool -> ForeignFunc -> Args -> GInstr CombIx)
-> m Bool -> m (ForeignFunc -> Args -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Bool
forall (m :: * -> *). MonadGet m => m Bool
getBool m (ForeignFunc -> Args -> GInstr CombIx)
-> m ForeignFunc -> m (Args -> GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m ForeignFunc
forall (m :: * -> *). MonadGet m => m ForeignFunc
getMForeignFunc m (Args -> GInstr CombIx) -> m Args -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
    InstrT
SetAffT -> Bool -> Int -> Int -> GInstr CombIx
forall comb. Bool -> Int -> Int -> GInstr comb
SetAff (Bool -> Int -> Int -> GInstr CombIx)
-> m Bool -> m (Int -> Int -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Bool
forall (m :: * -> *). MonadGet m => m Bool
gBool m (Int -> Int -> GInstr CombIx)
-> m Int -> m (Int -> GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
CaptureT -> Word64 -> GInstr CombIx
forall comb. Word64 -> GInstr comb
Capture (Word64 -> GInstr CombIx) -> m Word64 -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord
    InstrT
DiscardT -> Int -> GInstr CombIx
forall comb. Int -> GInstr comb
Discard (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
NameT -> GRef CombIx -> Args -> GInstr CombIx
forall comb. GRef comb -> Args -> GInstr comb
Name (GRef CombIx -> Args -> GInstr CombIx)
-> m (GRef CombIx) -> m (Args -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (GRef CombIx)
forall (m :: * -> *). MonadGet m => m (GRef CombIx)
getRef m (Args -> GInstr CombIx) -> m Args -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
    InstrT
InfoT -> String -> GInstr CombIx
forall comb. String -> GInstr comb
Info (String -> GInstr CombIx) -> m String -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m String
forall (m :: * -> *). MonadGet m => m String
getString
    InstrT
PackT -> Reference -> PackedTag -> Args -> GInstr CombIx
forall comb. Reference -> PackedTag -> Args -> GInstr comb
Pack (Reference -> PackedTag -> Args -> GInstr CombIx)
-> m Reference -> m (PackedTag -> Args -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Reference
forall (m :: * -> *). MonadGet m => m Reference
getReference m (PackedTag -> Args -> GInstr CombIx)
-> m PackedTag -> m (Args -> GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m PackedTag
forall (m :: * -> *). MonadGet m => m PackedTag
getPackedTag m (Args -> GInstr CombIx) -> m Args -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
    InstrT
LitT -> MLit -> GInstr CombIx
forall comb. MLit -> GInstr comb
Lit (MLit -> GInstr CombIx) -> m MLit -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m MLit
forall (m :: * -> *). MonadGet m => m MLit
getLit
    InstrT
PrintT -> Int -> GInstr CombIx
forall comb. Int -> GInstr comb
Print (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
ResetT -> EnumSet Word64 -> Int -> Maybe Int -> GInstr CombIx
forall comb. EnumSet Word64 -> Int -> Maybe Int -> GInstr comb
Reset (EnumSet Word64 -> Int -> Maybe Int -> GInstr CombIx)
-> m (EnumSet Word64) -> m (Int -> Maybe Int -> GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word64 -> m (EnumSet Word64)
forall (m :: * -> *) k.
(MonadGet m, EnumKey k) =>
m k -> m (EnumSet k)
getEnumSet m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord m (Int -> Maybe Int -> GInstr CombIx)
-> m Int -> m (Maybe Int -> GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Maybe Int -> GInstr CombIx)
-> m (Maybe Int) -> m (GInstr CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int -> m (Maybe Int)
forall (m :: * -> *) a. MonadGet m => m a -> m (Maybe a)
getMaybe m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
ForkT -> Int -> GInstr CombIx
forall comb. Int -> GInstr comb
Fork (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
AtomicallyT -> Int -> GInstr CombIx
forall comb. Int -> GInstr comb
Atomically (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
SeqT -> Args -> GInstr CombIx
forall comb. Args -> GInstr comb
Seq (Args -> GInstr CombIx) -> m Args -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Args
forall (m :: * -> *). MonadGet m => m Args
getArgs
    InstrT
TryForceT -> Int -> GInstr CombIx
forall comb. Int -> GInstr comb
TryForce (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
InLocalT -> Int -> GInstr CombIx
forall comb. Int -> GInstr comb
InLocal (Int -> GInstr CombIx) -> m Int -> m (GInstr CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    InstrT
SandboxingFailureT -> String -> m (GInstr CombIx)
forall a. HasCallStack => String -> a
error String
"getInstr: Unexpected serialized Sandboxing Failure"

data ArgsT
  = ZArgsT
  | Arg1T
  | Arg2T
  | ArgRT
  | ArgNT
  | ArgVT

instance Tag ArgsT where
  tag2word :: ArgsT -> Word8
tag2word ArgsT
ZArgsT = Word8
0
  tag2word ArgsT
Arg1T = Word8
1
  tag2word ArgsT
Arg2T = Word8
2
  tag2word ArgsT
ArgRT = Word8
3
  tag2word ArgsT
ArgNT = Word8
4
  tag2word ArgsT
ArgVT = Word8
5

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m ArgsT
word2tag Word8
0 = ArgsT -> m ArgsT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ArgsT
ZArgsT
  word2tag Word8
1 = ArgsT -> m ArgsT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ArgsT
Arg1T
  word2tag Word8
2 = ArgsT -> m ArgsT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ArgsT
Arg2T
  word2tag Word8
3 = ArgsT -> m ArgsT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ArgsT
ArgRT
  word2tag Word8
4 = ArgsT -> m ArgsT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ArgsT
ArgNT
  word2tag Word8
5 = ArgsT -> m ArgsT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ArgsT
ArgVT
  word2tag Word8
n = String -> Word8 -> m ArgsT
forall (m :: * -> *) a. MonadGet m => String -> Word8 -> m a
unknownTag String
"ArgsT" Word8
n

putArgs :: Args -> Builder
putArgs :: Args -> Builder
putArgs Args
ZArgs = ArgsT -> Builder
forall t. Tag t => t -> Builder
putTag ArgsT
ZArgsT
putArgs (VArg1 Int
i) = ArgsT -> Builder
forall t. Tag t => t -> Builder
putTag ArgsT
Arg1T Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
putArgs (VArg2 Int
i Int
j) = ArgsT -> Builder
forall t. Tag t => t -> Builder
putTag ArgsT
Arg2T Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
j
putArgs (VArgR Int
i Int
j) = ArgsT -> Builder
forall t. Tag t => t -> Builder
putTag ArgsT
ArgRT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
j
putArgs (VArgN PrimArray Int
pa) = ArgsT -> Builder
forall t. Tag t => t -> Builder
putTag ArgsT
ArgNT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> PrimArray Int -> Builder
putIntArr PrimArray Int
pa
putArgs (VArgV Int
i) = ArgsT -> Builder
forall t. Tag t => t -> Builder
putTag ArgsT
ArgVT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i

getArgs :: (MonadGet m) => m Args
getArgs :: forall (m :: * -> *). MonadGet m => m Args
getArgs =
  m ArgsT
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m ArgsT -> (ArgsT -> m Args) -> m Args
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    ArgsT
ZArgsT -> Args -> m Args
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Args
ZArgs
    ArgsT
Arg1T -> Int -> Args
VArg1 (Int -> Args) -> m Int -> m Args
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    ArgsT
Arg2T -> Int -> Int -> Args
VArg2 (Int -> Int -> Args) -> m Int -> m (Int -> Args)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Int -> Args) -> m Int -> m Args
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    ArgsT
ArgRT -> Int -> Int -> Args
VArgR (Int -> Int -> Args) -> m Int -> m (Int -> Args)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt m (Int -> Args) -> m Int -> m Args
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    ArgsT
ArgNT -> PrimArray Int -> Args
VArgN (PrimArray Int -> Args) -> m (PrimArray Int) -> m Args
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (PrimArray Int)
forall (m :: * -> *). MonadGet m => m (PrimArray Int)
getIntArr
    ArgsT
ArgVT -> Int -> Args
VArgV (Int -> Args) -> m Int -> m Args
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt

data RefT = StkT | EnvT | DynT

instance Tag RefT where
  tag2word :: RefT -> Word8
tag2word RefT
StkT = Word8
0
  tag2word RefT
EnvT = Word8
1
  tag2word RefT
DynT = Word8
2

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m RefT
word2tag Word8
0 = RefT -> m RefT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RefT
StkT
  word2tag Word8
1 = RefT -> m RefT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RefT
EnvT
  word2tag Word8
2 = RefT -> m RefT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure RefT
DynT
  word2tag Word8
n = String -> Word8 -> m RefT
forall (m :: * -> *) a. MonadGet m => String -> Word8 -> m a
unknownTag String
"RefT" Word8
n

putRef :: GRef cix -> Builder
putRef :: forall cix. GRef cix -> Builder
putRef (Stk Int
i) = RefT -> Builder
forall t. Tag t => t -> Builder
putTag RefT
StkT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
putRef (Env CombIx
cix cix
_) = RefT -> Builder
forall t. Tag t => t -> Builder
putTag RefT
EnvT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> CombIx -> Builder
putCombIx CombIx
cix
putRef (Dyn Word64
i) = RefT -> Builder
forall t. Tag t => t -> Builder
putTag RefT
DynT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
i

getRef :: (MonadGet m) => m Ref
getRef :: forall (m :: * -> *). MonadGet m => m (GRef CombIx)
getRef =
  m RefT
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m RefT -> (RefT -> m (GRef CombIx)) -> m (GRef CombIx)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    RefT
StkT -> Int -> GRef CombIx
forall comb. Int -> GRef comb
Stk (Int -> GRef CombIx) -> m Int -> m (GRef CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    RefT
EnvT -> do
      CombIx
cix <- m CombIx
forall (m :: * -> *). MonadGet m => m CombIx
getCombIx
      pure $ CombIx -> CombIx -> GRef CombIx
forall comb. CombIx -> comb -> GRef comb
Env CombIx
cix CombIx
cix
    RefT
DynT -> Word64 -> GRef CombIx
forall comb. Word64 -> GRef comb
Dyn (Word64 -> GRef CombIx) -> m Word64 -> m (GRef CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord

putCombIx :: CombIx -> Builder
putCombIx :: CombIx -> Builder
putCombIx (CIx Reference
r Word64
n Word64
i) = Reference -> Builder
putReference Reference
r Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
n Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
i

getCombIx :: (MonadGet m) => m CombIx
getCombIx :: forall (m :: * -> *). MonadGet m => m CombIx
getCombIx = Reference -> Word64 -> Word64 -> CombIx
CIx (Reference -> Word64 -> Word64 -> CombIx)
-> m Reference -> m (Word64 -> Word64 -> CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Reference
forall (m :: * -> *). MonadGet m => m Reference
getReference m (Word64 -> Word64 -> CombIx) -> m Word64 -> m (Word64 -> CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord m (Word64 -> CombIx) -> m Word64 -> m CombIx
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord

data MLitT = MIT | MNT | MCT | MDT | MTT | MMT | MYT

instance Tag MLitT where
  tag2word :: MLitT -> Word8
tag2word MLitT
MIT = Word8
0
  tag2word MLitT
MNT = Word8
1
  tag2word MLitT
MCT = Word8
2
  tag2word MLitT
MDT = Word8
3
  tag2word MLitT
MTT = Word8
4
  tag2word MLitT
MMT = Word8
5
  tag2word MLitT
MYT = Word8
6

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m MLitT
word2tag Word8
0 = MLitT -> m MLitT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLitT
MIT
  word2tag Word8
1 = MLitT -> m MLitT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLitT
MNT
  word2tag Word8
2 = MLitT -> m MLitT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLitT
MCT
  word2tag Word8
3 = MLitT -> m MLitT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLitT
MDT
  word2tag Word8
4 = MLitT -> m MLitT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLitT
MTT
  word2tag Word8
5 = MLitT -> m MLitT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLitT
MMT
  word2tag Word8
6 = MLitT -> m MLitT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MLitT
MYT
  word2tag Word8
n = String -> Word8 -> m MLitT
forall (m :: * -> *) a. MonadGet m => String -> Word8 -> m a
unknownTag String
"MLitT" Word8
n

putLit :: MLit -> Builder
putLit :: MLit -> Builder
putLit (MI Int
i) = MLitT -> Builder
forall t. Tag t => t -> Builder
putTag MLitT
MIT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
pInt Int
i
putLit (MN Word64
n) = MLitT -> Builder
forall t. Tag t => t -> Builder
putTag MLitT
MNT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
n
putLit (MC Char
c) = MLitT -> Builder
forall t. Tag t => t -> Builder
putTag MLitT
MCT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Char -> Builder
putChar Char
c
putLit (MD Double
d) = MLitT -> Builder
forall t. Tag t => t -> Builder
putTag MLitT
MDT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Double -> Builder
putFloat Double
d
putLit (MT Text
t) = MLitT -> Builder
forall t. Tag t => t -> Builder
putTag MLitT
MTT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Text -> Builder
putText (Text -> Text
Util.Text.toText Text
t)
putLit (MM Referent
r) = MLitT -> Builder
forall t. Tag t => t -> Builder
putTag MLitT
MMT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Referent -> Builder
putReferent Referent
r
putLit (MY Reference
r) = MLitT -> Builder
forall t. Tag t => t -> Builder
putTag MLitT
MYT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Reference -> Builder
putReference Reference
r

getLit :: (MonadGet m) => m MLit
getLit :: forall (m :: * -> *). MonadGet m => m MLit
getLit =
  m MLitT
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m MLitT -> (MLitT -> m MLit) -> m MLit
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    MLitT
MIT -> Int -> MLit
MI (Int -> MLit) -> m Int -> m MLit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *). MonadGet m => m Int
gInt
    MLitT
MNT -> Word64 -> MLit
MN (Word64 -> MLit) -> m Word64 -> m MLit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord
    MLitT
MCT -> Char -> MLit
MC (Char -> MLit) -> m Char -> m MLit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Char
forall (m :: * -> *). MonadGet m => m Char
getChar
    MLitT
MDT -> Double -> MLit
MD (Double -> MLit) -> m Double -> m MLit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Double
forall (m :: * -> *). MonadGet m => m Double
getFloat
    MLitT
MTT -> Text -> MLit
MT (Text -> MLit) -> (Text -> Text) -> Text -> MLit
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Util.Text.fromText (Text -> MLit) -> m Text -> m MLit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). MonadGet m => m Text
getText
    MLitT
MMT -> Referent -> MLit
MM (Referent -> MLit) -> m Referent -> m MLit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Referent
forall (m :: * -> *). MonadGet m => m Referent
getReferent
    MLitT
MYT -> Reference -> MLit
MY (Reference -> MLit) -> m Reference -> m MLit
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Reference
forall (m :: * -> *). MonadGet m => m Reference
getReference

data BranchT = Test1T | Test2T | TestWT | TestTT

instance Tag BranchT where
  tag2word :: BranchT -> Word8
tag2word BranchT
Test1T = Word8
0
  tag2word BranchT
Test2T = Word8
1
  tag2word BranchT
TestWT = Word8
2
  tag2word BranchT
TestTT = Word8
3

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m BranchT
word2tag Word8
0 = BranchT -> m BranchT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BranchT
Test1T
  word2tag Word8
1 = BranchT -> m BranchT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BranchT
Test2T
  word2tag Word8
2 = BranchT -> m BranchT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BranchT
TestWT
  word2tag Word8
3 = BranchT -> m BranchT
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure BranchT
TestTT
  word2tag Word8
n = String -> Word8 -> m BranchT
forall (m :: * -> *) a. MonadGet m => String -> Word8 -> m a
unknownTag String
"BranchT" Word8
n

putBranch :: GBranch cix -> Builder
putBranch :: forall cix. GBranch cix -> Builder
putBranch (Test1 Word64
w GSection cix
s GSection cix
d) =
  BranchT -> Builder
forall t. Tag t => t -> Builder
putTag BranchT
Test1T Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
w Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
s Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
d
putBranch (Test2 Word64
a GSection cix
sa Word64
b GSection cix
sb GSection cix
d) =
  BranchT -> Builder
forall t. Tag t => t -> Builder
putTag BranchT
Test2T
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
a
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
sa
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Word64 -> Builder
pWord Word64
b
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
sb
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
d
putBranch (TestW GSection cix
d EnumMap Word64 (GSection cix)
m) =
  BranchT -> Builder
forall t. Tag t => t -> Builder
putTag BranchT
TestWT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
d Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Word64 -> Builder)
-> (GSection cix -> Builder)
-> EnumMap Word64 (GSection cix)
-> Builder
forall k v.
EnumKey k =>
(k -> Builder) -> (v -> Builder) -> EnumMap k v -> Builder
putEnumMap Word64 -> Builder
pWord GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection EnumMap Word64 (GSection cix)
m
putBranch (TestT GSection cix
d Map Text (GSection cix)
m) =
  BranchT -> Builder
forall t. Tag t => t -> Builder
putTag BranchT
TestTT Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection GSection cix
d Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (Text -> Builder)
-> (GSection cix -> Builder) -> Map Text (GSection cix) -> Builder
forall a b. (a -> Builder) -> (b -> Builder) -> Map a b -> Builder
putMap (Text -> Builder
putText (Text -> Builder) -> (Text -> Text) -> Text -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
Util.Text.toText) GSection cix -> Builder
forall cix. GSection cix -> Builder
putSection Map Text (GSection cix)
m

getBranch :: (MonadGet m) => m Branch
getBranch :: forall (m :: * -> *). MonadGet m => m (GBranch CombIx)
getBranch =
  m BranchT
forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag m BranchT -> (BranchT -> m (GBranch CombIx)) -> m (GBranch CombIx)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    BranchT
Test1T -> Word64 -> GSection CombIx -> GSection CombIx -> GBranch CombIx
forall comb.
Word64 -> GSection comb -> GSection comb -> GBranch comb
Test1 (Word64 -> GSection CombIx -> GSection CombIx -> GBranch CombIx)
-> m Word64
-> m (GSection CombIx -> GSection CombIx -> GBranch CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord m (GSection CombIx -> GSection CombIx -> GBranch CombIx)
-> m (GSection CombIx) -> m (GSection CombIx -> GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection m (GSection CombIx -> GBranch CombIx)
-> m (GSection CombIx) -> m (GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
    BranchT
Test2T ->
      Word64
-> GSection CombIx
-> Word64
-> GSection CombIx
-> GSection CombIx
-> GBranch CombIx
forall comb.
Word64
-> GSection comb
-> Word64
-> GSection comb
-> GSection comb
-> GBranch comb
Test2
        (Word64
 -> GSection CombIx
 -> Word64
 -> GSection CombIx
 -> GSection CombIx
 -> GBranch CombIx)
-> m Word64
-> m (GSection CombIx
      -> Word64 -> GSection CombIx -> GSection CombIx -> GBranch CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord
        m (GSection CombIx
   -> Word64 -> GSection CombIx -> GSection CombIx -> GBranch CombIx)
-> m (GSection CombIx)
-> m (Word64
      -> GSection CombIx -> GSection CombIx -> GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
        m (Word64 -> GSection CombIx -> GSection CombIx -> GBranch CombIx)
-> m Word64
-> m (GSection CombIx -> GSection CombIx -> GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord
        m (GSection CombIx -> GSection CombIx -> GBranch CombIx)
-> m (GSection CombIx) -> m (GSection CombIx -> GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
        m (GSection CombIx -> GBranch CombIx)
-> m (GSection CombIx) -> m (GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
    BranchT
TestWT -> GSection CombIx
-> EnumMap Word64 (GSection CombIx) -> GBranch CombIx
forall comb.
GSection comb -> EnumMap Word64 (GSection comb) -> GBranch comb
TestW (GSection CombIx
 -> EnumMap Word64 (GSection CombIx) -> GBranch CombIx)
-> m (GSection CombIx)
-> m (EnumMap Word64 (GSection CombIx) -> GBranch CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection m (EnumMap Word64 (GSection CombIx) -> GBranch CombIx)
-> m (EnumMap Word64 (GSection CombIx)) -> m (GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Word64
-> m (GSection CombIx) -> m (EnumMap Word64 (GSection CombIx))
forall (m :: * -> *) k v.
(MonadGet m, EnumKey k) =>
m k -> m v -> m (EnumMap k v)
getEnumMap m Word64
forall (m :: * -> *). MonadGet m => m Word64
gWord m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection
    BranchT
TestTT -> GSection CombIx -> Map Text (GSection CombIx) -> GBranch CombIx
forall comb.
GSection comb -> Map Text (GSection comb) -> GBranch comb
TestT (GSection CombIx -> Map Text (GSection CombIx) -> GBranch CombIx)
-> m (GSection CombIx)
-> m (Map Text (GSection CombIx) -> GBranch CombIx)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection m (Map Text (GSection CombIx) -> GBranch CombIx)
-> m (Map Text (GSection CombIx)) -> m (GBranch CombIx)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Text -> m (GSection CombIx) -> m (Map Text (GSection CombIx))
forall (m :: * -> *) a b.
(MonadGet m, Ord a) =>
m a -> m b -> m (Map a b)
getMap (Text -> Text
Util.Text.fromText (Text -> Text) -> m Text -> m Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). MonadGet m => m Text
getText) m (GSection CombIx)
forall (m :: * -> *). MonadGet m => m (GSection CombIx)
getSection

gInt :: (MonadGet m) => m Int
gInt :: forall (m :: * -> *). MonadGet m => m Int
gInt = VarInt Int -> Int
forall n. VarInt n -> n
unVarInt (VarInt Int -> Int) -> m (VarInt Int) -> m Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (VarInt Int)
forall a (m :: * -> *). (Serial a, MonadGet m) => m a
forall (m :: * -> *). MonadGet m => m (VarInt Int)
deserialize

pInt :: Int -> Builder
pInt :: Int -> Builder
pInt Int
i = Int -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt Int
i

gBool :: (MonadGet m) => m Bool
gBool :: forall (m :: * -> *). MonadGet m => m Bool
gBool =
  m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8 m Word8 -> (Word8 -> m Bool) -> m Bool
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Word8
0 -> Bool -> m Bool
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
    Word8
1 -> Bool -> m Bool
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
    Word8
n -> String -> m Bool
forall a. String -> m a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail (String -> m Bool) -> String -> m Bool
forall a b. (a -> b) -> a -> b
$ String
"bad byte `" String -> String -> String
forall a. [a] -> [a] -> [a]
++ Word8 -> String
forall a. Show a => a -> String
show Word8
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"` while deserializing Bool"

pBool :: Bool -> Builder
pBool :: Bool -> Builder
pBool Bool
False = Word8 -> Builder
BU.word8 Word8
0
pBool Bool
True = Word8 -> Builder
BU.word8 Word8
1

gWord :: (MonadGet m) => m Word64
gWord :: forall (m :: * -> *). MonadGet m => m Word64
gWord = VarInt Word64 -> Word64
forall n. VarInt n -> n
unVarInt (VarInt Word64 -> Word64) -> m (VarInt Word64) -> m Word64
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (VarInt Word64)
forall a (m :: * -> *). (Serial a, MonadGet m) => m a
forall (m :: * -> *). MonadGet m => m (VarInt Word64)
deserialize

pWord :: Word64 -> Builder
pWord :: Word64 -> Builder
pWord Word64
w = Word64 -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt Word64
w

putIntArr :: PrimArray Int -> Builder
putIntArr :: PrimArray Int -> Builder
putIntArr PrimArray Int
pa = (Int -> Builder) -> [Int] -> Builder
forall (f :: * -> *) a.
Foldable f =>
(a -> Builder) -> f a -> Builder
putFoldable Int -> Builder
pInt ([Int] -> Builder) -> [Int] -> Builder
forall a b. (a -> b) -> a -> b
$ PrimArray Int -> [Item (PrimArray Int)]
forall l. IsList l => l -> [Item l]
toList PrimArray Int
pa

getIntArr :: (MonadGet m) => m (PrimArray Int)
getIntArr :: forall (m :: * -> *). MonadGet m => m (PrimArray Int)
getIntArr = [Int] -> PrimArray Int
[Item (PrimArray Int)] -> PrimArray Int
forall l. IsList l => [Item l] -> l
fromList ([Int] -> PrimArray Int) -> m [Int] -> m (PrimArray Int)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int -> m [Int]
forall (m :: * -> *) a. MonadGet m => m a -> m [a]
getList m Int
forall (m :: * -> *). MonadGet m => m Int
gInt