This module allows constant-space CSV parsing.

It feeds ByteStrings into cassavas incremental CSV parser to attain true constant-space record streaming.

Heres a simple example that reads from stdin and writes to a file

    import Pipes.Safe (runSafeT)
    import qualified Pipes.Safe.Prelude  as PS
    import qualified Pipes.ByteString    as PB
    import Data.Vector (fromList)
    import System.IO (IOMode(WriteMode))

    data Person = Person String Int
                deriving (Show)

    instance FromNamedRecord Person where
      parseNamedRecord p =
        Person <$> p .: "name"
               <*> p .: "age"

    personRec ~(Person name age) = ["name" .= name, "age" .= age]

    instance ToNamedRecord Person where
      toNamedRecord = namedRecord . personRec

    persons :: Monad m => Producer ByteString m () -> Producer Person m ()
    persons p = decodeByName p >-> right

    -- note: right can be replaced with Pipes.Prelude.concat in ghc-7.8,
    --       thanks to a Foldable instance for Either
    right :: (Monad m) => Pipe (Either a b) b m r
    right = loop
      where
        loop = await >>= s -> case s of
          Left _  -> loop
          Right v -> yield v >> loop

    write f = PS.withFile f WriteMode PB.toHandle

    main = runSafeT $ runEffect $ pipeline
      where
        header = fromList $ map fst $ personRec undefined
        pipeline = persons stdin
               >-> right
               >-> encodeByName header
               >-> write "persons_out.csv"

Data.Csv re-exports common types and operators:

• FromRecord, FromNamedRecord, ToRecord, ToNamedRecord
• ToField, FromField
• Record, Field, NamedRecord
• '(.!)', '(.:)', '(.=)'
• DecodeOptions, defaultDecodeOptions