Personal tools

Binary IO

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(style)
(fixed dead links)
(3 intermediate revisions by 3 users not shown)
Line 1: Line 1:
There are a number of binary I/O libraries available for Haskell.
+
== Data.Binary ==
   
* JeremyShaw's update of HalDaume's NewBinary package (Cabalized): http://www.n-heptane.com/nhlab/repos/NewBinary
+
There are a number of binary I/O libraries available for Haskell. The
* [http://www.cse.unsw.edu.au/~dons/fps.html Data.ByteString] (Cabalised) also provides byte level operations, and is used in some applications for binary IO
+
best to use is the new, semi-standard Data.Binary library:
* [http://www.cs.helsinki.fi/u/ekarttun/SerTH/ SerTH], the TH version (sort of) of NewBinary.
 
* PeterSimons's BlockIO package (Cabalized): http://cryp.to/blockio/
 
* JohnGoerzen's MissingH package (Cabalized): http://quux.org/devel/missingh
 
* SimonMarlow's experimental NewIO package: http://www.haskell.org/~simonmar/new-io.tar.gz (documentation at http://www.haskell.org/~simonmar/io/)
 
   
For very simple serialisation, use <hask>read</hask> and <hask>show</hask>.
+
* [http://hackage.haskell.org/cgi-bin/hackage-scripts/package/binary Data.Binary]
   
If you have simple binary IO requirements, then Data.ByteString might be easiest -- you get a List-like interface to packed byte arrays (interface documented [http://www.cse.unsw.edu.au/~dons/fps/Data.FastPackedString.html here]). For more complex serialisation, NewBinary would be preferred. [[Lambdabot]] follows this rule: when serialising lists and maps, it uses Data.ByteStrings. For complex algebraic datatypes, NewBinary is used (see [http://www.cse.unsw.edu.au/~dons/code/lambdabot/Plugin/Seen.hs Plugin/Seen.hs] in Lambdabot).
+
It's very simple to use, and provides a highly efficient, pure interface
  +
to binary serialisation.
   
NewBinary is based on Binary.hs from GHC, and traces back to NHC's binary library, described in [ftp://ftp.cs.york.ac.uk/pub/malcolm/ismm98.html "The Bits Between The Lambdas"]. It is simple to use: for each value you wish to serialise/unserialise, you write an instance of Binary for its type. This can be automated with the DrIFT tool, which will derive binary for you (as is done in GHC's .hi files). You can rip out your own copy of Binary.hs from NewBinary -- just take Binary.hs and FastMutInt.lhs.
+
A tutorial:
   
Lamdabot, hmp3 and hs-plugins are applications written using NewBinary, and it fairly simple and effective. Here, for example, is the binary serialisation code for the [http://www.cse.unsw.edu.au/~dons/code/hmp3.html hmp3] database type, an Array, and a user defined type: File. Easy!
+
* [[Serialisation_and_compression_with_Data_Binary]]
   
<haskell>
+
See also [[DealingWithBinaryData]]
instance Binary a => Binary (Array Int a) where
 
put_ bh arr = do
 
put_ bh (bounds arr)
 
mapM_ (put_ bh) (elems arr)
 
get bh = do
 
((x,y) :: (Int,Int)) <- get bh
 
(els :: [a]) <- sequence $ take (y+1) $ repeat (get bh)
 
return $! listArray (x,y) els
 
   
instance Binary File where
+
== Other libraries ==
put_ bh (File nm i) = do
 
put_ bh nm
 
put_ bh i
 
get bh = do
 
nm <- get bh
 
i <- get bh
 
return (File nm i)
 
</haskell>
 
   
As an aside, SerTH lets you derive instance of a Binary-alike class automagically using TH, rather than requiring hand-written instances, or DrIFT.
+
* JeremyShaw's update of HalDaume's NewBinary package (Cabalized): http://www.n-heptane.com/nhlab/repos/NewBinary
  +
* [http://hackage.haskell.org/package/bytestring Data.ByteString] (Cabalised) also provides byte level operations, and is used in some applications for binary IO
  +
* [http://web.archive.org/web/20080123105519/http://www.cs.helsinki.fi/u/ekarttun/SerTH/ SerTH], the TH version (sort of) of NewBinary.
  +
* PeterSimons's BlockIO package (Cabalized): http://cryp.to/blockio/
  +
* JohnGoerzen's MissingH package (Cabalized): http://quux.org/devel/missingh
  +
* SimonMarlow's experimental NewIO package: http://www.haskell.org/~simonmar/new-io.tar.gz (documentation at http://www.haskell.org/~simonmar/io/)
  +
  +
For very simple serialisation, use <hask>read</hask> and <hask>show</hask>.
   
So, in summary. There are a number of ways to do binary IO in Haskell, efficiently and simply. It's really not that hard at all.
+
If you have simple binary IO requirements, then Data.ByteString might be easiest -- you get a List-like interface to packed byte arrays (interface documented [http://www.cse.unsw.edu.au/~dons/fps/Data.FastPackedString.html here]). For more complex serialisation, Data.Binary would be preferred.
   
 
[[Category:Tutorials]]
 
[[Category:Tutorials]]

Revision as of 21:33, 29 October 2011

1 Data.Binary

There are a number of binary I/O libraries available for Haskell. The best to use is the new, semi-standard Data.Binary library:

   * Data.Binary

It's very simple to use, and provides a highly efficient, pure interface to binary serialisation.

A tutorial:

   * Serialisation_and_compression_with_Data_Binary

See also DealingWithBinaryData

2 Other libraries

For very simple serialisation, use
read
and
show
.

If you have simple binary IO requirements, then Data.ByteString might be easiest -- you get a List-like interface to packed byte arrays (interface documented here). For more complex serialisation, Data.Binary would be preferred.