diff --git a/cassava-conduit.cabal b/cassava-conduit.cabal
--- a/cassava-conduit.cabal
+++ b/cassava-conduit.cabal
@@ -1,5 +1,5 @@
 name:               cassava-conduit
-version:            0.3.4
+version:            0.3.5
 license:            BSD3
 license-file:       etc/LICENCE.md
 author:             Dom De Re
@@ -56,8 +56,13 @@
     main-is:            Main.hs
     hs-source-dirs:     quickcheck
     build-depends:      base                >= 4 && < 5
-                    ,   QuickCheck          == 2.9.*
-                    ,   cassava-conduit
+                      , bytestring          == 0.10.*
+                      , cassava             == 0.4.*
+                      , conduit             == 1.2.*
+                      , conduit-extra       == 1.1.*
+                      , QuickCheck          == 2.9.*
+                      , text                == 1.2.*
+                      , cassava-conduit
 
 benchmark               benchmarks
     default-language:   Haskell2010
diff --git a/quickcheck/Main.hs b/quickcheck/Main.hs
--- a/quickcheck/Main.hs
+++ b/quickcheck/Main.hs
@@ -1,5 +1,7 @@
 module Main where
 
+import qualified Test.Data.Csv.Conduit
+
 import Control.Monad
 
 import System.Exit
@@ -7,5 +9,5 @@
 
 main :: IO ()
 main = hSetBuffering stdout LineBuffering >> mapM id
-    [
-    ] >>= \rs -> when (not . all id $ rs) exitFailure
+  [ Test.Data.Csv.Conduit.tests
+  ] >>= \rs -> when (not . all id $ rs) exitFailure
diff --git a/src/Data/Csv/Conduit.hs b/src/Data/Csv/Conduit.hs
--- a/src/Data/Csv/Conduit.hs
+++ b/src/Data/Csv/Conduit.hs
@@ -10,44 +10,45 @@
 --
 -------------------------------------------------------------------
 module Data.Csv.Conduit (
-    -- * Types
-        CsvParseError(..)
-    ,   CsvStreamHaltParseError(..)
-    ,   CsvStreamRecordParseError(..)
-    -- * Conduits
-    ,   fromCsv
-    ,   fromCsvLiftError
-    ,   fromNamedCsv
-    ,   fromNamedCsvLiftError
-    ,   fromCsvStreamError
-    ,   fromNamedCsvStreamError
-    ,   toCsv
-    ) where
+  -- * Types
+    CsvParseError(..)
+  , CsvStreamHaltParseError(..)
+  , CsvStreamRecordParseError(..)
+  -- * Conduits
+  , fromCsv
+  , fromCsvLiftError
+  , fromNamedCsv
+  , fromNamedCsvLiftError
+  , fromCsvStreamError
+  , fromNamedCsvStreamError
+  , toCsv
+  ) where
 
 import LocalPrelude
 
-import Control.Monad.Trans ( MonadTrans(..) )
-import Control.Monad.Error.Class ( MonadError(..) )
-import Data.Bifunctor ( first )
+import Control.Monad.Trans (MonadTrans(..))
+import Control.Monad.Error.Class (MonadError(..))
+import Data.Bifunctor (first)
 import qualified Data.ByteString as BS
 import qualified Data.ByteString.Lazy as BSL
-import Data.Conduit ( Conduit, await, yield )
-import Data.Conduit.List ( map, mapM )
-import Data.Csv ( FromNamedRecord, FromRecord, ToRecord, DecodeOptions, EncodeOptions, HasHeader, encodeWith )
-import Data.Csv.Incremental ( HeaderParser(..), Parser(..), decodeByNameWith, decodeWith )
-import Data.Foldable ( mapM_ )
+import Data.Conduit (Conduit, await, yield)
+import Data.Conduit.List (map, mapM)
+import Data.Csv (FromNamedRecord, FromRecord, ToRecord, DecodeOptions, EncodeOptions, HasHeader, encodeWith)
+import Data.Csv.Incremental (HeaderParser(..), Parser(..), decodeByNameWith, decodeWith)
+import Data.Foldable (mapM_)
 import qualified Data.Text as T
 
 data CsvParseError =
-        CsvParseError BS.ByteString T.Text
-    |   IncrementalError T.Text
-        deriving (Show, Eq)
+    CsvParseError BS.ByteString T.Text
+  | IncrementalError T.Text
+    deriving (Show, Eq)
 
 -- | When you want to include errors in the stream, this error type represents errors that halt the stream.
 -- They do not appear inside the conduit and will instead get returned from running the conduit.
 --
-data CsvStreamHaltParseError = HaltingCsvParseError BS.ByteString T.Text -- ^ the remaining bytestring that was read in but not parsed yet, and the stringy error msg describing the fail.
-    deriving (Show, Eq)
+data CsvStreamHaltParseError =
+  HaltingCsvParseError BS.ByteString T.Text -- ^ the remaining bytestring that was read in but not parsed yet, and the stringy error msg describing the fail.
+  deriving (Show, Eq)
 
 -- | When you want to include errors in the stream, these are the errors that can be included in the stream,
 -- they are usually problems restricted to individual records, and streaming can resume from the next record
@@ -116,45 +117,45 @@
 streamParser :: (MonadError e m) => (CsvStreamHaltParseError -> e) -> Parser a -> Conduit BS.ByteString m (Either CsvStreamRecordParseError a)
 streamParser f (Fail rest errMsg)   = {-# SCC streamParser_Fail_p #-} lift . throwError . f $ HaltingCsvParseError rest (T.pack errMsg)
 streamParser f (Many rs p)          = {-# SCC streamParser_Many_p #-} do
-    -- send the results down the stream..
-    mapM_ (yield . first (CsvStreamRecordParseError . T.pack)) rs
-    -- wait for more..
-    more <- await
-    maybe (return ()) (streamParser f . p) more
+  -- send the results down the stream..
+  mapM_ (yield . first (CsvStreamRecordParseError . T.pack)) rs
+  -- wait for more..
+  more <- await
+  maybe (return ()) (streamParser f . p) more
 streamParser _ (Done rs)            = {-# SCC streamParser_Done_p #-} mapM_ (yield . first (CsvStreamRecordParseError . T.pack)) rs
 
 terminatingStreamHeaderParser
-    :: (Monad m, MonadError e m)
-    => (CsvParseError -> e)
-    -> HeaderParser (Parser a)
-    -> Conduit BS.ByteString m a
+  :: (Monad m, MonadError e m)
+  => (CsvParseError -> e)
+  -> HeaderParser (Parser a)
+  -> Conduit BS.ByteString m a
 terminatingStreamHeaderParser f (FailH rest errMsg)   = {-# SCC terminatingStreamHeaderParser_FailH_p #-} lift . throwError . f . CsvParseError rest . T.pack $ errMsg
 terminatingStreamHeaderParser f (PartialH p)          = {-# SCC terminatingStreamHeaderParser_PartialH_p #-} await >>= maybe (return ()) (terminatingStreamHeaderParser f . p)
 terminatingStreamHeaderParser f (DoneH _ p)           = {-# SCC terminatingStreamHeaderParser_DoneH_p #-} terminatingStreamParser f p
 
 terminatingStreamParser
-    :: (Monad m, MonadError e m)
-    => (CsvParseError -> e)
-    -> Parser a
-    -> Conduit BS.ByteString m a
+  :: (Monad m, MonadError e m)
+  => (CsvParseError -> e)
+  -> Parser a
+  -> Conduit BS.ByteString m a
 terminatingStreamParser f (Fail rest errMsg)    = {-# SCC terminatingStreamParser_Fail_p #-} lift . throwError . f . CsvParseError rest . T.pack $ errMsg
 terminatingStreamParser f (Many ers p)          = {-# SCC terminatingStreamParser_Many_p #-}
-    let
-        errorHandler :: (Monad m, MonadError e m) => (CsvParseError -> e) -> String -> Conduit BS.ByteString m a
-        errorHandler f' = mapM . const . throwError . f' . IncrementalError . T.pack
+  let
+    errorHandler :: (Monad m, MonadError e m) => (CsvParseError -> e) -> String -> Conduit BS.ByteString m a
+    errorHandler f' = mapM . const . throwError . f' . IncrementalError . T.pack
 
-        safeResultHandler
-            :: (Monad m)
-            => (BS.ByteString -> Parser a)
-            -> (Parser a -> Conduit BS.ByteString m a)
-            -> [a]
-            -> Conduit BS.ByteString m a
-        safeResultHandler p' f' rs = do
-            mapM_ yield rs
-            -- wait for more..
-            await >>= maybe (return ()) (f' . p')
-    in
-        -- send the results down the stream..
-        either (errorHandler f) (safeResultHandler p (terminatingStreamParser f)) (sequence ers)
+    safeResultHandler
+      :: (Monad m)
+      => (BS.ByteString -> Parser a)
+      -> (Parser a -> Conduit BS.ByteString m a)
+      -> [a]
+      -> Conduit BS.ByteString m a
+    safeResultHandler p' f' rs = do
+      mapM_ yield rs
+      -- wait for more..
+      await >>= f' . p' . fromMaybe BS.empty
+  in
+    -- send the results down the stream..
+    either (errorHandler f) (safeResultHandler p (terminatingStreamParser f)) (sequence ers)
 terminatingStreamParser f (Done rs) = {-# SCC terminatingStreamParser_Done_p #-} either (lift . throwError . f . IncrementalError . T.pack) (mapM_ yield) (sequence rs)
 
diff --git a/src/LocalPrelude.hs b/src/LocalPrelude.hs
--- a/src/LocalPrelude.hs
+++ b/src/LocalPrelude.hs
@@ -9,37 +9,39 @@
 --
 -------------------------------------------------------------------
 module LocalPrelude (
-    -- * Type Classes
-        Functor(..)
-    ,   A.Applicative(..)
-    ,   Monad(..)
-    ,   Num(..)
-    ,   Show(..)
-    ,   Eq(..)
-    -- * Types
-    ,   Char
-    ,   Either(..)
-    ,   Int
-    ,   IO
-    ,   Maybe(..)
-    ,   String
-    ,   Word8
-    -- * Operators
-    ,   (.)
-    ,   ($)
-    ,   ($!)
-    ,   (<$>)
-    ,   (++)
-    -- * Functions
-    ,   id
-    ,   const
-    ,   either
-    ,   flip
-    ,   fromIntegral
-    ,   maybe
-    ,   sequence
-    ) where
+  -- * Type Classes
+    Functor(..)
+  , A.Applicative(..)
+  , Monad(..)
+  , Num(..)
+  , Show(..)
+  , Eq(..)
+  -- * Types
+  , Char
+  , Either(..)
+  , Int
+  , IO
+  , Maybe(..)
+  , String
+  , Word8
+  -- * Operators
+  , (.)
+  , ($)
+  , ($!)
+  , (<$>)
+  , (++)
+  -- * Functions
+  , id
+  , const
+  , either
+  , flip
+  , fromIntegral
+  , fromMaybe
+  , maybe
+  , sequence
+  ) where
 
 import Prelude
 import Control.Applicative as A
+import Data.Maybe (fromMaybe)
 import Data.Word