Implements functions to convert to and from raw bytes

src/Data/HexString.hs

@@ -1,8 +1,10 @@
 module Data.HexString ( HexString
                       , hexString
-                      , toHex
+                      , fromBinary
-                      , fromHex
+                      , toBinary
-                      , asText ) where
+                      , fromBytes
+                      , toBytes
+                      , toText ) where
 
 import           Data.Word                   (Word8)
 
@@ -36,13 +38,23 @@ hexString bs =
      else error ("Not a valid hex string: " ++ show bs)
 
 -- | Converts a 'B.Binary' to a 'HexString' value
-toHex :: B.Binary a  => a -> HexString
+fromBinary :: B.Binary a  => a -> HexString
-toHex = hexString . BS16.encode . BSL.toStrict . B.encode
+fromBinary = hexString . BS16.encode . BSL.toStrict . B.encode
 
 -- | Converts a 'HexString' to a 'B.Binary' value
-fromHex :: B.Binary a => HexString -> a
+toBinary :: B.Binary a => HexString -> a
-fromHex (HexString bs) = B.decode . BSL.fromStrict . fst . BS16.decode $ bs
+toBinary (HexString bs) = B.decode . BSL.fromStrict . fst . BS16.decode $ bs
+
+-- | Reads a 'BS.ByteString' as raw bytes and converts to hex representation. We
+--   cannot use the instance Binary of 'BS.ByteString' because it provides
+--   a leading length, which is not what we want when dealing with raw bytes.
+fromBytes :: BS.ByteString -> HexString
+fromBytes = hexString . BS16.encode
+
+-- | Access to the raw bytes in a 'BS.ByteString' format.
+toBytes :: HexString -> BS.ByteString
+toBytes (HexString bs) = (fst . BS16.decode) bs
 
 -- | Access to a 'T.Text' representation of the 'HexString'
-asText :: HexString -> T.Text
+toText :: HexString -> T.Text
-asText (HexString bs) = TE.decodeUtf8 bs
+toText (HexString bs) = TE.decodeUtf8 bs

test/Data/HexStringSpec.hs

@@ -1,15 +1,10 @@
 module Data.HexStringSpec where
 
 import           Data.HexString ( hexString
-                                , toHex
+                                , fromBytes
-                                , fromHex
+                                , toBytes )
-                                , asText )
 
-import qualified Data.ByteString       as BS
 import qualified Data.ByteString.Char8 as BS8
-import qualified Data.Text             as T
-
-import qualified Data.Binary as B ( encode )
 
 import           Test.Hspec
 
@@ -24,3 +19,9 @@ spec = do
       putStrLn (show (hexString (BS8.pack ":"))) `shouldThrow` anyErrorCall
       putStrLn (show (hexString (BS8.pack "`"))) `shouldThrow` anyErrorCall
       putStrLn (show (hexString (BS8.pack "g"))) `shouldThrow` anyErrorCall
+
+  describe "when interpreting a hex string" $ do
+    it "should convert the hex string properly when interpreting as bytes" $
+      toBytes (hexString (BS8.pack "ffff")) `shouldBe` BS8.pack "\255\255"
+    it "should convert bytes to the proper hex string" $
+      fromBytes (BS8.pack "\255\255") `shouldBe` hexString (BS8.pack "ffff")