{-# LANGUAGE PatternSynonyms #-}

module Unison.Runtime.Serialize where

import Control.Monad (replicateM)
import Data.Bits (Bits, clearBit, setBit, shiftL, shiftR, testBit, (.|.))
import Data.ByteString qualified as B
import Data.ByteString.Builder (Builder)
import Data.ByteString.Builder qualified as BU
import Data.Bytes.Get hiding (getBytes)
import Data.Bytes.Get qualified as Ser
import Data.Bytes.Serial
import Data.Bytes.Signed (Unsigned, unsigned)
import Data.Int (Int64)
import Data.Map.Strict as Map (Map, fromList, toList)
import Data.Primitive.Array
  ( Array,
    indexArray,
    sizeofArray,
  )
import Data.Sequence (Seq, (|>))
import Data.Text (Text)
import Data.Text.Encoding (decodeUtf8, encodeUtf8)
import Data.Vector.Primitive qualified as BA
import Data.Word (Word64, Word8)
import Unison.ConstructorReference (ConstructorReference, GConstructorReference (..))
import Unison.ConstructorType qualified as CT
import Unison.Hash (Hash)
import Unison.Hash qualified as Hash
import Unison.Reference (Id' (..), Reference, Reference' (Builtin, DerivedId), pattern Derived)
import Unison.Referent (Referent, pattern Con, pattern Ref)
import Unison.ReferentPrime (Referent' (..))
import Unison.Runtime.Array qualified as PA
import Unison.Runtime.Canonicalizer
import Unison.Runtime.Exception (exn)
import Unison.Runtime.MCode
  ( Prim1 (..),
    Prim2 (..),
  )
import Unison.Runtime.Referenced (RefNum (..))
import Unison.Util.Bytes qualified as Bytes
import Unison.Util.EnumContainers as EC

unknownTag :: (MonadGet m) => String -> Word8 -> m a
unknownTag :: forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
t Word8
w =
  m (Remaining m)
forall (m :: * -> *). MonadGet m => m (Remaining m)
remaining m (Remaining m) -> (Remaining m -> m a) -> m a
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Remaining m
r ->
    [Word] -> [Char] -> m a
forall a. HasCallStack => [Word] -> [Char] -> a
exn [] ([Char] -> m a) -> [Char] -> m a
forall a b. (a -> b) -> a -> b
$
      [Char]
"unknown "
        [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
t
        [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" word: "
        [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Word8 -> [Char]
forall a. Show a => a -> [Char]
show Word8
w
        [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" ("
        [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show (forall a b. (Integral a, Num b) => a -> b
fromIntegral @_ @Int Remaining m
r)
        [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
" bytes remaining)"

class Tag t where
  tag2word :: t -> Word8
  word2tag :: (MonadGet m) => Word8 -> m t

putTag :: (Tag t) => t -> Builder
putTag :: forall t. Tag t => t -> Builder
putTag = Word8 -> Builder
BU.word8 (Word8 -> Builder) -> (t -> Word8) -> t -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. t -> Word8
forall t. Tag t => t -> Word8
tag2word
{-# INLINE putTag #-}

getTag :: (MonadGet m) => (Tag t) => m t
getTag :: forall (m :: * -> *) t. (MonadGet m, Tag t) => m t
getTag = Word8 -> m t
forall t (m :: * -> *). (Tag t, MonadGet m) => Word8 -> m t
forall (m :: * -> *). MonadGet m => Word8 -> m t
word2tag (Word8 -> m t) -> m Word8 -> m t
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8
{-# INLINE getTag #-}

getVarInt :: (MonadGet m, Num b, Bits b) => m b
getVarInt :: forall (m :: * -> *) b. (MonadGet m, Num b, Bits b) => m b
getVarInt = m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8 m Word8 -> (Word8 -> m b) -> m b
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word8 -> m b
forall {f :: * -> *} {b}.
(MonadGet f, Bits b, Num b) =>
Word8 -> f b
go
  where
    go :: Word8 -> f b
go Word8
n
      | Word8 -> Int -> Bool
forall a. Bits a => a -> Int -> Bool
testBit Word8
n Int
7 = do
          b
m <- f Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8 f Word8 -> (Word8 -> f b) -> f b
forall a b. f a -> (a -> f b) -> f b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word8 -> f b
go
          return $ b -> Int -> b
forall a. Bits a => a -> Int -> a
shiftL b
m Int
7 b -> b -> b
forall a. Bits a => a -> a -> a
.|. b -> Int -> b
forall a. Bits a => a -> Int -> a
clearBit (Word8 -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
n) Int
7
      | Bool
otherwise = b -> f b
forall a. a -> f a
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> f b) -> b -> f b
forall a b. (a -> b) -> a -> b
$ Word8 -> b
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
n
{-# INLINE getVarInt #-}

putVarInt ::
  (Integral a, Integral (Unsigned a), Bits (Unsigned a)) => a -> Builder
putVarInt :: forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt = Unsigned a -> Builder
forall {t}. (Integral t, Bits t) => t -> Builder
go (Unsigned a -> Builder) -> (a -> Unsigned a) -> a -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Unsigned a
forall i. (Integral i, Num (Unsigned i)) => i -> Unsigned i
unsigned
  where
    go :: t -> Builder
go t
n
      | t
n t -> t -> Bool
forall a. Ord a => a -> a -> Bool
< t
0x80 = Word8 -> Builder
BU.word8 (Word8 -> Builder) -> Word8 -> Builder
forall a b. (a -> b) -> a -> b
$ t -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral t
n
      | Bool
otherwise =
          Word8 -> Builder
BU.word8 (Word8 -> Int -> Word8
forall a. Bits a => a -> Int -> a
setBit (t -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral t
n) Int
7)
            Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> t -> Builder
go (t -> Int -> t
forall a. Bits a => a -> Int -> a
shiftR t
n Int
7)
{-# INLINE putVarInt #-}

-- Some basics, moved over from V1 serialization
putChar :: Char -> Builder
putChar :: Char -> Builder
putChar = Int -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt (Int -> Builder) -> (Char -> Int) -> Char -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum

getChar :: (MonadGet m) => m Char
getChar :: forall (m :: * -> *). MonadGet m => m Char
getChar = Int -> Char
forall a. Enum a => Int -> a
toEnum (Int -> Char) -> m Int -> m Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *) b. (MonadGet m, Num b, Bits b) => m b
getVarInt

putFloat :: Double -> Builder
putFloat :: Double -> Builder
putFloat = Double -> Builder
BU.doubleBE

getFloat :: (MonadGet m) => m Double
getFloat :: forall (m :: * -> *). MonadGet m => m Double
getFloat = m Double
forall a (m :: * -> *). (SerialEndian a, MonadGet m) => m a
forall (m :: * -> *). MonadGet m => m Double
deserializeBE

putBool :: Bool -> Builder
putBool :: Bool -> Builder
putBool Bool
b = Word8 -> Builder
BU.word8 (if Bool
b then Word8
1 else Word8
0)

getBool :: (MonadGet m) => m Bool
getBool :: forall (m :: * -> *). MonadGet m => m Bool
getBool = Word8 -> m Bool
forall {a} {f :: * -> *}.
(Eq a, Num a, Applicative f, Show a) =>
a -> f Bool
d (Word8 -> m Bool) -> m Word8 -> m Bool
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8
  where
    d :: a -> f Bool
d a
0 = Bool -> f Bool
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
False
    d a
1 = Bool -> f Bool
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
True
    d a
n = [Word] -> [Char] -> f Bool
forall a. HasCallStack => [Word] -> [Char] -> a
exn [] ([Char] -> f Bool) -> [Char] -> f Bool
forall a b. (a -> b) -> a -> b
$ [Char]
"getBool: bad tag: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ a -> [Char]
forall a. Show a => a -> [Char]
show a
n

putNat :: Word64 -> Builder
putNat :: Pos -> Builder
putNat = Pos -> Builder
BU.word64BE

getNat :: (MonadGet m) => m Word64
getNat :: forall (m :: * -> *). MonadGet m => m Pos
getNat = m Pos
forall (m :: * -> *). MonadGet m => m Pos
getWord64be

putInt :: Int64 -> Builder
putInt :: Int64 -> Builder
putInt = Int64 -> Builder
BU.int64BE

getInt :: (MonadGet m) => m Int64
getInt :: forall (m :: * -> *). MonadGet m => m Int64
getInt = m Int64
forall a (m :: * -> *). (SerialEndian a, MonadGet m) => m a
forall (m :: * -> *). MonadGet m => m Int64
deserializeBE

putLength ::
  ( Integral n,
    Integral (Unsigned n),
    Bits n,
    Bits (Unsigned n)
  ) =>
  n ->
  Builder
putLength :: forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength = n -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt
{-# INLINE putLength #-}

getLength ::
  ( MonadGet m,
    Integral n,
    Integral (Unsigned n),
    Bits n,
    Bits (Unsigned n)
  ) =>
  m n
getLength :: forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength = m n
forall (m :: * -> *) b. (MonadGet m, Num b, Bits b) => m b
getVarInt
{-# INLINE getLength #-}

-- Checks for negatives, in case you put an Integer, which does not
-- behave properly for negative numbers.
putPositive ::
  (Bits n, Bits (Unsigned n), Integral n, Integral (Unsigned n)) =>
  n ->
  Builder
putPositive :: forall n.
(Bits n, Bits (Unsigned n), Integral n, Integral (Unsigned n)) =>
n -> Builder
putPositive n
n
  | n
n n -> n -> Bool
forall a. Ord a => a -> a -> Bool
< n
0 = [Word] -> [Char] -> Builder
forall a. HasCallStack => [Word] -> [Char] -> a
exn [] ([Char] -> Builder) -> [Char] -> Builder
forall a b. (a -> b) -> a -> b
$ [Char]
"putPositive: negative number: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Integer -> [Char]
forall a. Show a => a -> [Char]
show (n -> Integer
forall a. Integral a => a -> Integer
toInteger n
n)
  | Bool
otherwise = n -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt n
n
{-# INLINE putPositive #-}

-- Reads as an Integer, then checks that the result will fit in the
-- result type.
getPositive :: forall m n. (Bounded n, Integral n, MonadGet m) => m n
getPositive :: forall (m :: * -> *) n. (Bounded n, Integral n, MonadGet m) => m n
getPositive = Integer -> m n
validate (Integer -> m n) -> m Integer -> m n
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< m Integer
forall (m :: * -> *) b. (MonadGet m, Num b, Bits b) => m b
getVarInt
  where
    mx0 :: n
    mx0 :: n
mx0 = n
forall a. Bounded a => a
maxBound
    mx :: Integer
    mx :: Integer
mx = n -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral n
mx0

    validate :: Integer -> m n
    validate :: Integer -> m n
validate Integer
n
      | Integer
n Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Integer
mx = n -> m n
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (n -> m n) -> n -> m n
forall a b. (a -> b) -> a -> b
$ Integer -> n
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
n
      | Bool
otherwise = [Char] -> m n
forall a. [Char] -> m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail ([Char] -> m n) -> [Char] -> m n
forall a b. (a -> b) -> a -> b
$ [Char]
"getPositive: overflow: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Integer -> [Char]
forall a. Show a => a -> [Char]
show Integer
n
{-# INLINE getPositive #-}

putFoldable ::
  (Foldable f) => (a -> Builder) -> f a -> Builder
putFoldable :: forall (f :: * -> *) a.
Foldable f =>
(a -> Builder) -> f a -> Builder
putFoldable a -> Builder
putA f a
as =
  Int -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength (f a -> Int
forall a. f a -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length f a
as) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (a -> Builder -> Builder) -> Builder -> f a -> Builder
forall a b. (a -> b -> b) -> b -> f a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (\a
x Builder
b -> a -> Builder
putA a
x Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
b) Builder
forall a. Monoid a => a
mempty f a
as
{-# INLINE putFoldable #-}

putMap :: (a -> Builder) -> (b -> Builder) -> Map a b -> Builder
putMap :: forall a b. (a -> Builder) -> (b -> Builder) -> Map a b -> Builder
putMap a -> Builder
putA b -> Builder
putB Map a b
m = (a -> Builder) -> (b -> Builder) -> [(a, b)] -> Builder
forall a b. (a -> Builder) -> (b -> Builder) -> [(a, b)] -> Builder
putMapping a -> Builder
putA b -> Builder
putB ([(a, b)] -> Builder) -> [(a, b)] -> Builder
forall a b. (a -> b) -> a -> b
$ Map a b -> [(a, b)]
forall k a. Map k a -> [(k, a)]
Map.toList Map a b
m

getList :: (MonadGet m) => m a -> m [a]
getList :: forall (m :: * -> *) a. MonadGet m => m a -> m [a]
getList m a
a = m Int
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength m Int -> (Int -> m [a]) -> m [a]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> m a -> m [a]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
`replicateM` m a
a)
{-# INLINE getList #-}

getSeq :: (MonadGet m) => m a -> m (Seq a)
getSeq :: forall (m :: * -> *) a. MonadGet m => m a -> m (Seq a)
getSeq m a
a = m Int
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength m Int -> (Int -> m (Seq a)) -> m (Seq a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Seq a -> Int -> m (Seq a)
pull Seq a
forall a. Monoid a => a
mempty
  where
    pull :: Seq a -> Int -> m (Seq a)
pull !Seq a
acc (Int
n :: Int)
      | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = Seq a -> m (Seq a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Seq a
acc
      | Bool
otherwise = m a
a m a -> (a -> m (Seq a)) -> m (Seq a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> Seq a -> Int -> m (Seq a)
pull (Seq a
acc Seq a -> a -> Seq a
forall a. Seq a -> a -> Seq a
|> a
x) (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
{-# INLINE getSeq #-}

getMap :: (MonadGet m, Ord a) => m a -> m b -> m (Map a b)
getMap :: forall (m :: * -> *) a b.
(MonadGet m, Ord a) =>
m a -> m b -> m (Map a b)
getMap m a
getA m b
getB = [(a, b)] -> Map a b
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(a, b)] -> Map a b) -> m [(a, b)] -> m (Map a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a -> m b -> m [(a, b)]
forall (m :: * -> *) a b. MonadGet m => m a -> m b -> m [(a, b)]
getMapping m a
getA m b
getB

putMapping :: (a -> Builder) -> (b -> Builder) -> [(a, b)] -> Builder
putMapping :: forall a b. (a -> Builder) -> (b -> Builder) -> [(a, b)] -> Builder
putMapping a -> Builder
putA b -> Builder
putB = ((a, b) -> Builder) -> [(a, b)] -> Builder
forall (f :: * -> *) a.
Foldable f =>
(a -> Builder) -> f a -> Builder
putFoldable ((a -> Builder) -> (b -> Builder) -> (a, b) -> Builder
forall a b. (a -> Builder) -> (b -> Builder) -> (a, b) -> Builder
putPair a -> Builder
putA b -> Builder
putB)
{-# INLINE putMapping #-}

getMapping :: (MonadGet m) => m a -> m b -> m [(a, b)]
getMapping :: forall (m :: * -> *) a b. MonadGet m => m a -> m b -> m [(a, b)]
getMapping m a
getA m b
getB = m Int
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength m Int -> (Int -> m [(a, b)]) -> m [(a, b)]
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Int -> m (a, b) -> m [(a, b)]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
`replicateM` m a -> m b -> m (a, b)
forall (m :: * -> *) a b. MonadGet m => m a -> m b -> m (a, b)
getPair m a
getA m b
getB)
{-# INLINE getMapping #-}

putEnumMap ::
  (EnumKey k) =>
  (k -> Builder) ->
  (v -> Builder) ->
  EnumMap k v ->
  Builder
putEnumMap :: forall k v.
EnumKey k =>
(k -> Builder) -> (v -> Builder) -> EnumMap k v -> Builder
putEnumMap k -> Builder
pk v -> Builder
pv EnumMap k v
m = ((k, v) -> Builder) -> [(k, v)] -> Builder
forall (f :: * -> *) a.
Foldable f =>
(a -> Builder) -> f a -> Builder
putFoldable ((k -> Builder) -> (v -> Builder) -> (k, v) -> Builder
forall a b. (a -> Builder) -> (b -> Builder) -> (a, b) -> Builder
putPair k -> Builder
pk v -> Builder
pv) (EnumMap k v -> [(k, v)]
forall k a. EnumKey k => EnumMap k a -> [(k, a)]
mapToList EnumMap k v
m)

getEnumMap :: (MonadGet m) => (EnumKey k) => m k -> m v -> m (EnumMap k v)
getEnumMap :: forall (m :: * -> *) k v.
(MonadGet m, EnumKey k) =>
m k -> m v -> m (EnumMap k v)
getEnumMap m k
gk m v
gv = [(k, v)] -> EnumMap k v
forall k a. EnumKey k => [(k, a)] -> EnumMap k a
mapFromList ([(k, v)] -> EnumMap k v) -> m [(k, v)] -> m (EnumMap k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (k, v) -> m [(k, v)]
forall (m :: * -> *) a. MonadGet m => m a -> m [a]
getList (m k -> m v -> m (k, v)
forall (m :: * -> *) a b. MonadGet m => m a -> m b -> m (a, b)
getPair m k
gk m v
gv)

putEnumSet :: (EnumKey k) => (k -> Builder) -> EnumSet k -> Builder
putEnumSet :: forall k. EnumKey k => (k -> Builder) -> EnumSet k -> Builder
putEnumSet k -> Builder
pk EnumSet k
s =
  Int -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength (EnumSet k -> Int
forall k. EnumSet k -> Int
setSize EnumSet k
s) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> (k -> Builder -> Builder) -> Builder -> EnumSet k -> Builder
forall k r. EnumKey k => (k -> r -> r) -> r -> EnumSet k -> r
foldrSet (\k
k Builder
b -> k -> Builder
pk k
k Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Builder
b) Builder
forall a. Monoid a => a
mempty EnumSet k
s

getEnumSet :: (MonadGet m) => (EnumKey k) => m k -> m (EnumSet k)
getEnumSet :: forall (m :: * -> *) k.
(MonadGet m, EnumKey k) =>
m k -> m (EnumSet k)
getEnumSet m k
gk = [k] -> EnumSet k
forall k. EnumKey k => [k] -> EnumSet k
setFromList ([k] -> EnumSet k) -> m [k] -> m (EnumSet k)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m k -> m [k]
forall (m :: * -> *) a. MonadGet m => m a -> m [a]
getList m k
gk

putMaybe :: Maybe a -> (a -> Builder) -> Builder
putMaybe :: forall a. Maybe a -> (a -> Builder) -> Builder
putMaybe Maybe a
Nothing a -> Builder
_ = Word8 -> Builder
BU.word8 Word8
0
putMaybe (Just a
a) a -> Builder
putA = Word8 -> Builder
BU.word8 Word8
1 Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> a -> Builder
putA a
a

getMaybe :: (MonadGet m) => m a -> m (Maybe a)
getMaybe :: forall (m :: * -> *) a. MonadGet m => m a -> m (Maybe a)
getMaybe m a
getA =
  m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8 m Word8 -> (Word8 -> m (Maybe a)) -> m (Maybe a)
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Word8
tag -> case Word8
tag of
    Word8
0 -> Maybe a -> m (Maybe a)
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing
    Word8
1 -> a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> m a -> m (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
getA
    Word8
_ -> [Char] -> Word8 -> m (Maybe a)
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"Maybe" Word8
tag

putPair :: (a -> Builder) -> (b -> Builder) -> (a, b) -> Builder
putPair :: forall a b. (a -> Builder) -> (b -> Builder) -> (a, b) -> Builder
putPair a -> Builder
putA b -> Builder
putB (a
a, b
b) = a -> Builder
putA a
a Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> b -> Builder
putB b
b
{-# INLINE putPair #-}

getPair :: (MonadGet m) => m a -> m b -> m (a, b)
getPair :: forall (m :: * -> *) a b. MonadGet m => m a -> m b -> m (a, b)
getPair = (a -> b -> (a, b)) -> m a -> m b -> m (a, b)
forall a b c. (a -> b -> c) -> m a -> m b -> m c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (,)

getBytes :: (MonadGet m) => m Bytes.Bytes
getBytes :: forall (m :: * -> *). MonadGet m => m Bytes
getBytes = [Chunk] -> Bytes
Bytes.fromChunks ([Chunk] -> Bytes) -> m [Chunk] -> m Bytes
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Chunk -> m [Chunk]
forall (m :: * -> *) a. MonadGet m => m a -> m [a]
getList m Chunk
forall (m :: * -> *). MonadGet m => m Chunk
getBlock

putBytes :: Bytes.Bytes -> Builder
putBytes :: Bytes -> Builder
putBytes = (Chunk -> Builder) -> [Chunk] -> Builder
forall (f :: * -> *) a.
Foldable f =>
(a -> Builder) -> f a -> Builder
putFoldable Chunk -> Builder
putBlock ([Chunk] -> Builder) -> (Bytes -> [Chunk]) -> Bytes -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bytes -> [Chunk]
Bytes.chunks

getByteArray :: (MonadGet m) => m PA.ByteArray
getByteArray :: forall (m :: * -> *). MonadGet m => m ByteArray
getByteArray = [Word8] -> ByteArray
forall a. Prim a => [a] -> ByteArray
PA.byteArrayFromList ([Word8] -> ByteArray) -> m [Word8] -> m ByteArray
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Word8 -> m [Word8]
forall (m :: * -> *) a. MonadGet m => m a -> m [a]
getList m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8

putByteArray :: PA.ByteArray -> Builder
putByteArray :: ByteArray -> Builder
putByteArray ByteArray
a =
  Int -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength (ByteArray -> Int
PA.sizeofByteArray ByteArray
a)
    Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ShortByteString -> Builder
BU.shortByteString (ByteArray -> ShortByteString
PA.byteArrayToShortByteString ByteArray
a)

getArray :: (MonadGet m) => m a -> m (PA.Array a)
getArray :: forall (m :: * -> *) a. MonadGet m => m a -> m (Array a)
getArray m a
a = do
  Int
sz <- m Int
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength
  Int -> [a] -> Array a
forall a. Int -> [a] -> Array a
PA.arrayFromListN Int
sz ([a] -> Array a) -> m [a] -> m (Array a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> m a -> m [a]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
sz m a
a

putArray :: (a -> Builder) -> PA.Array a -> Builder
putArray :: forall a. (a -> Builder) -> Array a -> Builder
putArray a -> Builder
putThing Array a
a = Int -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength Int
sz Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
go Int
0
  where
    sz :: Int
sz = Array a -> Int
forall a. Array a -> Int
sizeofArray Array a
a
    go :: Int -> Builder
go Int
i
      | Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Int
sz = a -> Builder
putThing (Array a -> Int -> a
forall a. Array a -> Int -> a
indexArray Array a
a Int
i) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Int -> Builder
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
      | Bool
otherwise = Builder
forall a. Monoid a => a
mempty
{-# INLINE putArray #-}

getBlock :: (MonadGet m) => m Bytes.Chunk
getBlock :: forall (m :: * -> *). MonadGet m => m Chunk
getBlock = m Int
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength m Int -> (Int -> m Chunk) -> m Chunk
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ByteString -> Chunk) -> m ByteString -> m Chunk
forall a b. (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ByteString -> Chunk
Bytes.byteStringToChunk (m ByteString -> m Chunk)
-> (Int -> m ByteString) -> Int -> m Chunk
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> m ByteString
forall (m :: * -> *). MonadGet m => Int -> m ByteString
getByteString

putBlock :: Bytes.Chunk -> Builder
putBlock :: Chunk -> Builder
putBlock Chunk
b = Int -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength (Chunk -> Int
forall a. Prim a => Vector a -> Int
BA.length Chunk
b) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ByteString -> Builder
BU.byteString (Chunk -> ByteString
Bytes.chunkToByteString Chunk
b)

putHash :: Hash -> Builder
putHash :: Hash -> Builder
putHash Hash
h = Int -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength (ByteString -> Int
B.length ByteString
bs) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ByteString -> Builder
BU.byteString ByteString
bs
  where
    bs :: ByteString
bs = Hash -> ByteString
Hash.toByteString Hash
h
{-# INLINE putHash #-}

getHash :: (MonadGet m) => m Hash
getHash :: forall (m :: * -> *). MonadGet m => m Hash
getHash = do
  Int
len <- m Int
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength
  ByteString
bs <- Int -> m ByteString
forall (m :: * -> *). MonadGet m => Int -> m ByteString
Ser.getBytes Int
len
  pure $ ByteString -> Hash
Hash.fromByteString ByteString
bs
{-# INLINE getHash #-}

putReferent :: Referent -> Builder
putReferent :: Referent -> Builder
putReferent = \case
  Ref Reference
r ->
    Word8 -> Builder
BU.word8 Word8
0
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Reference -> Builder
putReference Reference
r
  Con ConstructorReference
r ConstructorType
ct ->
    Word8 -> Builder
BU.word8 Word8
1
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ConstructorReference -> Builder
putConstructorReference ConstructorReference
r
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ConstructorType -> Builder
putConstructorType ConstructorType
ct

getReferent :: (MonadGet m) => m Referent
getReferent :: forall (m :: * -> *). MonadGet m => m Referent
getReferent = do
  Word8
tag <- m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8
  case Word8
tag of
    Word8
0 -> Reference -> Referent
Ref (Reference -> Referent) -> m Reference -> m Referent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Reference
forall (m :: * -> *). MonadGet m => m Reference
getReference
    Word8
1 -> ConstructorReference -> ConstructorType -> Referent
Con (ConstructorReference -> ConstructorType -> Referent)
-> m ConstructorReference -> m (ConstructorType -> Referent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m ConstructorReference
forall (m :: * -> *). MonadGet m => m ConstructorReference
getConstructorReference m (ConstructorType -> Referent) -> m ConstructorType -> m Referent
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m ConstructorType
forall (m :: * -> *). MonadGet m => m ConstructorType
getConstructorType
    Word8
_ -> [Char] -> Word8 -> m Referent
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"getReferent" Word8
tag

-- Arguments for getting/putting references by numbering rather than
-- inline. For getting, the format is numbered, so we just need an
-- array of references. For putting, the assumption is that every
-- `Reference` has been resolved to a unique object in memory, so that
-- we can look them up by stable name.
type GetRefLookup = (Array Reference, Array Reference)

type PutRefLookup = (CanonMap Reference Int, CanonMap Reference Int)

putReferentByNumber :: PutRefLookup -> Referent -> Builder
putReferentByNumber :: PutRefLookup -> Referent -> Builder
putReferentByNumber (CanonMap Reference Int
tys, CanonMap Reference Int
tms) = \case
  Ref Reference
r ->
    Word8 -> Builder
BU.word8 Word8
0
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> CanonMap Reference Int -> Reference -> Builder
putReferenceByNumber CanonMap Reference Int
tms Reference
r
  Con ConstructorReference
r ConstructorType
ct ->
    Word8 -> Builder
BU.word8 Word8
1
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> CanonMap Reference Int -> ConstructorReference -> Builder
putConstructorReferenceByNumber CanonMap Reference Int
tys ConstructorReference
r
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ConstructorType -> Builder
putConstructorType ConstructorType
ct

putNumberedReferent :: Referent' RefNum -> Builder
putNumberedReferent :: Referent' RefNum -> Builder
putNumberedReferent = \case
  Ref' RefNum
r ->
    Word8 -> Builder
BU.word8 Word8
0
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> RefNum -> Builder
putRefNum RefNum
r
  Con' GConstructorReference RefNum
r ConstructorType
ct ->
    Word8 -> Builder
BU.word8 Word8
1
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> GConstructorReference RefNum -> Builder
putNumberedConstructorReference GConstructorReference RefNum
r
      Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ConstructorType -> Builder
putConstructorType ConstructorType
ct

getReferentByNumber :: (MonadGet m) => GetRefLookup -> m Referent
getReferentByNumber :: forall (m :: * -> *). MonadGet m => GetRefLookup -> m Referent
getReferentByNumber (Array Reference
tys, Array Reference
tms) = do
  Word8
tag <- m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8
  case Word8
tag of
    Word8
0 -> Reference -> Referent
Ref (Reference -> Referent) -> m Reference -> m Referent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Array Reference -> m Reference
forall (m :: * -> *). MonadGet m => Array Reference -> m Reference
getReferenceByNumber Array Reference
tms
    Word8
1 -> ConstructorReference -> ConstructorType -> Referent
Con (ConstructorReference -> ConstructorType -> Referent)
-> m ConstructorReference -> m (ConstructorType -> Referent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Array Reference -> m ConstructorReference
forall (m :: * -> *).
MonadGet m =>
Array Reference -> m ConstructorReference
getConstructorReferenceByNumber Array Reference
tys m (ConstructorType -> Referent) -> m ConstructorType -> m Referent
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m ConstructorType
forall (m :: * -> *). MonadGet m => m ConstructorType
getConstructorType
    Word8
_ -> [Char] -> Word8 -> m Referent
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"getReferent" Word8
tag

getNumberedReferent :: (MonadGet m) => m (Referent' RefNum)
getNumberedReferent :: forall (m :: * -> *). MonadGet m => m (Referent' RefNum)
getNumberedReferent =
  m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8 m Word8 -> (Word8 -> m (Referent' RefNum)) -> m (Referent' RefNum)
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 -> RefNum -> Referent' RefNum
forall r. r -> Referent' r
Ref' (RefNum -> Referent' RefNum) -> m RefNum -> m (Referent' RefNum)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m RefNum
forall (m :: * -> *). MonadGet m => m RefNum
getRefNum
    Word8
1 -> GConstructorReference RefNum -> ConstructorType -> Referent' RefNum
forall r. GConstructorReference r -> ConstructorType -> Referent' r
Con' (GConstructorReference RefNum
 -> ConstructorType -> Referent' RefNum)
-> m (GConstructorReference RefNum)
-> m (ConstructorType -> Referent' RefNum)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m (GConstructorReference RefNum)
forall (m :: * -> *).
MonadGet m =>
m (GConstructorReference RefNum)
getNumberedConstructorReference m (ConstructorType -> Referent' RefNum)
-> m ConstructorType -> m (Referent' RefNum)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m ConstructorType
forall (m :: * -> *). MonadGet m => m ConstructorType
getConstructorType
    Word8
tag -> [Char] -> Word8 -> m (Referent' RefNum)
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"getNumberedReferent" Word8
tag

getConstructorType :: (MonadGet m) => m CT.ConstructorType
getConstructorType :: forall (m :: * -> *). MonadGet m => m ConstructorType
getConstructorType =
  m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8 m Word8 -> (Word8 -> m ConstructorType) -> m ConstructorType
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 -> ConstructorType -> m ConstructorType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ConstructorType
CT.Data
    Word8
1 -> ConstructorType -> m ConstructorType
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ConstructorType
CT.Effect
    Word8
t -> [Char] -> Word8 -> m ConstructorType
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"getConstructorType" Word8
t

putConstructorType :: CT.ConstructorType -> Builder
putConstructorType :: ConstructorType -> Builder
putConstructorType = \case
  ConstructorType
CT.Data -> Word8 -> Builder
BU.word8 Word8
0
  ConstructorType
CT.Effect -> Word8 -> Builder
BU.word8 Word8
1

putConstructorReferenceByNumber ::
  CanonMap Reference Int -> ConstructorReference -> Builder
putConstructorReferenceByNumber :: CanonMap Reference Int -> ConstructorReference -> Builder
putConstructorReferenceByNumber CanonMap Reference Int
tys (ConstructorReference Reference
r Pos
i) =
  CanonMap Reference Int -> Reference -> Builder
putReferenceByNumber CanonMap Reference Int
tys Reference
r Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Pos -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength Pos
i

getConstructorReferenceByNumber ::
  (MonadGet m) => Array Reference -> m ConstructorReference
getConstructorReferenceByNumber :: forall (m :: * -> *).
MonadGet m =>
Array Reference -> m ConstructorReference
getConstructorReferenceByNumber Array Reference
tys =
  Reference -> Pos -> ConstructorReference
forall r. r -> Pos -> GConstructorReference r
ConstructorReference (Reference -> Pos -> ConstructorReference)
-> m Reference -> m (Pos -> ConstructorReference)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Array Reference -> m Reference
forall (m :: * -> *). MonadGet m => Array Reference -> m Reference
getReferenceByNumber Array Reference
tys m (Pos -> ConstructorReference) -> m Pos -> m ConstructorReference
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Pos
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength

putNumberedConstructorReference ::
  GConstructorReference RefNum -> Builder
putNumberedConstructorReference :: GConstructorReference RefNum -> Builder
putNumberedConstructorReference (ConstructorReference RefNum
r Pos
i) =
  RefNum -> Builder
putRefNum RefNum
r Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Pos -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength Pos
i

getNumberedConstructorReference ::
  (MonadGet m) => m (GConstructorReference RefNum)
getNumberedConstructorReference :: forall (m :: * -> *).
MonadGet m =>
m (GConstructorReference RefNum)
getNumberedConstructorReference =
  RefNum -> Pos -> GConstructorReference RefNum
forall r. r -> Pos -> GConstructorReference r
ConstructorReference (RefNum -> Pos -> GConstructorReference RefNum)
-> m RefNum -> m (Pos -> GConstructorReference RefNum)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m RefNum
forall (m :: * -> *). MonadGet m => m RefNum
getRefNum m (Pos -> GConstructorReference RefNum)
-> m Pos -> m (GConstructorReference RefNum)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Pos
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength

putString :: String -> Builder
putString :: [Char] -> Builder
putString = (Char -> Builder) -> [Char] -> Builder
forall (f :: * -> *) a.
Foldable f =>
(a -> Builder) -> f a -> Builder
putFoldable (Int -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt (Int -> Builder) -> (Char -> Int) -> Char -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum)

getString :: (MonadGet m) => m String
getString :: forall (m :: * -> *). MonadGet m => m [Char]
getString = m Char -> m [Char]
forall (m :: * -> *) a. MonadGet m => m a -> m [a]
getList (Int -> Char
forall a. Enum a => Int -> a
toEnum (Int -> Char) -> m Int -> m Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *) b. (MonadGet m, Num b, Bits b) => m b
getVarInt)

putText :: Text -> Builder
putText :: Text -> Builder
putText Text
text = Int -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength (ByteString -> Int
B.length ByteString
bs) Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> ByteString -> Builder
BU.byteString ByteString
bs
  where
    bs :: ByteString
bs = Text -> ByteString
encodeUtf8 Text
text
{-# INLINE putText #-}

getText :: (MonadGet m) => m Text
getText :: forall (m :: * -> *). MonadGet m => m Text
getText = do
  Int
len <- m Int
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength
  ByteString
bs <- ByteString -> ByteString
B.copy (ByteString -> ByteString) -> m ByteString -> m ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> m ByteString
forall (m :: * -> *). MonadGet m => Int -> m ByteString
Ser.getBytes Int
len
  pure $ ByteString -> Text
decodeUtf8 ByteString
bs
{-# INLINE getText #-}

putReference :: Reference -> Builder
putReference :: Reference -> Builder
putReference Reference
r = case Reference
r of
  Builtin Text
name -> Word8 -> Builder
BU.word8 Word8
0 Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Text -> Builder
putText Text
name
  Derived Hash
hash Pos
i -> Word8 -> Builder
BU.word8 Word8
1 Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Hash -> Builder
putHash Hash
hash Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Pos -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength Pos
i
{-# INLINE putReference #-}

putReferenceByNumber :: CanonMap Reference Int -> Reference -> Builder
putReferenceByNumber :: CanonMap Reference Int -> Reference -> Builder
putReferenceByNumber CanonMap Reference Int
cm Reference
r
  | Just Int
i <- Reference -> CanonMap Reference Int -> Maybe Int
forall k v. Ord k => k -> CanonMap k v -> Maybe v
unsafeLookup Reference
r CanonMap Reference Int
cm = Int -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt Int
i
  | Bool
otherwise = [Word] -> [Char] -> Builder
forall a. HasCallStack => [Word] -> [Char] -> a
exn [] ([Char] -> Builder) -> [Char] -> Builder
forall a b. (a -> b) -> a -> b
$ [Char]
"could not serialize reference: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Reference -> [Char]
forall a. Show a => a -> [Char]
show Reference
r
{-# INLINE putReferenceByNumber #-}

putRefNum :: RefNum -> Builder
putRefNum :: RefNum -> Builder
putRefNum (RefNum Int
i) = Int -> Builder
forall a.
(Integral a, Integral (Unsigned a), Bits (Unsigned a)) =>
a -> Builder
putVarInt Int
i
{-# INLINE putRefNum #-}

getReference :: (MonadGet m) => m Reference
getReference :: forall (m :: * -> *). MonadGet m => m Reference
getReference = do
  Word8
tag <- m Word8
forall (m :: * -> *). MonadGet m => m Word8
getWord8
  case Word8
tag of
    Word8
0 -> Text -> Reference
forall t h. t -> Reference' t h
Builtin (Text -> Reference) -> m Text -> m Reference
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Text
forall (m :: * -> *). MonadGet m => m Text
getText
    Word8
1 -> Id' Hash -> Reference
forall h t. Id' h -> Reference' t h
DerivedId (Id' Hash -> Reference) -> m (Id' Hash) -> m Reference
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Hash -> Pos -> Id' Hash
forall h. h -> Pos -> Id' h
Id (Hash -> Pos -> Id' Hash) -> m Hash -> m (Pos -> Id' Hash)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Hash
forall (m :: * -> *). MonadGet m => m Hash
getHash m (Pos -> Id' Hash) -> m Pos -> m (Id' Hash)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Pos
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength)
    Word8
_ -> [Char] -> Word8 -> m Reference
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"Reference" Word8
tag
{-# INLINE getReference #-}

getReferenceByNumber :: (MonadGet m) => Array Reference -> m Reference
getReferenceByNumber :: forall (m :: * -> *). MonadGet m => Array Reference -> m Reference
getReferenceByNumber Array Reference
refm = m Int
forall (m :: * -> *) b. (MonadGet m, Num b, Bits b) => m b
getVarInt m Int -> (Int -> m Reference) -> m Reference
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Array Reference -> Int -> m Reference
forall (m :: * -> *).
Monad m =>
Array Reference -> Int -> m Reference
lookupRef Array Reference
refm
{-# INLINE getReferenceByNumber #-}

lookupRef :: (Monad m) => Array Reference -> Int -> m Reference
lookupRef :: forall (m :: * -> *).
Monad m =>
Array Reference -> Int -> m Reference
lookupRef Array Reference
arr Int
i
  | Int
0 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
i Bool -> Bool -> Bool
&& Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Array Reference -> Int
forall a. Array a -> Int
sizeofArray Array Reference
arr = Reference -> m Reference
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Reference -> m Reference) -> Reference -> m Reference
forall a b. (a -> b) -> a -> b
$ Array Reference -> Int -> Reference
forall a. Array a -> Int -> a
indexArray Array Reference
arr Int
i
  | Bool
otherwise = [Word] -> [Char] -> m Reference
forall a. HasCallStack => [Word] -> [Char] -> a
exn [] ([Char] -> m Reference) -> [Char] -> m Reference
forall a b. (a -> b) -> a -> b
$ [Char]
"lookupRef: index out of bounds: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ Int -> [Char]
forall a. Show a => a -> [Char]
show Int
i
{-# INLINE lookupRef #-}

getRefNum :: (MonadGet m) => m RefNum
getRefNum :: forall (m :: * -> *). MonadGet m => m RefNum
getRefNum = Int -> RefNum
RefNum (Int -> RefNum) -> m Int -> m RefNum
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Int
forall (m :: * -> *) b. (MonadGet m, Num b, Bits b) => m b
getVarInt
{-# INLINE getRefNum #-}

putConstructorReference :: ConstructorReference -> Builder
putConstructorReference :: ConstructorReference -> Builder
putConstructorReference (ConstructorReference Reference
r Pos
i) =
  Reference -> Builder
putReference Reference
r Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Pos -> Builder
forall n.
(Integral n, Integral (Unsigned n), Bits n, Bits (Unsigned n)) =>
n -> Builder
putLength Pos
i

getConstructorReference :: (MonadGet m) => m ConstructorReference
getConstructorReference :: forall (m :: * -> *). MonadGet m => m ConstructorReference
getConstructorReference =
  Reference -> Pos -> ConstructorReference
forall r. r -> Pos -> GConstructorReference r
ConstructorReference (Reference -> Pos -> ConstructorReference)
-> m Reference -> m (Pos -> ConstructorReference)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m Reference
forall (m :: * -> *). MonadGet m => m Reference
getReference m (Pos -> ConstructorReference) -> m Pos -> m ConstructorReference
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> m Pos
forall (m :: * -> *) n.
(MonadGet m, Integral n, Integral (Unsigned n), Bits n,
 Bits (Unsigned n)) =>
m n
getLength

instance Tag Prim1 where
  tag2word :: Prim1 -> Word8
tag2word Prim1
DECI = Word8
0
  tag2word Prim1
DECN = Word8
1
  tag2word Prim1
INCI = Word8
2
  tag2word Prim1
INCN = Word8
3
  tag2word Prim1
NEGI = Word8
4
  tag2word Prim1
SGNI = Word8
5
  tag2word Prim1
LZRO = Word8
6
  tag2word Prim1
TZRO = Word8
7
  tag2word Prim1
COMN = Word8
8
  tag2word Prim1
COMI = Word8
9
  tag2word Prim1
POPC = Word8
10
  tag2word Prim1
ABSF = Word8
11
  tag2word Prim1
EXPF = Word8
12
  tag2word Prim1
LOGF = Word8
13
  tag2word Prim1
SQRT = Word8
14
  tag2word Prim1
COSF = Word8
15
  tag2word Prim1
ACOS = Word8
16
  tag2word Prim1
COSH = Word8
17
  tag2word Prim1
ACSH = Word8
18
  tag2word Prim1
SINF = Word8
19
  tag2word Prim1
ASIN = Word8
20
  tag2word Prim1
SINH = Word8
21
  tag2word Prim1
ASNH = Word8
22
  tag2word Prim1
TANF = Word8
23
  tag2word Prim1
ATAN = Word8
24
  tag2word Prim1
TANH = Word8
25
  tag2word Prim1
ATNH = Word8
26
  tag2word Prim1
ITOF = Word8
27
  tag2word Prim1
NTOF = Word8
28
  tag2word Prim1
CEIL = Word8
29
  tag2word Prim1
FLOR = Word8
30
  tag2word Prim1
TRNF = Word8
31
  tag2word Prim1
RNDF = Word8
32
  tag2word Prim1
TRNC = Word8
33
  tag2word Prim1
NOTB = Word8
34
  --
  tag2word Prim1
SIZT = Word8
35
  tag2word Prim1
USNC = Word8
36
  tag2word Prim1
UCNS = Word8
37
  tag2word Prim1
ITOT = Word8
38
  tag2word Prim1
NTOT = Word8
39
  tag2word Prim1
FTOT = Word8
40
  tag2word Prim1
TTOI = Word8
41
  tag2word Prim1
TTON = Word8
42
  tag2word Prim1
TTOF = Word8
43
  tag2word Prim1
PAKT = Word8
44
  tag2word Prim1
UPKT = Word8
45
  tag2word Prim1
VWLS = Word8
46
  tag2word Prim1
VWRS = Word8
47
  tag2word Prim1
SIZS = Word8
48
  tag2word Prim1
PAKB = Word8
49
  tag2word Prim1
UPKB = Word8
50
  tag2word Prim1
SIZB = Word8
51
  tag2word Prim1
FLTB = Word8
52
  tag2word Prim1
MISS = Word8
53
  tag2word Prim1
CACH = Word8
54
  tag2word Prim1
LKUP = Word8
55
  tag2word Prim1
LOAD = Word8
56
  tag2word Prim1
CVLD = Word8
57
  tag2word Prim1
VALU = Word8
58
  tag2word Prim1
TLTT = Word8
59
  tag2word Prim1
DBTX = Word8
60
  tag2word Prim1
SDBL = Word8
61
  tag2word Prim1
REFN = Word8
62
  tag2word Prim1
REFR = Word8
63
  tag2word Prim1
RRFC = Word8
64
  tag2word Prim1
TIKR = Word8
65

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m Prim1
word2tag Word8
0 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
DECI
  word2tag Word8
1 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
DECN
  word2tag Word8
2 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
INCI
  word2tag Word8
3 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
INCN
  word2tag Word8
4 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
NEGI
  word2tag Word8
5 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SGNI
  word2tag Word8
6 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
LZRO
  word2tag Word8
7 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TZRO
  word2tag Word8
8 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
COMN
  word2tag Word8
9 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
COMI
  word2tag Word8
10 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
POPC
  word2tag Word8
11 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ABSF
  word2tag Word8
12 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
EXPF
  word2tag Word8
13 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
LOGF
  word2tag Word8
14 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SQRT
  word2tag Word8
15 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
COSF
  word2tag Word8
16 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ACOS
  word2tag Word8
17 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
COSH
  word2tag Word8
18 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ACSH
  word2tag Word8
19 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SINF
  word2tag Word8
20 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ASIN
  word2tag Word8
21 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SINH
  word2tag Word8
22 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ASNH
  word2tag Word8
23 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TANF
  word2tag Word8
24 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ATAN
  word2tag Word8
25 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TANH
  word2tag Word8
26 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ATNH
  word2tag Word8
27 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ITOF
  word2tag Word8
28 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
NTOF
  word2tag Word8
29 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
CEIL
  word2tag Word8
30 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
FLOR
  word2tag Word8
31 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TRNF
  word2tag Word8
32 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
RNDF
  word2tag Word8
33 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TRNC
  word2tag Word8
34 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
NOTB
  --
  word2tag Word8
35 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SIZT
  word2tag Word8
36 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
USNC
  word2tag Word8
37 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
UCNS
  word2tag Word8
38 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
ITOT
  word2tag Word8
39 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
NTOT
  word2tag Word8
40 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
FTOT
  word2tag Word8
41 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TTOI
  word2tag Word8
42 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TTON
  word2tag Word8
43 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TTOF
  word2tag Word8
44 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
PAKT
  word2tag Word8
45 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
UPKT
  word2tag Word8
46 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
VWLS
  word2tag Word8
47 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
VWRS
  word2tag Word8
48 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SIZS
  word2tag Word8
49 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
PAKB
  word2tag Word8
50 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
UPKB
  word2tag Word8
51 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SIZB
  word2tag Word8
52 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
FLTB
  word2tag Word8
53 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
MISS
  word2tag Word8
54 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
CACH
  word2tag Word8
55 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
LKUP
  word2tag Word8
56 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
LOAD
  word2tag Word8
57 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
CVLD
  word2tag Word8
58 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
VALU
  word2tag Word8
59 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TLTT
  word2tag Word8
60 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
DBTX
  word2tag Word8
61 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
SDBL
  word2tag Word8
62 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
REFN
  word2tag Word8
63 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
REFR
  word2tag Word8
64 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
RRFC
  word2tag Word8
65 = Prim1 -> m Prim1
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim1
TIKR
  word2tag Word8
n = [Char] -> Word8 -> m Prim1
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"Prim1" Word8
n

instance Tag Prim2 where
  tag2word :: Prim2 -> Word8
tag2word Prim2
ADDI = Word8
0
  tag2word Prim2
ADDN = Word8
1
  tag2word Prim2
SUBI = Word8
2
  tag2word Prim2
SUBN = Word8
3
  tag2word Prim2
MULI = Word8
4
  tag2word Prim2
MULN = Word8
5
  tag2word Prim2
DIVI = Word8
6
  tag2word Prim2
MODI = Word8
7
  tag2word Prim2
DIVN = Word8
8
  tag2word Prim2
MODN = Word8
9
  tag2word Prim2
SHLI = Word8
10
  tag2word Prim2
SHLN = Word8
11
  tag2word Prim2
SHRI = Word8
12
  tag2word Prim2
SHRN = Word8
13
  tag2word Prim2
POWI = Word8
14
  tag2word Prim2
POWN = Word8
15
  tag2word Prim2
EQLI = Word8
16
  tag2word Prim2
NEQI = Word8
17
  tag2word Prim2
EQLN = Word8
18
  tag2word Prim2
NEQN = Word8
19
  tag2word Prim2
LEQI = Word8
20
  tag2word Prim2
LEQN = Word8
21
  tag2word Prim2
LESI = Word8
22
  tag2word Prim2
LESN = Word8
23
  tag2word Prim2
ANDN = Word8
24
  tag2word Prim2
ANDI = Word8
25
  tag2word Prim2
IORN = Word8
26
  tag2word Prim2
IORI = Word8
27
  tag2word Prim2
XORN = Word8
28
  tag2word Prim2
XORI = Word8
29
  tag2word Prim2
EQLF = Word8
30
  tag2word Prim2
NEQF = Word8
31
  tag2word Prim2
LEQF = Word8
32
  tag2word Prim2
LESF = Word8
33
  tag2word Prim2
ADDF = Word8
34
  tag2word Prim2
SUBF = Word8
35
  tag2word Prim2
MULF = Word8
36
  tag2word Prim2
DIVF = Word8
37
  tag2word Prim2
ATN2 = Word8
38
  tag2word Prim2
POWF = Word8
39
  tag2word Prim2
LOGB = Word8
40
  tag2word Prim2
MAXF = Word8
41
  tag2word Prim2
MINF = Word8
42
  tag2word Prim2
CAST = Word8
43
  tag2word Prim2
DRPN = Word8
44
  tag2word Prim2
ANDB = Word8
45
  tag2word Prim2
IORB = Word8
46
  tag2word Prim2
EQLU = Word8
47
  tag2word Prim2
LEQU = Word8
48
  tag2word Prim2
LESU = Word8
49
  tag2word Prim2
CMPU = Word8
50
  tag2word Prim2
DRPT = Word8
51
  tag2word Prim2
CATT = Word8
52
  tag2word Prim2
TAKT = Word8
53
  tag2word Prim2
EQLT = Word8
54
  tag2word Prim2
LEQT = Word8
55
  tag2word Prim2
LEST = Word8
56
  tag2word Prim2
DRPS = Word8
57
  tag2word Prim2
CATS = Word8
58
  tag2word Prim2
TAKS = Word8
59
  tag2word Prim2
CONS = Word8
60
  tag2word Prim2
SNOC = Word8
61
  tag2word Prim2
IDXS = Word8
62
  tag2word Prim2
SPLL = Word8
63
  tag2word Prim2
SPLR = Word8
64
  tag2word Prim2
TAKB = Word8
65
  tag2word Prim2
DRPB = Word8
66
  tag2word Prim2
IDXB = Word8
67
  tag2word Prim2
CATB = Word8
68
  tag2word Prim2
THRO = Word8
69
  tag2word Prim2
TRCE = Word8
70
  tag2word Prim2
SDBX = Word8
71
  tag2word Prim2
IXOT = Word8
72
  tag2word Prim2
IXOB = Word8
73
  tag2word Prim2
SDBV = Word8
74
  tag2word Prim2
REFW = Word8
75

  word2tag :: forall (m :: * -> *). MonadGet m => Word8 -> m Prim2
word2tag Word8
0 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
ADDI
  word2tag Word8
1 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
ADDN
  word2tag Word8
2 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SUBI
  word2tag Word8
3 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SUBN
  word2tag Word8
4 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
MULI
  word2tag Word8
5 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
MULN
  word2tag Word8
6 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
DIVI
  word2tag Word8
7 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
MODI
  word2tag Word8
8 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
DIVN
  word2tag Word8
9 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
MODN
  word2tag Word8
10 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SHLI
  word2tag Word8
11 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SHLN
  word2tag Word8
12 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SHRI
  word2tag Word8
13 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SHRN
  word2tag Word8
14 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
POWI
  word2tag Word8
15 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
POWN
  word2tag Word8
16 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
EQLI
  word2tag Word8
17 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
NEQI
  word2tag Word8
18 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
EQLN
  word2tag Word8
19 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
NEQN
  word2tag Word8
20 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LEQI
  word2tag Word8
21 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LEQN
  word2tag Word8
22 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LESI
  word2tag Word8
23 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LESN
  word2tag Word8
24 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
ANDN
  word2tag Word8
25 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
ANDI
  word2tag Word8
26 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
IORN
  word2tag Word8
27 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
IORI
  word2tag Word8
28 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
XORN
  word2tag Word8
29 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
XORI
  word2tag Word8
30 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
EQLF
  word2tag Word8
31 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
NEQF
  word2tag Word8
32 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LEQF
  word2tag Word8
33 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LESF
  word2tag Word8
34 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
ADDF
  word2tag Word8
35 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SUBF
  word2tag Word8
36 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
MULF
  word2tag Word8
37 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
DIVF
  word2tag Word8
38 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
ATN2
  word2tag Word8
39 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
POWF
  word2tag Word8
40 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LOGB
  word2tag Word8
41 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
MAXF
  word2tag Word8
42 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
MINF
  word2tag Word8
43 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
CAST
  word2tag Word8
44 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
DRPN
  word2tag Word8
45 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
ANDB
  word2tag Word8
46 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
IORB
  --
  word2tag Word8
47 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
EQLU
  word2tag Word8
48 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LEQU
  word2tag Word8
49 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LESU
  word2tag Word8
50 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
CMPU
  word2tag Word8
51 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
DRPT
  word2tag Word8
52 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
CATT
  word2tag Word8
53 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
TAKT
  word2tag Word8
54 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
EQLT
  word2tag Word8
55 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LEQT
  word2tag Word8
56 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
LEST
  word2tag Word8
57 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
DRPS
  word2tag Word8
58 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
CATS
  word2tag Word8
59 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
TAKS
  word2tag Word8
60 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
CONS
  word2tag Word8
61 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SNOC
  word2tag Word8
62 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
IDXS
  word2tag Word8
63 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SPLL
  word2tag Word8
64 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SPLR
  word2tag Word8
65 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
TAKB
  word2tag Word8
66 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
DRPB
  word2tag Word8
67 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
IDXB
  word2tag Word8
68 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
CATB
  word2tag Word8
69 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
THRO
  word2tag Word8
70 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
TRCE
  word2tag Word8
71 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SDBX
  word2tag Word8
72 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
IXOT
  word2tag Word8
73 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
IXOB
  word2tag Word8
74 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
SDBV
  word2tag Word8
75 = Prim2 -> m Prim2
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Prim2
REFW
  word2tag Word8
n = [Char] -> Word8 -> m Prim2
forall (m :: * -> *) a. MonadGet m => [Char] -> Word8 -> m a
unknownTag [Char]
"Prim2" Word8
n