Efficiently deserialize CSV records from a lazy ByteString. If this fails due to incomplete or invalid input, Left msg is returned. Equivalent to decodeWith defaultDecodeOptions.

Efficiently deserialize CSV records from a lazy ByteString. If this fails due to incomplete or invalid input, Left msg is returned. The data is assumed to be preceeded by a header. Equivalent to decodeByNameWith defaultDecodeOptions.

Efficiently serialize CVS records as a lazy ByteString.

Efficiently serialize CVS records as a lazy ByteString. The header is written before any records and dictates the field order.

Options that controls how data is decoded. These options can be used to e.g. decode tab-separated data instead of comma-separated data.

Decoding options for parsing CSV files.

Like decode, but lets you customize how the CSV data is parsed.

Like decodeByName, but lets you customize how the CSV data is parsed.

Options that controls how data is encoded. These options can be used to e.g. encode data in a tab-separated format instead of in a comma-separated format.

Encoding options for CSV files.

Like encode, but lets you customize how the CSV data is encoded.

Like encodeByName, but lets you customize how the CSV data is encoded.

CSV data represented as a Haskell vector of vector of bytestrings.

A record corresponds to a single line in a CSV file.

A single field within a record.

The header corresponds to the first line a CSV file. Not all CSV files have a header.

A header has one or more names, describing the data in the column following the name.

A record corresponds to a single line in a CSV file, indexed by the column name rather than the column index.

A type that can be converted from a single CSV record, with the possibility of failure.

When writing an instance, use empty, mzero, or fail to make a conversion fail, e.g. if a Record has the wrong number of columns.

Given this example data:

 John,56
 Jane,55

here's an example type and instance:

data Person = Person { name :: Text, age :: Int }

instance FromRecord Person where
     parseRecord v
         | length v == 2 = Person <$>
                           v .! 0 <*>
                           v .! 1
         | otherwise     = mzero

Conversion of a field to a value might fail e.g. if the field is malformed. This possibility is captured by the Parser type, which lets you compose several field conversions together in such a way that if any of them fail, the whole record conversion fails.

Retrieve the nth field in the given record. The result is empty if the value cannot be converted to the desired type. Raises an exception if the index is out of bounds.

A type that can be converted to a single CSV record.

An example type and instance:

data Person = Person { name :: Text, age :: Int }

instance ToRecord Person where
     toRecord (Person name age) = record [
        toField name, toField age]

Outputs data on this form:

 John,56
 Jane,55

Construct a record from a list of ByteStrings. Use toField to convert values to ByteStrings for use with record.

Haskell lacks a single-element tuple type, so if you CSV data with just one column you can use the Only type to represent a single-column result.

A type that can be converted from a single CSV record, with the possibility of failure.

When writing an instance, use empty, mzero, or fail to make a conversion fail, e.g. if a Record has the wrong number of columns.

Given this example data:

 name,age
 John,56
 Jane,55

here's an example type and instance:

{-# LANGUAGE OverloadedStrings #-}

data Person = Person { name :: Text, age :: Int }

instance FromRecord Person where
     parseNamedRecord m = Person <$>
                          m .: "name" <*>
                          m .: "age"

Note the use of the OverloadedStrings language extension which enables ByteString values to be written as string literals.

Retrieve a field in the given record by name. The result is empty if the field is missing or if the value cannot be converted to the desired type.

A type that can be converted to a single CSV record.

An example type and instance:

data Person = Person { name :: Text, age :: Int }

instance ToRecord Person where
     toNamedRecord (Person name age) = namedRecord [
        "name" .= name, "age" .= age]

Construct a named record from a list of name-value ByteString pairs. Use .= to construct such a pair from a name and a value.

Construct a pair from a name and a value. For use with namedRecord.

A type that can be converted from a single CSV field, with the possibility of failure.

When writing an instance, use empty, mzero, or fail to make a conversion fail, e.g. if a Field can't be converted to the given type.

Example type and instance:

{-# LANGUAGE OverloadedStrings #-}

data Color = Red | Green | Blue

instance FromField Color where
     parseField s
         | s == "R"  = pure Red
         | s == "G"  = pure Green
         | s == "B"  = pure Blue
         | otherwise = mzero

A type that can be converted to a single CSV field.

Example type and instance:

{-# LANGUAGE OverloadedStrings #-}

data Color = Red | Green | Blue

instance ToField Color where
     toField Red   = "R"
     toField Green = "G"
     toField Blue  = "B"