diff --git a/binary.cabal b/binary.cabal --- a/binary.cabal +++ b/binary.cabal @@ -1,32 +1,33 @@ name: binary -version: 0.4.1 +version: 0.4.2 license: BSD3 license-file: LICENSE author: Lennart Kolmodin maintainer: Lennart Kolmodin, Don Stewart -homepage: http://www.cse.unsw.edu.au/~dons/binary.html +homepage: http://code.haskell.org/binary/ description: Efficient, pure binary serialisation using lazy ByteStrings. - Haskell values may be encoded to and form binary formats, + Haskell values may be encoded to and from binary formats, written to disk as binary, or sent over the network. Serialisation speeds of over 1 G\/sec have been observed, so this library should be suitable for high performance scenarios. -synopsis: Binary serialization for Haskell values using lazy ByteStrings +synopsis: Binary serialisation for Haskell values using lazy ByteStrings category: Data, Parsing stability: provisional build-type: Simple cabal-version: >= 1.2 tested-with: GHC ==6.4.2, GHC ==6.6.1, GHC ==6.8.0 -extra-source-files: README +extra-source-files: README index.html flag bytestring-in-base flag split-base +flag applicative-in-base library if flag(bytestring-in-base) -- bytestring was in base-2.0 and 2.1.1 build-depends: base >= 2.0 && < 2.2 - ghc-options: -DBYTESTRING_IN_BASE + cpp-options: -DBYTESTRING_IN_BASE else -- in base 1.0 and 3.0 bytestring is a separate package build-depends: base < 2.0 || >= 3, bytestring >= 0.9 @@ -36,6 +37,12 @@ else build-depends: base < 3.0 + if flag(applicative-in-base) + build-depends: base >= 2.0 + cpp-options: -DAPPLICATIVE_IN_BASE + else + build-depends: base < 2.0 + exposed-modules: Data.Binary, Data.Binary.Put, Data.Binary.Get, @@ -44,4 +51,4 @@ hs-source-dirs: src ghc-options: -O2 -Wall -fliberate-case-threshold=1000 if impl(ghc < 6.5) - ghc-options: -fallow-undecidable-instances + cpp-options: -fallow-undecidable-instances diff --git a/index.html b/index.html new file mode 100644 --- /dev/null +++ b/index.html @@ -0,0 +1,149 @@ + + + + + + Data.Binary - efficient, pure binary serialisation for Haskell + + + + + +
+ +

Data.Binary

+ +
+ +

About

+

+ Data.Binary is a library for high performance binary serialisation + of Haskell data. It uses the + ByteString library to achieve efficient, lazy reading and + writing of structures in binary format. +

+ +

Example

+ For example, to serialise an interpreter's abstract syntax tree to + binary format: +
import Data.Binary
+import Control.Monad
+import Codec.Compression.GZip
+
+-- A Haskell AST structure
+data Exp = IntE Int
+         | OpE  String Exp Exp
+   deriving Eq
+
+-- An instance of Binary to encode and decode an Exp in binary
+instance Binary Exp where
+     put (IntE i)          = put (0 :: Word8) >> put i
+     put (OpE s e1 e2)     = put (1 :: Word8) >> put s >> put e1 >> put e2
+     get = do tag <- getWord8
+              case tag of
+                  0 -> liftM  IntE get
+                  1 -> liftM3 OpE  get get get
+
+-- A test expression
+e = OpE "*" (IntE 7) (OpE "/" (IntE 4) (IntE 2))
+
+-- Serialise and compress with gzip, then decompress and deserialise
+main = do
+    let t  = compress (encode e)
+    print t
+    let e' = decode (decompress t)
+    print (e == e')
+
+ +

Download

+ + + +

stable release

+ + + + + + + + + + + +
+ binary 0.4.2 + (Apr 2008)
+ binary 0.4.1 + (Oct 2007)
+ binary 0.4 + (Oct 2007)
+ binary 0.3 + (Mar 2007)
+ binary 0.2 + (Jan 2007)
+

development branch

+ + +
+ darcs get http://code.haskell.org/binary +
+
+ +

Download

+ + +

Project Activity

+ +
+ binary commit statistics +
+ +

Starring...

+ + The Binary Strike Force +
    +
  • Lennart Kolmodin
    • +
  • Duncan Coutts
    • +
  • Don Stewart
    • +
  • Spencer Janssen
    • +
  • David Himmelstrup
    • +
  • Björn Bringert
    • +
  • Ross Paterson
    • +
  • Einar Karttunen
    • +
  • John Meacham
    • +
  • Ulf Norell
    • +
  • Bryan O'Sullivan
    • +
  • Tomasz Zielonka
    • +
  • Florian Weimer
    • +
  • Judah Jacobson
    • +
+ +
+ +covered by HPC +built with Cabal +tested with QuickCheck + +
+ + + + + + diff --git a/src/Data/Binary.hs b/src/Data/Binary.hs --- a/src/Data/Binary.hs +++ b/src/Data/Binary.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE CPP, FlexibleInstances #-} +{-# LANGUAGE CPP, FlexibleInstances, FlexibleContexts #-} ----------------------------------------------------------------------------- -- | -- Module : Data.Binary @@ -88,6 +88,7 @@ -- #if __GLASGOW_HASKELL__ >= 606 import qualified Data.Sequence as Seq +import qualified Data.Foldable as Fold #endif ------------------------------------------------------------------------ @@ -104,9 +105,10 @@ -- -- Instances of Binary should satisfy the following property: -- --- > get . put == id +-- > decode . encode == id -- --- A range of instances are provided for basic Haskell types. +-- That is, the 'get' and 'put' methods should be the inverse of each +-- other. A range of instances are provided for basic Haskell types. -- class Binary t where -- | Encode a value in the Put monad. @@ -638,10 +640,7 @@ instance (Binary e) => Binary (Seq.Seq e) where -- any better way to do this? - put s = put . flip unfoldr s $ \sq -> - case Seq.viewl sq of - Seq.EmptyL -> Nothing - (Seq.:<) e sq' -> Just (e,sq') + put = put . Fold.toList get = fmap Seq.fromList get #endif diff --git a/src/Data/Binary/Get.hs b/src/Data/Binary/Get.hs --- a/src/Data/Binary/Get.hs +++ b/src/Data/Binary/Get.hs @@ -69,7 +69,7 @@ ) where -import Control.Monad (when,liftM) +import Control.Monad (when,liftM,ap) import Control.Monad.Fix import Data.Maybe (isNothing) @@ -83,6 +83,10 @@ import qualified Data.ByteString.Lazy.Internal as L #endif +#ifdef APPLICATIVE_IN_BASE +import Control.Applicative (Applicative(..)) +#endif + import Foreign -- used by splitAtST @@ -106,6 +110,12 @@ instance Functor Get where fmap f m = Get (\s -> let (a, s') = unGet m s in (f a, s')) + +#ifdef APPLICATIVE_IN_BASE +instance Applicative Get where + pure = return + (<*>) = ap +#endif instance Monad Get where return a = Get (\s -> (a, s)) diff --git a/src/Data/Binary/Put.hs b/src/Data/Binary/Put.hs --- a/src/Data/Binary/Put.hs +++ b/src/Data/Binary/Put.hs @@ -52,6 +52,11 @@ import qualified Data.ByteString as S import qualified Data.ByteString.Lazy as L +#ifdef APPLICATIVE_IN_BASE +import Control.Applicative +#endif + + ------------------------------------------------------------------------ -- | The PutM type. A Writer monad over the efficient Builder monoid. @@ -63,6 +68,14 @@ instance Functor PutM where fmap f m = Put (let (a, w) = unPut m in (f a, w)) + +#ifdef APPLICATIVE_IN_BASE +instance Applicative PutM where + pure = return + m <*> k = Put (let (f, w) = unPut m + (x, w') = unPut k + in (f x, w `B.append` w')) +#endif instance Monad PutM where return a = Put (a, B.empty) diff --git a/tests/Makefile b/tests/Makefile --- a/tests/Makefile +++ b/tests/Makefile @@ -4,7 +4,7 @@ runhaskell QC.hs 1000 compiled: - ghc --make -O QC.hs -o qc -no-recomp -threaded + ghc --make -fhpc -O QC.hs -o qc -no-recomp -threaded time ./qc 500 +RTS -qw -N2 bench:: Benchmark.hs MemBench.hs CBenchmark.o