在haskell中编写结构化的二进制文件

Question

我想在 Haskell 中编写一个结构化的二进制文件。 例如，假设前四个字节应该是“TEST”（ASCII），然后是数字 1、2、3、4，然后是 32 个字节，每个字节的值是 128，然后是 Little Endian 格式的数字 2048。

也就是说，创建的文件（十六进制）应该是这样的：

54 45 53 54 01 02 03 04 80 80 [... 30 个字节以上 ...] 00 08

所以基本上我有一个自定义数据结构，比如说

data MyData = MyData {
  header :: String     -- "TEST"
  n1     :: Integer    -- 1
  n2     :: Integer    -- 2
  n3     :: Integer    -- 3
  block  :: [Integer]  -- 32 times 128
  offset :: Integer    -- 2048
}

现在我想将此数据写入文件。所以基本上我需要把这个结构转换成一个长字节串。我找不到一个干净的惯用方法来做到这一点。理想情况下我有一个功能

MyDataToByteString :: MyData -> ByteString

或

MyDataToPut :: MyData -> Put

但我不知道如何创建这样的函数。

背景信息：我想写一首脉冲追踪​​器格式的歌曲（http://schismtracker.org/wiki/ITTECH.TXT），这是分裂追踪器软件的二进制格式。

更新 1

对于字节序转换，我想我可以按如下方式提取单个字节：

getByte :: Int -> Int -> Int
getByte b num = shift (num .&. bitMask b) (8-8*b)
  where bitMask b = sum $ map (2^) [8*b-8 .. 8*b-1]

Answer 1

你可以试试这个（恐怕不是最佳的）：

import qualified Data.List as L
import qualified Data.ByteString.Char8 as BC
import qualified Data.ByteString as B

data MyData = MyData {
      header :: String     -- "TEST"
    , n1     :: Integer    -- 1
    , n2     :: Integer    -- 2
    , n3     :: Integer    -- 3
    , n4     :: Integer    -- 4
    , block  :: [Integer]  -- 32 times 128
    , offset :: [Integer]  -- 2048 in little endian
} deriving (Show)

d = MyData "TEST" 1 2 3 4 (L.replicate 32 128) [0, 8]

myDataToByteString :: MyData -> B.ByteString
myDataToByteString (MyData h n1 n2 n3 n4 b o) =
    B.concat [
          BC.pack h
        , B.pack (map fromIntegral [n1, n2, n3, n4])
        , B.pack (map fromIntegral b)
        , B.pack (map fromIntegral o)
    ]

Answer 2

binary 或cereal 包提供了简单的ByteString 数据结构序列化。这是一个使用binary的示例

{-# LANGUAGE DeriveGeneric #-} 

import Data.Binary
import qualified Data.ByteString.Char8 as B8
import Data.Word8                  
import GHC.Generics

data MyData = MyData                  
    { header :: B8.ByteString               
    , n1     :: Int                 
    , n2     :: Int                  
    , n3     :: Int                 
    , n4     :: Int                 
    , block  :: [Word8]               
    , offset :: Int                 
    } deriving (Generic, Show)

instance Binary MyData

myData = MyData (B8.pack "Test") 1 2 3 4 (replicate 32 128) 2048

请注意，我已将 block 的类型更改为 [Word8]，因为问题指出这些将是 字节。

我们为MyData 派生了一个GHC.Generics 实例，它允许binary 包自动生成一个Binary 实例。现在我们可以使用encode将我们的数据序列化为ByteString，并使用decode反序列化：

λ. let encoded = encode myData
λ. :t encoded
encoded :: Data.ByteString.Lazy.Internal.ByteString
λ. let decoded = decode encoded :: MyData
λ. decoded
MyData {header = "Test", n1 = 1, n2 = 2, n3 = 3, n4 = 4, block = [128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128], offset = 2048}