diff --git a/cereal.cabal b/cereal.cabal
--- a/cereal.cabal
+++ b/cereal.cabal
@@ -1,5 +1,5 @@
 name:                   cereal
-version:                0.2
+version:                0.3.0.0
 license:                BSD3
 license-file:           LICENSE
 author:                 Lennart Kolmodin <kolmodin@dtek.chalmers.se>, Galois Inc.
diff --git a/src/Data/Serialize.hs b/src/Data/Serialize.hs
--- a/src/Data/Serialize.hs
+++ b/src/Data/Serialize.hs
@@ -20,20 +20,12 @@
 
     -- $example
 
-    -- * The Get and Put monads
-    , Get
-    , Put
-    , Putter
-
-    -- * Useful helpers for writing instances
-    , putWord8
-    , getWord8
-
     -- * Serialize serialisation
     , encode
     , decode
 
-    , module Data.Word -- useful
+    , module Data.Serialize.Get
+    , module Data.Serialize.Put
 
     ) where
 
@@ -70,12 +62,13 @@
 ------------------------------------------------------------------------
 -- Wrappers to run the underlying monad
 
--- | Encode a value using binary serialisation to a lazy ByteString.
+-- | Encode a value using binary serialisation to a strict ByteString.
 --
 encode :: Serialize a => a -> ByteString
 encode = runPut . put
 
--- | Decode a value from a lazy ByteString, reconstructing the original structure.
+-- | Decode a value from a strict ByteString, reconstructing the original
+-- structure.
 --
 decode :: Serialize a => ByteString -> Either String a
 decode = runGet get
diff --git a/src/Data/Serialize/Get.hs b/src/Data/Serialize/Get.hs
--- a/src/Data/Serialize/Get.hs
+++ b/src/Data/Serialize/Get.hs
@@ -149,7 +149,7 @@
 put s = Get (\_ _ k -> k s ())
 
 label :: String -> Get a -> Get a
-label l m = Get (\s0 f k -> unGet m s0 (\ls s -> f (l:ls) s) k)
+label l m = Get (\s0 f k -> unGet m s0 (\ls -> f (l:ls)) k)
 
 finalK :: Success a a
 finalK s a = Right (a,s)
@@ -179,8 +179,8 @@
 
 -- | Isolate an action to operating within a fixed block of bytes.  The action
 --   is required to consume all the bytes that it is isolated to.
-isolate :: String -> Int -> Get a -> Get a
-isolate l n m = label l $ do
+isolate :: Int -> Get a -> Get a
+isolate n m = do
   when (n < 0) (fail "Attempted to isolate a negative number of bytes")
   s <- get
   let left = B.length s
@@ -272,7 +272,7 @@
   return $! B.copy bs
 
 getLazyByteString :: Int64 -> Get L.ByteString
-getLazyByteString n = f `fmap` getBytes (fromIntegral n)
+getLazyByteString n = f `fmap` getByteString (fromIntegral n)
   where f bs = L.fromChunks [bs]
 
 
@@ -293,13 +293,13 @@
 -- Primtives
 
 -- helper, get a raw Ptr onto a strict ByteString copied out of the
--- underlying lazy byteString. So many indirections from the raw parser
--- state that my head hurts...
+-- underlying strict byteString.
 
 getPtr :: Storable a => Int -> Get a
 getPtr n = do
     (fp,o,_) <- B.toForeignPtr `fmap` getBytes n
-    return . B.inlinePerformIO $ withForeignPtr fp $ \p -> peek (castPtr $ p `plusPtr` o)
+    let k p = peek (castPtr (p `plusPtr` o))
+    return (B.inlinePerformIO (withForeignPtr fp k))
 
 ------------------------------------------------------------------------