Picking development back up

Merge Kiselyov optimizations and De Bruijn indices
General clean up

src/Research.hs

@@ -1,11 +1,11 @@
 module Research where
 
 import Data.ByteArray            (convert)
-import Data.Char                 (chr, ord)
+import Data.ByteString.Base16    (decode, encode)
 import Data.List                 (intercalate)
 import Data.Map                  (Map)
-import Data.Text                 (Text, replace, unpack)
-import Data.Word                 (Word8)
+import Data.Text                 (Text, replace, pack)
+import Data.Text.Encoding        (decodeUtf8, encodeUtf8)
 import System.Console.CmdArgs    (Data, Typeable)
 
 import qualified Data.ByteString as BS
@@ -76,36 +76,21 @@ data Node
 --   Fork:  0x02 || left_hash (32 bytes) || right_hash (32 bytes)
 serializeNode :: Node -> BS.ByteString
 serializeNode NLeaf        = BS.pack [0x00]
-serializeNode (NStem h)    = BS.pack [0x01] <> hexToBytes h
-serializeNode (NFork l r)  = BS.pack [0x02] <> hexToBytes l <> hexToBytes r
+serializeNode (NStem h) = BS.pack [0x01] <> go (decode (encodeUtf8 h))
+  where go (Left _) = error "Research.serializeNode: invalid hex hash"
+        go (Right bs) = bs
+serializeNode (NFork l r) = BS.pack [0x02] <> go (decode (encodeUtf8 l)) <> go (decode (encodeUtf8 r))
+  where go (Left _) = error "Research.serializeNode: invalid hex hash"
+        go (Right bs) = bs
 
 -- | Hash a node per the Merkle content-addressing spec.
 -- hash = SHA256( "tricu.merkle.node.v1" <> 0x00 <> node_payload )
 nodeHash :: Node -> MerkleHash
-nodeHash node = bytesToHex (sha256WithPrefix (serializeNode node))
+nodeHash node = decodeUtf8 (encode (sha256WithPrefix (serializeNode node)))
   where sha256WithPrefix payload =
           convert . (hash :: BS.ByteString -> Digest SHA256) $ utf8Tag <> BS.pack [0x00] <> payload
         utf8Tag = BS.pack $ map fromIntegral $ BS.unpack "tricu.merkle.node.v1"
 
--- | Convert a Hex Text hash into raw ByteString (2 hex chars per byte)
-hexToBytes :: Text -> BS.ByteString
-hexToBytes h = BS.pack $ map combinePair pairs
-  where
-    chars = unpack h
-    pairs = chunkPairs chars
-    chunkPairs :: String -> [(Char, Char)]
-    chunkPairs (c1:c2:rest) = (c1, c2) : chunkPairs rest
-    chunkPairs [] = []
-    chunkPairs _ = error "hexToBytes: odd number of hex digits"
-    combinePair :: (Char, Char) -> Word8
-    combinePair (c1, c2) = fromIntegral (hexDigitToInt c1 * 16 + hexDigitToInt c2)
-    hexDigitToInt :: Char -> Int
-    hexDigitToInt c
-      | '0' <= c && c <= '9'  = ord c - ord '0'
-      | 'a' <= c && c <= 'f'  = ord c - ord 'a' + 10
-      | 'A' <= c && c <= 'F'  = ord c - ord 'A' + 10
-      | otherwise              = error $ "Invalid hex digit: " ++ show c
-
 -- | Deserialize a Node from canonical bytes.
 deserializeNode :: BS.ByteString -> Node
 deserializeNode bs =
@@ -115,26 +100,14 @@ deserializeNode bs =
 
     Just (0x01, rest)
       | BS.length rest == 32 ->
-          NStem $ bytesToHex rest
+          NStem $ decodeUtf8 (encode rest)
 
     Just (0x02, rest)
       | BS.length rest == 64 ->
           let (l, r) = BS.splitAt 32 rest
-          in NFork (bytesToHex l) (bytesToHex r)
+          in NFork (decodeUtf8 (encode l)) (decodeUtf8 (encode r))
 
-    _ -> error "invalid merkle node payload"
-
-
--- | Convert 32-byte ByteString back to hex Text
-bytesToHex :: BS.ByteString -> Text
-bytesToHex bs = T.pack $ concatMap byteToHexChars $ BS.unpack bs
-  where
-    byteToHexChars :: Word8 -> String
-    byteToHexChars w = [hexDigit (fromIntegral w `div` 16), hexDigit (fromIntegral w `mod` 16)]
-    hexDigit :: Int -> Char
-    hexDigit n
-      | n < 10    = chr (ord '0' + n)
-      | otherwise = chr (ord 'a' + n - 10)
+    _ -> errorWithoutStackTrace "invalid merkle node payload"
 
 -- | Build a Merkle DAG from a Tree Calculus term.
 buildMerkle :: T -> Node