Sophie: ghc-7.4.2-4.mga5 i586

ghc-7.4.2-4.mga5.i586.rpm

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><title>Data.Binary</title><link href="ocean.css" rel="stylesheet" type="text/css" title="Ocean" /><script src="haddock-util.js" type="text/javascript"></script><script type="text/javascript">//<![CDATA[
window.onload = function () {pageLoad();setSynopsis("mini_Data-Binary.html");};
//]]>
</script></head><body><div id="package-header"><ul class="links" id="page-menu"><li><a href="index.html">Contents</a></li><li><a href="doc-index.html">Index</a></li></ul><p class="caption">binary-0.5.1.0: Binary serialisation for Haskell values using lazy ByteStrings</p></div><div id="content"><div id="module-header"><table class="info"><tr><th>Portability</th><td>portable to Hugs and GHC. Requires the FFI and some flexible instances</td></tr><tr><th>Stability</th><td>unstable</td></tr><tr><th>Maintainer</th><td>Lennart Kolmodin &lt;kolmodin@dtek.chalmers.se&gt;</td></tr><tr><th>Safe Haskell</th><td>Trustworthy</td></tr></table><p class="caption">Data.Binary</p></div><div id="table-of-contents"><p class="caption">Contents</p><ul><li><a href="#g:1">The Binary class
</a></li><li><a href="#g:2">The Get and Put monads
</a></li><li><a href="#g:3">Useful helpers for writing instances
</a></li><li><a href="#g:4">Binary serialisation
</a></li><li><a href="#g:5">IO functions for serialisation
</a></li></ul></div><div id="description"><p class="caption">Description</p><div class="doc"><p>Binary serialisation of Haskell values to and from lazy ByteStrings.
 The Binary library provides methods for encoding Haskell values as
 streams of bytes directly in memory. The resulting <code>ByteString</code> can
 then be written to disk, sent over the network, or futher processed
 (for example, compressed with gzip).
</p><p>The <code><a href="Data-Binary.html#t:Binary">Binary</a></code> package is notable in that it provides both pure, and
 high performance serialisation.
</p><p>Values are always encoded in network order (big endian) form, and
 encoded data should be portable across machine endianess, word size,
 or compiler version. For example, data encoded using the Binary class
 could be written from GHC, and read back in Hugs.
</p></div></div><div id="synopsis"><p id="control.syn" class="caption expander" onclick="toggleSection('syn')">Synopsis</p><ul id="section.syn" class="hide" onclick="toggleSection('syn')"><li class="src short"><span class="keyword">class</span>  <a href="#t:Binary">Binary</a> t  <span class="keyword">where</span><ul class="subs"><li><a href="#v:put">put</a> :: t -&gt; <a href="Data-Binary.html#t:Put">Put</a></li><li><a href="#v:get">get</a> :: <a href="Data-Binary.html#t:Get">Get</a> t</li></ul></li><li class="src short"><span class="keyword">data</span>  <a href="#t:Get">Get</a> a</li><li class="src short"><span class="keyword">type</span> <a href="#t:Put">Put</a> = <a href="Data-Binary-Put.html#t:PutM">PutM</a> ()</li><li class="src short"><a href="#v:putWord8">putWord8</a> :: <a href="../base-4.5.1.0/Data-Word.html#t:Word8">Word8</a> -&gt; <a href="Data-Binary.html#t:Put">Put</a></li><li class="src short"><a href="#v:getWord8">getWord8</a> :: <a href="Data-Binary.html#t:Get">Get</a> <a href="../base-4.5.1.0/Data-Word.html#t:Word8">Word8</a></li><li class="src short"><a href="#v:encode">encode</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; a -&gt; <a href="../bytestring-0.9.2.1/Data-ByteString-Lazy.html#t:ByteString">ByteString</a></li><li class="src short"><a href="#v:decode">decode</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="../bytestring-0.9.2.1/Data-ByteString-Lazy.html#t:ByteString">ByteString</a> -&gt; a</li><li class="src short"><a href="#v:encodeFile">encodeFile</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="../base-4.5.1.0/System-IO.html#t:FilePath">FilePath</a> -&gt; a -&gt; <a href="../base-4.5.1.0/System-IO.html#t:IO">IO</a> ()</li><li class="src short"><a href="#v:decodeFile">decodeFile</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="../base-4.5.1.0/System-IO.html#t:FilePath">FilePath</a> -&gt; <a href="../base-4.5.1.0/System-IO.html#t:IO">IO</a> a</li><li class="src short">module <a href="../base-4.5.1.0/Data-Word.html">Data.Word</a></li></ul></div><div id="interface"><h1 id="g:1">The Binary class
</h1><div class="top"><p class="src"><span class="keyword">class</span>  <a name="t:Binary" class="def">Binary</a> t  <span class="keyword">where</span></p><div class="doc"><p>The <code>Binary</code> class provides <code><a href="Data-Binary.html#v:put">put</a></code> and <code><a href="Data-Binary.html#v:get">get</a></code>, methods to encode and
 decode a Haskell value to a lazy ByteString. It mirrors the Read and
 Show classes for textual representation of Haskell types, and is
 suitable for serialising Haskell values to disk, over the network.
</p><p>For parsing and generating simple external binary formats (e.g. C
 structures), Binary may be used, but in general is not suitable
 for complex protocols. Instead use the Put and Get primitives
 directly.
</p><p>Instances of Binary should satisfy the following property:
</p><pre> decode . encode == id
</pre><p>That is, the <code><a href="Data-Binary.html#v:get">get</a></code> and <code><a href="Data-Binary.html#v:put">put</a></code> methods should be the inverse of each
 other. A range of instances are provided for basic Haskell types. 
</p></div><div class="subs methods"><p class="caption">Methods</p><p class="src"><a name="v:put" class="def">put</a> :: t -&gt; <a href="Data-Binary.html#t:Put">Put</a></p><div class="doc"><p>Encode a value in the Put monad.
</p></div><p class="src"><a name="v:get" class="def">get</a> :: <a href="Data-Binary.html#t:Get">Get</a> t</p><div class="doc"><p>Decode a value in the Get monad
</p></div></div><div class="subs instances"><p id="control.i:Binary" class="caption collapser" onclick="toggleSection('i:Binary')">Instances</p><div id="section.i:Binary" class="show"><table><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Bool.html#t:Bool">Bool</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Char.html#t:Char">Char</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Prelude.html#t:Double">Double</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Prelude.html#t:Float">Float</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Int.html#t:Int">Int</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Int.html#t:Int8">Int8</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Int.html#t:Int16">Int16</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Int.html#t:Int32">Int32</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Int.html#t:Int64">Int64</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Prelude.html#t:Integer">Integer</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Ord.html#t:Ordering">Ordering</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Word.html#t:Word">Word</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Word.html#t:Word8">Word8</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Word.html#t:Word16">Word16</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Word.html#t:Word32">Word32</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../base-4.5.1.0/Data-Word.html#t:Word64">Word64</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> ()</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../bytestring-0.9.2.1/Data-ByteString-Lazy.html#t:ByteString">ByteString</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../bytestring-0.9.2.1/Data-ByteString.html#t:ByteString">ByteString</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> <a href="../containers-0.4.2.1/Data-IntSet.html#t:IntSet">IntSet</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> [a]</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="../base-4.5.1.0/Prelude.html#t:Integral">Integral</a> a) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../base-4.5.1.0/Data-Ratio.html#t:Ratio">Ratio</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../base-4.5.1.0/Data-Maybe.html#t:Maybe">Maybe</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> e =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../containers-0.4.2.1/Data-Tree.html#t:Tree">Tree</a> e)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> e =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../containers-0.4.2.1/Data-Sequence.html#t:Seq">Seq</a> e)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="Data-Binary.html#t:Binary">Binary</a> e =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../containers-0.4.2.1/Data-IntMap.html#t:IntMap">IntMap</a> e)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="../base-4.5.1.0/Data-Ord.html#t:Ord">Ord</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> a) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../containers-0.4.2.1/Data-Set.html#t:Set">Set</a> a)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../base-4.5.1.0/Data-Either.html#t:Either">Either</a> a b)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> i, <a href="../base-4.5.1.0/Data-Ix.html#t:Ix">Ix</a> i, <a href="Data-Binary.html#t:Binary">Binary</a> e, <a href="../array-0.4.0.0/Data-Array-IArray.html#t:IArray">IArray</a> <a href="../array-0.4.0.0/Data-Array-Unboxed.html#t:UArray">UArray</a> e) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../array-0.4.0.0/Data-Array-Unboxed.html#t:UArray">UArray</a> i e)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> i, <a href="../base-4.5.1.0/Data-Ix.html#t:Ix">Ix</a> i, <a href="Data-Binary.html#t:Binary">Binary</a> e) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../array-0.4.0.0/Data-Array.html#t:Array">Array</a> i e)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="../base-4.5.1.0/Data-Ord.html#t:Ord">Ord</a> k, <a href="Data-Binary.html#t:Binary">Binary</a> k, <a href="Data-Binary.html#t:Binary">Binary</a> e) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (<a href="../containers-0.4.2.1/Data-Map.html#t:Map">Map</a> k e)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c, <a href="Data-Binary.html#t:Binary">Binary</a> d) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c, d)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c, <a href="Data-Binary.html#t:Binary">Binary</a> d, <a href="Data-Binary.html#t:Binary">Binary</a> e) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c, d, e)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c, <a href="Data-Binary.html#t:Binary">Binary</a> d, <a href="Data-Binary.html#t:Binary">Binary</a> e, <a href="Data-Binary.html#t:Binary">Binary</a> f) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c, d, e, f)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c, <a href="Data-Binary.html#t:Binary">Binary</a> d, <a href="Data-Binary.html#t:Binary">Binary</a> e, <a href="Data-Binary.html#t:Binary">Binary</a> f, <a href="Data-Binary.html#t:Binary">Binary</a> g) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c, d, e, f, g)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c, <a href="Data-Binary.html#t:Binary">Binary</a> d, <a href="Data-Binary.html#t:Binary">Binary</a> e, <a href="Data-Binary.html#t:Binary">Binary</a> f, <a href="Data-Binary.html#t:Binary">Binary</a> g, <a href="Data-Binary.html#t:Binary">Binary</a> h) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c, d, e, f, g, h)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c, <a href="Data-Binary.html#t:Binary">Binary</a> d, <a href="Data-Binary.html#t:Binary">Binary</a> e, <a href="Data-Binary.html#t:Binary">Binary</a> f, <a href="Data-Binary.html#t:Binary">Binary</a> g, <a href="Data-Binary.html#t:Binary">Binary</a> h, <a href="Data-Binary.html#t:Binary">Binary</a> i) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c, d, e, f, g, h, i)</td><td class="doc empty">&nbsp;</td></tr><tr><td class="src">(<a href="Data-Binary.html#t:Binary">Binary</a> a, <a href="Data-Binary.html#t:Binary">Binary</a> b, <a href="Data-Binary.html#t:Binary">Binary</a> c, <a href="Data-Binary.html#t:Binary">Binary</a> d, <a href="Data-Binary.html#t:Binary">Binary</a> e, <a href="Data-Binary.html#t:Binary">Binary</a> f, <a href="Data-Binary.html#t:Binary">Binary</a> g, <a href="Data-Binary.html#t:Binary">Binary</a> h, <a href="Data-Binary.html#t:Binary">Binary</a> i, <a href="Data-Binary.html#t:Binary">Binary</a> j) =&gt; <a href="Data-Binary.html#t:Binary">Binary</a> (a, b, c, d, e, f, g, h, i, j)</td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="doc"><p>To serialise a custom type, an instance of Binary for that type is
 required. For example, suppose we have a data structure:
</p><pre> data Exp = IntE Int
          | OpE  String Exp Exp
    deriving Show
</pre><p>We can encode values of this type into bytestrings using the
 following instance, which proceeds by recursively breaking down the
 structure to serialise:
</p><pre> instance Binary Exp where
       put (IntE i)          = do put (0 :: Word8)
                                  put i
       put (OpE s e1 e2)     = do put (1 :: Word8)
                                  put s
                                  put e1
                                  put e2
 
       get = do t &lt;- get :: Get Word8
                case t of
                     0 -&gt; do i &lt;- get
                             return (IntE i)
                     1 -&gt; do s  &lt;- get
                             e1 &lt;- get
                             e2 &lt;- get
                             return (OpE s e1 e2)
</pre><p>Note how we write an initial tag byte to indicate each variant of the
 data type.
</p><p>We can simplify the writing of <code><a href="Data-Binary.html#v:get">get</a></code> instances using monadic
 combinators:
</p><pre>       get = do tag &lt;- getWord8
                case tag of
                    0 -&gt; liftM  IntE get
                    1 -&gt; liftM3 OpE  get get get
</pre><p>The generation of Binary instances has been automated by a script
 using Scrap Your Boilerplate generics. Use the script here:
  <a href="http://darcs.haskell.org/binary/tools/derive/BinaryDerive.hs">http://darcs.haskell.org/binary/tools/derive/BinaryDerive.hs</a>.
</p><p>To derive the instance for a type, load this script into GHCi, and
 bring your type into scope. Your type can then have its Binary
 instances derived as follows:
</p><pre> $ ghci -fglasgow-exts BinaryDerive.hs
 *BinaryDerive&gt; :l Example.hs
 *Main&gt; deriveM (undefined :: Drinks)

 instance Binary Main.Drinks where
      put (Beer a) = putWord8 0 &gt;&gt; put a
      put Coffee = putWord8 1
      put Tea = putWord8 2
      put EnergyDrink = putWord8 3
      put Water = putWord8 4
      put Wine = putWord8 5
      put Whisky = putWord8 6
      get = do
        tag_ &lt;- getWord8
        case tag_ of
          0 -&gt; get &gt;&gt;= \a -&gt; return (Beer a)
          1 -&gt; return Coffee
          2 -&gt; return Tea
          3 -&gt; return EnergyDrink
          4 -&gt; return Water
          5 -&gt; return Wine
          6 -&gt; return Whisky

</pre><p>To serialise this to a bytestring, we use <code><a href="Data-Binary.html#v:encode">encode</a></code>, which packs the
 data structure into a binary format, in a lazy bytestring
</p><pre> &gt; let e = OpE &quot;*&quot; (IntE 7) (OpE &quot;/&quot; (IntE 4) (IntE 2))
 &gt; let v = encode e
</pre><p>Where <code>v</code> is a binary encoded data structure. To reconstruct the
 original data, we use <code><a href="Data-Binary.html#v:decode">decode</a></code>
</p><pre> &gt; decode v :: Exp
 OpE &quot;*&quot; (IntE 7) (OpE &quot;/&quot; (IntE 4) (IntE 2))
</pre><p>The lazy ByteString that results from <code><a href="Data-Binary.html#v:encode">encode</a></code> can be written to
 disk, and read from disk using Data.ByteString.Lazy IO functions,
 such as hPutStr or writeFile:
</p><pre> &gt; writeFile &quot;/tmp/exp.txt&quot; (encode e)
</pre><p>And read back with:
</p><pre> &gt; readFile &quot;/tmp/exp.txt&quot; &gt;&gt;= return . decode :: IO Exp
 OpE &quot;*&quot; (IntE 7) (OpE &quot;/&quot; (IntE 4) (IntE 2))
</pre><p>We can also directly serialise a value to and from a Handle, or a file:
</p><pre> &gt; v &lt;- decodeFile  &quot;/tmp/exp.txt&quot; :: IO Exp
 OpE &quot;*&quot; (IntE 7) (OpE &quot;/&quot; (IntE 4) (IntE 2))
</pre><p>And write a value to disk
</p><pre> &gt; encodeFile &quot;/tmp/a.txt&quot; v
</pre></div><h1 id="g:2">The Get and Put monads
</h1><div class="top"><p class="src"><span class="keyword">data</span>  <a name="t:Get" class="def">Get</a> a </p><div class="doc"><p>The Get monad is just a State monad carrying around the input ByteString
 We treat it as a strict state monad. 
</p></div><div class="subs instances"><p id="control.i:Get" class="caption collapser" onclick="toggleSection('i:Get')">Instances</p><div id="section.i:Get" class="show"><table><tr><td class="src"><a href="../base-4.5.1.0/Control-Monad.html#t:Monad">Monad</a> <a href="Data-Binary.html#t:Get">Get</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="../base-4.5.1.0/Control-Monad.html#t:Functor">Functor</a> <a href="Data-Binary.html#t:Get">Get</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="../base-4.5.1.0/Control-Monad-Fix.html#t:MonadFix">MonadFix</a> <a href="Data-Binary.html#t:Get">Get</a></td><td class="doc empty">&nbsp;</td></tr><tr><td class="src"><a href="../base-4.5.1.0/Control-Applicative.html#t:Applicative">Applicative</a> <a href="Data-Binary.html#t:Get">Get</a></td><td class="doc empty">&nbsp;</td></tr></table></div></div></div><div class="top"><p class="src"><span class="keyword">type</span> <a name="t:Put" class="def">Put</a> = <a href="Data-Binary-Put.html#t:PutM">PutM</a> ()</p><div class="doc"><p>Put merely lifts Builder into a Writer monad, applied to ().
</p></div></div><h1 id="g:3">Useful helpers for writing instances
</h1><div class="top"><p class="src"><a name="v:putWord8" class="def">putWord8</a> :: <a href="../base-4.5.1.0/Data-Word.html#t:Word8">Word8</a> -&gt; <a href="Data-Binary.html#t:Put">Put</a></p><div class="doc"><p>Efficiently write a byte into the output buffer
</p></div></div><div class="top"><p class="src"><a name="v:getWord8" class="def">getWord8</a> :: <a href="Data-Binary.html#t:Get">Get</a> <a href="../base-4.5.1.0/Data-Word.html#t:Word8">Word8</a></p><div class="doc"><p>Read a Word8 from the monad state
</p></div></div><h1 id="g:4">Binary serialisation
</h1><div class="top"><p class="src"><a name="v:encode" class="def">encode</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; a -&gt; <a href="../bytestring-0.9.2.1/Data-ByteString-Lazy.html#t:ByteString">ByteString</a></p><div class="doc"><p>Encode a value using binary serialisation to a lazy ByteString.
</p></div></div><div class="top"><p class="src"><a name="v:decode" class="def">decode</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="../bytestring-0.9.2.1/Data-ByteString-Lazy.html#t:ByteString">ByteString</a> -&gt; a</p><div class="doc"><p>Decode a value from a lazy ByteString, reconstructing the original structure.
</p></div></div><h1 id="g:5">IO functions for serialisation
</h1><div class="top"><p class="src"><a name="v:encodeFile" class="def">encodeFile</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="../base-4.5.1.0/System-IO.html#t:FilePath">FilePath</a> -&gt; a -&gt; <a href="../base-4.5.1.0/System-IO.html#t:IO">IO</a> ()</p><div class="doc"><p>Lazily serialise a value to a file
</p><p>This is just a convenience function, it's defined simply as:
</p><pre> encodeFile f = B.writeFile f . encode
</pre><p>So for example if you wanted to compress as well, you could use:
</p><pre> B.writeFile f . compress . encode
</pre></div></div><div class="top"><p class="src"><a name="v:decodeFile" class="def">decodeFile</a> :: <a href="Data-Binary.html#t:Binary">Binary</a> a =&gt; <a href="../base-4.5.1.0/System-IO.html#t:FilePath">FilePath</a> -&gt; <a href="../base-4.5.1.0/System-IO.html#t:IO">IO</a> a</p><div class="doc"><p>Lazily reconstruct a value previously written to a file.
</p><p>This is just a convenience function, it's defined simply as:
</p><pre> decodeFile f = return . decode =&lt;&lt; B.readFile f
</pre><p>So for example if you wanted to decompress as well, you could use:
</p><pre> return . decode . decompress =&lt;&lt; B.readFile f
</pre><p>After contructing the data from the input file, <code><a href="Data-Binary.html#v:decodeFile">decodeFile</a></code> checks
 if the file is empty, and in doing so will force the associated file
 handle closed, if it is indeed empty. If the file is not empty, 
 it is up to the decoding instance to consume the rest of the data,
 or otherwise finalise the resource.
</p></div></div><div class="top"><p class="src">module <a href="../base-4.5.1.0/Data-Word.html">Data.Word</a></p></div></div></div><div id="footer"><p>Produced by <a href="http://www.haskell.org/haddock/">Haddock</a> version 2.11.0</p></div></body></html>