blocks|key|663869|text|所以我建议继续使用Data.Binary，但是为可增长列表编写一个新的实例。下面是当前的(严格)实例：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|663870|instance+Binary+a+=>+Binary+[a]+where
++++put+l++=+put+(length+l)+>>+mapM_+put+l
++++get++++=+do+n+<-+get+::+Get+Int
++++++++++++++++getMany+n

--+%7C+'getMany+n'+get+'n'+elements+in+order,+without+blowing+the+stack.
getMany+::+Binary+a+=>+Int+->+Get+[a]
getMany+n+=+go+[]+n
+where
++++go+xs+0+=+return+$!+reverse+xs
++++go+xs+i+=+do+x+<-+get
+++++++++++++++++x+`seq`+go+(x:xs)+(i-1)
{-#+INLINE+getMany+#-}|code-block|syntax|javascript|663871|现在，允许您流式传输(二进制)以附加到文件的版本需要是急切的或惰性的。懒惰版本是最微不足道的。类似于：|663872|import+Data.Binary

newtype+Stream+a+=+Stream+{+unstream+::+[a]+}

instance+Binary+a+=>+Binary+(Stream+a)+where

++++put+(Stream+[])+++++=+putWord8+0
++++put+(Stream+(x:xs))+=+putWord8+1+>>+put+x+>>+put+(Stream+xs)

++++get+=+do
++++++++t+<-+getWord8
++++++++case+t+of
++++++++++++0+->+return+(Stream+[])
++++++++++++1+->+do+x+++++++++<-+get
++++++++++++++++++++Stream+xs+<-+get
++++++++++++++++++++return+(Stream+(x:xs))|663873|适当地为流媒体工作的消息。现在，为了处理静默追加，在添加更多元素之前，我们需要能够查找到文件的末尾，并覆盖最终的0标记。|663874|entityMap^0|9|B|0|0|0|0|1K|1|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

So I say stick with <code>Data.Binary</code> but write a new instance for growable lists. Here's the current (strict) instance:

<pre><code>instance Binary a =&gt; Binary [a] where
 put l = put (length l) &gt;&gt; mapM_ put l
 get = do n &lt;- get :: Get Int
 getMany n

-- | 'getMany n' get 'n' elements in order, without blowing the stack.
getMany :: Binary a =&gt; Int -&gt; Get [a]
getMany n = go [] n
 where
 go xs 0 = return $! reverse xs
 go xs i = do x &lt;- get
 x `seq` go (x:xs) (i-1)
{-# INLINE getMany #-}
</code></pre>

Now, a version that lets you stream (in binary) to append to a file would need to be eager or lazy. The lazy version is the most trivial. Something like:

<pre><code>import Data.Binary

newtype Stream a = Stream { unstream :: [a] }

instance Binary a =&gt; Binary (Stream a) where

 put (Stream []) = putWord8 0
 put (Stream (x:xs)) = putWord8 1 &gt;&gt; put x &gt;&gt; put (Stream xs)

 get = do
 t &lt;- getWord8
 case t of
 0 -&gt; return (Stream [])
 1 -&gt; do x &lt;- get
 Stream xs &lt;- get
 return (Stream (x:xs))
</code></pre>

Massaged appropriately works for streaming. Now, to handle silently appending, we'll need to be able to seek to the end of the file, and overwrite the final <code>0</code> tag, before adding more elements.

blocks|key|880907|text|这个问题已经被回答了四年了，但我遇到了与gatoatigrado在Don+Stewart的回答的评论中相同的问题。put方法按照所宣传的那样工作，但是get读取整个输入。我认为问题出在case语句Stream+xs+<-+get中的模式匹配上，该语句在返回之前必须确定剩余的get是否为Stream+a。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|880908|我的解决方案使用Data.Binary.Get中的示例作为起点：|880909|import+Data.ByteString.Lazy(toChunks,ByteString)
import+Data.Binary(Binary(..),getWord8)
import+Data.Binary.Get(pushChunk,Decoder(..),runGetIncremental)
import+Data.List(unfoldr)

decodes+::+Binary+a+=>+ByteString+->+[a]
decodes+=+runGets+(getWord8+>>+get)

runGets+::+Get+a+->+ByteString+->+[a]
runGets+g+=+unfoldr+(decode1+d)+.+toChunks
++where+d+=+runGetIncremental+g

decode1+_+[]+=+Nothing
decode1+d+(x:xs)+=+case+d+`pushChunk`+x+of
+++++++++++++++++++++Fail+_+_+str++->+error+str
+++++++++++++++++++++Done+x'+_+a+++->+Just+(a,x':xs)
+++++++++++++++++++++k@(Partial+_)+->+decode1+k+xs|code-block|syntax|javascript|880910|注意getWord8的用法这是为了读取编码的[]和:，它们是由流实例的put定义产生的。还要注意，因为getWord8忽略了编码的[]和:符号，所以这个实现不会检测到列表的结尾。我的编码文件只是一个单独的列表，所以它适用于此，但否则您将需要修改。|880911|在任何情况下，在访问head和last元素的两种情况下，此decodes都在常量内存中运行。|880912|entityMap^0|1L|3|23|3|2Q|G|3T|3|3Z|8|0|0|0|2|8|M|2|P|1|Z|3|0|T|7|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|14|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|15|8|@$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|R|$]]

It's four years since this question has been answered, but I ran into the same problems as gatoatigrado in the comment to Don Stewart's answer. The <code>put</code> method works as advertised, but <code>get</code> reads the whole input. I believe the problem lies in the pattern match in the case statement, <code>Stream xs &lt;- get</code>, which must determine whether or not the remaining <code>get</code> is a <code>Stream a</code> or not before returning. 

My solution used the example in Data.Binary.Get as a starting point:

<pre><code>import Data.ByteString.Lazy(toChunks,ByteString)
import Data.Binary(Binary(..),getWord8)
import Data.Binary.Get(pushChunk,Decoder(..),runGetIncremental)
import Data.List(unfoldr)

decodes :: Binary a =&gt; ByteString -&gt; [a]
decodes = runGets (getWord8 &gt;&gt; get)

runGets :: Get a -&gt; ByteString -&gt; [a]
runGets g = unfoldr (decode1 d) . toChunks
 where d = runGetIncremental g

decode1 _ [] = Nothing
decode1 d (x:xs) = case d `pushChunk` x of
 Fail _ _ str -&gt; error str
 Done x' _ a -&gt; Just (a,x':xs)
 k@(Partial _) -&gt; decode1 k xs
</code></pre>

Note the use of <code>getWord8</code> This is to read the encoded <code>[]</code> and <code>:</code> resulting from the definition of <code>put</code> for the stream instance. Also note, since getWord8 ignores the encoded [] and : symbols, this implementation will not detect the end of the list. My encoded file was just a single list so it works for that, but otherwise you'll need to modify.

In any case, this <code>decodes</code> ran in constant memory in both cases of accessing the head and last elements.

I've been using Data.Binary to serialize data to files. In my application I incrementally add items to these files. The two most popular serialization packages, binary and cereal, both serialize lists as a count followed by the list items. Because of this, I can't append to my serialized files. I currently read in the whole file, deserialize the list, append to the list, re-serialize the list, and write it back out to the file. However, my data set is getting large and I'm starting to run out of memory. I could probably go around unboxing my data structures to gain some space, but that approach doesn't scale.

One solution would be to get down and dirty with the file format to change the initial count, then just append my elements. But that's not very satisfying, not to mention being sensitive to future changes in the file format as a result of breaking the abstraction. Iteratees/Enumerators come to mind as an attractive option here. I looked for a library combining them with a binary serialization, but didn't find anything. Anyone know if this has been done already? If not, would a library for this be useful? Or am I missing something?

Binary Serialization for Lists of Undefined Length in Haskell

数据结构

我一直在使用Data.Binary将数据序列化为文件。在我的应用程序中，我逐渐地向这些文件中添加项目。两个最流行的序列化包，二进制和谷类，都将列表序列化为计数，然后是列表项。正因为如此，我不能附加到我的序列化文件。我目前读取了整个文件，反序列化列表，追加到列表，重新序列化列表，并将其写回文件。但是，我的数据集越来越大，...

问Haskell中未定义长度列表的二进制序列化
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Haskell中未定义长度列表的二进制序列化EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Haskell中未定义长度列表的二进制序列化
EN