Remove WriteBuilder API from BitWriter

src/Juvix/Compiler/Nockma/Encoding/Base.hs

@@ -3,25 +3,26 @@ module Juvix.Compiler.Nockma.Encoding.Base where
 import Data.Bit as Bit
 import Data.Bits
 import Data.Vector.Unboxed qualified as U
+import Juvix.Compiler.Nockma.Encoding.Effect.BitWriter
 import Juvix.Prelude.Base
-import VectorBuilder.Builder as Builder
-import VectorBuilder.Vector
 
--- | Binary encode an integer to a vector of bits, ordered from least to most significant bits
-integerToVectorBits :: Integer -> Bit.Vector Bit
-integerToVectorBits = build . integerToBuilder
-
-integerToBuilder :: (Integral a) => a -> Builder Bit
-integerToBuilder x
+-- | Binary encode an integer to a vector of bits, ordered from least to most significant bits.
+-- NB: 0 is encoded as the empty bit vector is specified by the Hoon serialization spec
+writeIntegral :: forall a r. (Integral a, Member BitWriter r) => a -> Sem r ()
+writeIntegral x
   | x < 0 = error "integerToVectorBits: negative integers are not supported in this implementation"
   | otherwise = unfoldBits (fromIntegral x)
   where
-    unfoldBits :: Integer -> Builder Bit
+    unfoldBits :: Integer -> Sem r ()
     unfoldBits n
-      | n == 0 = Builder.empty
-      | otherwise = Builder.singleton (Bit (testBit n 0)) <> unfoldBits (n `shiftR` 1)
+      | n == 0 = return ()
+      | otherwise = writeBit (Bit (testBit n 0)) <> unfoldBits (n `shiftR` 1)
+
+integerToVectorBits ::  (Integral a) => a -> Bit.Vector Bit
+integerToVectorBits = run . execBitWriter . writeIntegral
 
 -- | Computes the number of bits required to store the argument in binary
+-- NB: 0 is encoded to the empty bit vector (as specified by the Hoon serialization spec), so 0 has bit length 0.
 bitLength :: forall a. (Integral a) => a -> Int
 bitLength = \case
   0 -> 0

src/Juvix/Compiler/Nockma/Encoding/Effect/BitWriter.hs

@@ -6,14 +6,11 @@ import VectorBuilder.Builder as Builder
 import VectorBuilder.Vector
 
 data BitWriter :: Effect where
-  WriteBuilder :: Builder Bit -> BitWriter m ()
+  WriteBit :: Bit -> BitWriter m ()
   GetCurrentPosition :: BitWriter m Int
 
 makeSem ''BitWriter
 
-writeBit :: (Member BitWriter r) => Bit -> Sem r ()
-writeBit b = writeBuilder (Builder.singleton b)
-
 writeOne :: (Member BitWriter r) => Sem r ()
 writeOne = writeBit (Bit True)
 
@@ -41,14 +38,14 @@ execBitWriter sem = do
 
 re :: Sem (BitWriter ': r) a -> Sem (State WriterState ': r) a
 re = interpretTop $ \case
-  WriteBuilder b -> writeBuilder' b
+  WriteBit b -> writeBit' b
   GetCurrentPosition -> getCurrentPosition'
 
-writeBuilder' :: (Member (State WriterState) r) => Builder Bit -> Sem r ()
-writeBuilder' b = modify appendBuilder
+writeBit' :: (Member (State WriterState) r) => Bit -> Sem r ()
+writeBit' b = modify appendBit
   where
-    appendBuilder :: WriterState -> WriterState
-    appendBuilder = over writerStateBuilder (<> b)
+    appendBit :: WriterState -> WriterState
+    appendBit = over writerStateBuilder (<> Builder.singleton b)
 
 getCurrentPosition' :: (Member (State WriterState) r) => Sem r Int
 getCurrentPosition' = Builder.size <$> gets (^. writerStateBuilder)

src/Juvix/Compiler/Nockma/Encoding/Jam.hs

@@ -25,10 +25,6 @@ initJamState =
 
 makeLenses ''JamState
 
--- | Write the binary encoding of the argument to the output
-writeIntegral :: (Integral a, Member BitWriter r) => a -> Sem r ()
-writeIntegral i = writeBuilder (integerToBuilder i)
-
 -- | Write the binary encoding of argument interpreted as a length to the output
 writeLength :: forall r. (Member BitWriter r) => Int -> Sem r ()
 writeLength len = do