Implement Bytes serialization + assorted tweaks

parser-typechecker/src/Unison/Codebase/Serialization/V1.hs

@@ -7,19 +7,22 @@ import Unison.Prelude
 
 import Prelude hiding (getChar, putChar)
 
+import Basement.Block (Block)
+
 -- import qualified Data.Text as Text
 import qualified Unison.Pattern                 as Pattern
 import           Unison.Pattern                 ( Pattern
                                                 , SeqOp
                                                 )
 import           Data.Bits                      ( Bits )
-import           Data.Bytes.Get
-import           Data.Bytes.Put
+import           Data.Bytes.Get                 as Ser
+import           Data.Bytes.Put                 as Ser
 import           Data.Bytes.Serial              ( serialize
                                                 , deserialize
                                                 , serializeBE
                                                 , deserializeBE
                                                 )
+import qualified Data.ByteArray                 as BA
 import           Data.Bytes.Signed              ( Unsigned )
 import           Data.Bytes.VarInt              ( VarInt(..) )
 import qualified Data.Map                      as Map
@@ -57,6 +60,7 @@ import           Unison.Referent               (Referent)
 import qualified Unison.Referent               as Referent
 import qualified Unison.Term                   as Term
 import qualified Unison.Type                   as Type
+import qualified Unison.Util.Bytes             as Bytes
 import           Unison.Util.Star3             ( Star3 )
 import qualified Unison.Util.Star3             as Star3
 import           Unison.Util.Relation           ( Relation )
@@ -177,13 +181,13 @@ putText text = do
 getText :: MonadGet m => m Text
 getText = do
   len <- getLength
-  bs <- B.copy <$> getBytes len
+  bs <- B.copy <$> Ser.getBytes len
   pure $ decodeUtf8 bs
 
 skipText :: MonadGet m => m ()
 skipText = do
   len <- getLength
-  void $ getBytes len
+  void $ Ser.getBytes len
 
 putFloat :: MonadPut m => Double -> m ()
 putFloat = serializeBE
@@ -222,7 +226,7 @@ putHash h = do
 getHash :: MonadGet m => m Hash
 getHash = do
   len <- getLength
-  bs <- B.copy <$> getBytes len
+  bs <- B.copy <$> Ser.getBytes len
   pure $ Hash.fromBytes bs
 
 putReference :: MonadPut m => Reference -> m ()
@@ -809,3 +813,15 @@ putEdits edits =
 getEdits :: MonadGet m => m Patch
 getEdits = Patch <$> getRelation getReference getTermEdit
                  <*> getRelation getReference getTypeEdit
+
+putBytes :: MonadPut m => Bytes.Bytes -> m ()
+putBytes = putFoldable putBlock . Bytes.chunks
+
+putBlock :: MonadPut m => Bytes.View (Block Word8) -> m ()
+putBlock b = putLength (BA.length b) *> putByteString (BA.convert b)
+
+getBytes :: MonadGet m => m Bytes.Bytes
+getBytes = Bytes.fromChunks <$> getList getBlock
+
+getBlock :: MonadGet m => m (Bytes.View (Block Word8))
+getBlock = getLength >>= fmap (Bytes.view . BA.convert) . getByteString

parser-typechecker/src/Unison/Runtime/ANF.hs

@@ -84,6 +84,7 @@ import qualified Prelude
 import Unison.Term hiding (resolve, fresh, float, Text, Ref)
 import Unison.Var (Var, typed)
 import Unison.Util.EnumContainers as EC
+import Unison.Util.Bytes (Bytes)
 import qualified Data.Map as Map
 import qualified Data.Set as Set
 import qualified Data.Text as Text
@@ -883,23 +884,28 @@ type ANFM v
 type ANFD v = Compose (ANFM v) (Directed ())
 
 data GroupRef = GR Reference Word64
+  deriving (Show)
 
 data Value
   = Partial GroupRef [Word64] [Value]
   | Data Reference Word64 [Word64] [Value]
   | Cont [Word64] [Value] Cont
   | BLit BLit
+  deriving (Show)
 
 data Cont
   = KE
   | Mark [Reference] (Map Reference Value) Cont
   | Push Word64 Word64 Word64 Word64 GroupRef Cont
+  deriving (Show)
 
 data BLit
   = Text Text
   | List (Seq Value)
   | TmLink Referent
   | TyLink Reference
+  | Bytes Bytes
+  deriving (Show)
 
 groupVars :: ANFM v (Set v)
 groupVars = ask
@@ -1267,6 +1273,7 @@ contLinks _ KE = mempty
 
 litLinks :: Monoid a => (Bool -> Reference -> a) -> BLit -> a
 litLinks _ (Text _) = mempty
+litLinks _ (Bytes _) = mempty
 litLinks f (List s) = foldMap (valueLinks f) s
 litLinks f (TmLink (Ref r)) = f False r
 litLinks f (TmLink (Con r _ _)) = f True r

parser-typechecker/src/Unison/Runtime/ANF/Serialize.hs

@@ -6,7 +6,7 @@ module Unison.Runtime.ANF.Serialize where
 import Control.Monad
 
 import Data.Bytes.Put
-import Data.Bytes.Get
+import Data.Bytes.Get hiding (getBytes)
 import Data.Bytes.VarInt
 import Data.Bytes.Serial
 import Data.ByteString (ByteString)
@@ -43,7 +43,7 @@ data MtTag
 data LtTag
   = IT | NT | FT | TT | CT | LMT | LYT
 
-data BLTag = TextT | ListT | TmLinkT | TyLinkT
+data BLTag = TextT | ListT | TmLinkT | TyLinkT | BytesT
 
 data VaTag = PartialT | DataT | ContT | BLitT
 data CoTag = KET | MarkT | PushT
@@ -141,12 +141,14 @@ instance Tag BLTag where
     ListT -> 1
     TmLinkT -> 2
     TyLinkT -> 3
+    BytesT -> 4
 
   word2tag = \case
     0 -> TextT
     1 -> ListT
     2 -> TmLinkT
     3 -> TyLinkT
+    4 -> BytesT
     _ -> error "unknown BLTag word"
 
 instance Tag VaTag where
@@ -418,6 +420,7 @@ putBLit (Text t) = putTag TextT *> putText t
 putBLit (List s) = putTag ListT *> putFoldable putValue s
 putBLit (TmLink r) = putTag TmLinkT *> putReferent r
 putBLit (TyLink r) = putTag TyLinkT *> putReference r
+putBLit (Bytes b) = putTag BytesT *> putBytes b
 
 getBLit :: MonadGet m => m BLit
 getBLit = getTag >>= \case
@@ -425,6 +428,7 @@ getBLit = getTag >>= \case
   ListT -> List . Seq.fromList <$> getList getValue
   TmLinkT -> TmLink <$> getReferent
   TyLinkT -> TyLink <$> getReference
+  BytesT -> Bytes <$> getBytes
 
 putRefs :: MonadPut m => [Reference] -> m ()
 putRefs rs = putFoldable putReference rs

parser-typechecker/src/Unison/Runtime/Machine.hs

@@ -1502,6 +1502,8 @@ reflectValue rty = goV
   goF f
     | Just t <- maybeUnwrapBuiltin f
     = pure (ANF.Text t)
+    | Just b <- maybeUnwrapBuiltin f
+    = pure (ANF.Bytes b)
     | Just s <- maybeUnwrapForeign Rf.vectorRef f
     = ANF.List <$> traverse goV s
     | Just l <- maybeUnwrapForeign Rf.termLinkRef f
@@ -1566,3 +1568,4 @@ reifyValue0 (rty, rtm) = goV
   goL (ANF.List l) = Foreign . Wrap Rf.vectorRef <$> traverse goV l
   goL (ANF.TmLink r) = pure . Foreign $ Wrap Rf.termLinkRef r
   goL (ANF.TyLink r) = pure . Foreign $ Wrap Rf.typeLinkRef r
+  goL (ANF.Bytes b) = pure . Foreign $ Wrap Rf.bytesRef b

unison-src/new-runtime-transcripts/codeops.md

@@ -143,7 +143,7 @@ tests =
    , identicality "ident float" 0.5
    , identicality "ident termlink" fDeps
    , identicality "ident bool" false
-   , identicality "ident bytes" (Bytes.empty)
+   , identicality "ident bytes" [fSer, Bytes.empty]
    ]
 ```