Safe Haskell	Safe-Inferred
Language	Haskell2010

Unison.Runtime.ANF.Serialize

Synopsis

data Version
- = Transfer Word32
- | Hash Word32
index :: Eq v => [v] -> v -> Maybe Word64
deindex :: HasCallStack => [v] -> Word64 -> v
pushCtx :: [v] -> [v] -> [v]
putIndex :: MonadPut m => Word64 -> m ()
getIndex :: MonadGet m => m Word64
putVar :: MonadPut m => Eq v => [v] -> v -> m ()
getVar :: MonadGet m => [v] -> m v
putArgs :: MonadPut m => Eq v => [v] -> [v] -> m ()
getArgs :: MonadGet m => [v] -> m [v]
putCCs :: MonadPut m => [Mem] -> m ()
getCCs :: MonadGet m => m [Mem]
putGroup :: MonadPut m => Var v => Map Reference Word64 -> Bool -> SuperGroup Reference v -> m ()
getGroup :: MonadGet m => SerialConfig m => Var v => m (SuperGroup Reference v)
putCode :: MonadPut m => Bool -> Code Reference -> m ()
getCode :: (MonadGet m, SerialConfig m) => m (Code Reference)
putInlineInfo :: (MonadPut m, Var v) => [v] -> InlineInfo Reference v -> m ()
getInlineInfo :: (MonadGet m, SerialConfig m, Var v) => [v] -> Word64 -> m (InlineInfo Reference v)
putInlineExpr :: (MonadPut m, Var v) => [v] -> ANormal Reference v -> m ()
getInlineExpr :: (MonadGet m, SerialConfig m, Var v) => [v] -> Word64 -> m (ANormal Reference v)
putOptInfos :: (MonadPut m, Var v) => OptInfos Reference v -> m ()
getOptInfos :: (MonadGet m, Var v) => m (OptInfos Reference v)
putInlineClass :: MonadPut m => InlineClass -> m ()
getInlineClass :: MonadGet m => m InlineClass
putCacheability :: MonadPut m => Cacheability -> m ()
getCacheability :: (MonadGet m, SerialConfig m) => m Cacheability
putComb :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> SuperNormal Reference v -> m ()
getFresh :: Var v => Word64 -> v
getComb :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m (SuperNormal Reference v)
putNormal :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> ANormal Reference v -> m ()
getNormal :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m (ANormal Reference v)
putFunc :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> Func Reference v -> m ()
getFunc :: (MonadGet m, SerialConfig m, Var v) => [v] -> m (Func Reference v)
putFOp :: MonadPut m => ForeignFunc -> m ()
getFOp :: MonadGet m => m ForeignFunc
putPOp :: MonadPut m => POp -> m ()
getPOp :: MonadGet m => m POp
pOpCode :: POp -> Word16
pOpAssoc :: [(POp, Word16)]
pop2word :: Map POp Word16
word2pop :: Map Word16 POp
putLit :: MonadPut m => Lit Reference -> m ()
getLit :: MonadGet m => m (Lit Reference)
putBLit :: MonadPut m => Version -> BLit Reference -> m ()
putAsMap :: MonadPut m => Version -> [(Value Reference, Value Reference)] -> m ()
getBLit :: (MonadGet m, SerialConfig m) => m (BLit Reference)
putRefs :: MonadPut m => [Reference] -> m ()
getRefs :: MonadGet m => m [Reference]
putBranches :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> Branched Reference (ANormal Reference v) -> m ()
getBranches :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m (Branched Reference (ANormal Reference v))
putCase :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> ([Mem], ANormal Reference v) -> m ()
getCase :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m ([Mem], ANormal Reference v)
putCTag :: MonadPut m => CTag -> m ()
getCTag :: MonadGet m => m CTag
putGroupRef :: MonadPut m => GroupRef Reference -> m ()
getGroupRef :: MonadGet m => m (GroupRef Reference)
putValue :: MonadPut m => Version -> Value Reference -> m ()
getValue :: (MonadGet m, SerialConfig m) => m (Value Reference)
putCont :: MonadPut m => Version -> Cont Reference -> m ()
getCont :: (MonadGet m, SerialConfig m) => m (Cont Reference)
deserializeCode :: ByteString -> Either String (Referenced Code)
serializeCode :: Bool -> Referenced Code -> ByteString
serializeCodeWithVersion :: Word64 -> Bool -> Referenced Code -> IO (Either String ByteString)
serializeGroupForRehash :: Var v => Reference -> SuperGroup Reference v -> ByteString
getVersionedValue :: MonadGet m => m (Referenced Value)
deserializeValue :: ByteString -> Either String (Referenced Value)
serializeValue :: Referenced Value -> ByteString
serializeValueWithVersion :: Word64 -> Referenced Value -> IO ByteString
serializeValueForHash :: Value Reference -> ByteString
getGroupCurrent :: (MonadGet m, Var v) => m (SuperGroup Reference v)
askVersion :: SerialConfig m => m Version
askFOp :: SerialConfig m => m Bool
type SerialConfig m = MonadReader (Version, Bool) m
type BDeserial = ReaderT (Version, Bool) Get
type SDeserial = ReaderT (Version, Bool) Get
valueToCode :: Version -> Version
withCodeVersion :: SerialConfig m => m r -> m r
valueVersion :: Word32
codeVersion :: Word32

Documentation

data Version Source #

Constructors

Transfer Word32
Hash Word32

Instances

Instances details

Show Version Source #
Instance details Defined in Unison.Runtime.ANF.Serialize Methods showsPrec :: Int -> Version -> ShowS # show :: Version -> String # showList :: [Version] -> ShowS #

index :: Eq v => [v] -> v -> Maybe Word64 Source #

deindex :: HasCallStack => [v] -> Word64 -> v Source #

pushCtx :: [v] -> [v] -> [v] Source #

putIndex :: MonadPut m => Word64 -> m () Source #

getIndex :: MonadGet m => m Word64 Source #

putVar :: MonadPut m => Eq v => [v] -> v -> m () Source #

getVar :: MonadGet m => [v] -> m v Source #

putArgs :: MonadPut m => Eq v => [v] -> [v] -> m () Source #

getArgs :: MonadGet m => [v] -> m [v] Source #

putCCs :: MonadPut m => [Mem] -> m () Source #

getCCs :: MonadGet m => m [Mem] Source #

putGroup :: MonadPut m => Var v => Map Reference Word64 -> Bool -> SuperGroup Reference v -> m () Source #

getGroup :: MonadGet m => SerialConfig m => Var v => m (SuperGroup Reference v) Source #

putCode :: MonadPut m => Bool -> Code Reference -> m () Source #

getCode :: (MonadGet m, SerialConfig m) => m (Code Reference) Source #

putInlineInfo :: (MonadPut m, Var v) => [v] -> InlineInfo Reference v -> m () Source #

getInlineInfo :: (MonadGet m, SerialConfig m, Var v) => [v] -> Word64 -> m (InlineInfo Reference v) Source #

putInlineExpr :: (MonadPut m, Var v) => [v] -> ANormal Reference v -> m () Source #

getInlineExpr :: (MonadGet m, SerialConfig m, Var v) => [v] -> Word64 -> m (ANormal Reference v) Source #

putOptInfos :: (MonadPut m, Var v) => OptInfos Reference v -> m () Source #

getOptInfos :: (MonadGet m, Var v) => m (OptInfos Reference v) Source #

putInlineClass :: MonadPut m => InlineClass -> m () Source #

getInlineClass :: MonadGet m => m InlineClass Source #

putCacheability :: MonadPut m => Cacheability -> m () Source #

getCacheability :: (MonadGet m, SerialConfig m) => m Cacheability Source #

putComb :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> SuperNormal Reference v -> m () Source #

getFresh :: Var v => Word64 -> v Source #

getComb :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m (SuperNormal Reference v) Source #

putNormal :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> ANormal Reference v -> m () Source #

getNormal :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m (ANormal Reference v) Source #

putFunc :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> Func Reference v -> m () Source #

getFunc :: (MonadGet m, SerialConfig m, Var v) => [v] -> m (Func Reference v) Source #

putFOp :: MonadPut m => ForeignFunc -> m () Source #

getFOp :: MonadGet m => m ForeignFunc Source #

putPOp :: MonadPut m => POp -> m () Source #

getPOp :: MonadGet m => m POp Source #

pOpCode :: POp -> Word16 Source #

pOpAssoc :: [(POp, Word16)] Source #

pop2word :: Map POp Word16 Source #

word2pop :: Map Word16 POp Source #

putLit :: MonadPut m => Lit Reference -> m () Source #

getLit :: MonadGet m => m (Lit Reference) Source #

putBLit :: MonadPut m => Version -> BLit Reference -> m () Source #

putAsMap :: MonadPut m => Version -> [(Value Reference, Value Reference)] -> m () Source #

getBLit :: (MonadGet m, SerialConfig m) => m (BLit Reference) Source #

putRefs :: MonadPut m => [Reference] -> m () Source #

getRefs :: MonadGet m => m [Reference] Source #

putBranches :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> Branched Reference (ANormal Reference v) -> m () Source #

getBranches :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m (Branched Reference (ANormal Reference v)) Source #

putCase :: MonadPut m => Var v => Map Reference Word64 -> Bool -> [v] -> ([Mem], ANormal Reference v) -> m () Source #

getCase :: MonadGet m => SerialConfig m => Var v => [v] -> Word64 -> m ([Mem], ANormal Reference v) Source #

putCTag :: MonadPut m => CTag -> m () Source #

getCTag :: MonadGet m => m CTag Source #

putGroupRef :: MonadPut m => GroupRef Reference -> m () Source #

getGroupRef :: MonadGet m => m (GroupRef Reference) Source #

putValue :: MonadPut m => Version -> Value Reference -> m () Source #

getValue :: (MonadGet m, SerialConfig m) => m (Value Reference) Source #

putCont :: MonadPut m => Version -> Cont Reference -> m () Source #

getCont :: (MonadGet m, SerialConfig m) => m (Cont Reference) Source #

deserializeCode :: ByteString -> Either String (Referenced Code) Source #

serializeCode :: Bool -> Referenced Code -> ByteString Source #

serializeCodeWithVersion :: Word64 -> Bool -> Referenced Code -> IO (Either String ByteString) Source #

serializeGroupForRehash :: Var v => Reference -> SuperGroup Reference v -> ByteString Source #

Serializes a SuperGroup for rehashing.

Expected as arguments are some code, and the Reference that refers to it. In particular, if the code refers to itself by reference, or if the code is part of a mututally-recursive set of definitions (which have a common hash), the reference used as part of that (mutual) recursion must be supplied.

Using that reference, we find all references in the code to that connected component. In the resulting byte string, those references are instead replaced by positions in a listing of the connected component. This means that the byte string is independent of the hash used for the self reference. Only the order matters (which is determined by the Reference). Then the bytes can be re-hashed to establish a new hash for the connected component. This operation should be idempotent as long as the indexing is preserved.

Supplying a Builtin reference is not supported. Such code shouldn't be subject to rehashing.

getVersionedValue :: MonadGet m => m (Referenced Value) Source #

deserializeValue :: ByteString -> Either String (Referenced Value) Source #

serializeValue :: Referenced Value -> ByteString Source #

serializeValueWithVersion :: Word64 -> Referenced Value -> IO ByteString Source #

serializeValueForHash :: Value Reference -> ByteString Source #

getGroupCurrent :: (MonadGet m, Var v) => m (SuperGroup Reference v) Source #

askVersion :: SerialConfig m => m Version Source #

askFOp :: SerialConfig m => m Bool Source #

type SerialConfig m = MonadReader (Version, Bool) m Source #

type BDeserial = ReaderT (Version, Bool) Get Source #

type SDeserial = ReaderT (Version, Bool) Get Source #

valueToCode :: Version -> Version Source #

withCodeVersion :: SerialConfig m => m r -> m r Source #

valueVersion :: Word32 Source #

codeVersion :: Word32 Source #