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 wrapper around custom haskell types that can directly be converted/parsed from an incoming CSV stream.

We define this wrapper to stop GHC from complaining about overlapping instances. Just use getNamed to get your object out of the wrapper.

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

A shorthand for the ByteString case of MapRow

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

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.

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]

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 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

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"

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.

Run a Parser, returning either Left errMsg or Right result. Forces the value in the Left or Right constructors to weak head normal form.

You most likely won't need to use this function directly, but it's included for completeness.

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.

index is a simple convenience function that is equivalent to parseField (v ! idx). If you're certain that the index is not out of bounds, using unsafeIndex is somewhat faster.

Alias for index.

Like index but without bounds checking.

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.

Alias for lookup.

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

Alias for namedField.

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

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