    {-# LANGUAGE
        BangPatterns,
        CPP,
        DefaultSignatures,
        FlexibleContexts,
        FlexibleInstances,
        KindSignatures,
        MultiParamTypeClasses,
        OverloadedStrings,
        Rank2Types,
        ScopedTypeVariables,
        TypeOperators,
        UndecidableInstances
        #-}
    {-# LANGUAGE DataKinds #-}
    {-# LANGUAGE PolyKinds #-}

    module Data.Csv.Conversion
        (
        -- * Type conversion
          Only(..)
        , FromRecord(..)
        , FromNamedRecord(..)
        , ToNamedRecord(..)
        , DefaultOrdered(..)
        , FromField(..)
        , ToRecord(..)
        , ToField(..)

        -- ** Generic type conversion
        , genericParseRecord
        , genericToRecord
        , genericParseNamedRecord
        , genericToNamedRecord
        , genericHeaderOrder

        -- *** Generic type conversion options
        , Options
        , defaultOptions
        , fieldLabelModifier

        -- *** Generic type conversion class names
        , GFromRecord
        , GToRecord
        , GFromNamedRecord
        , GToNamedRecordHeader

        -- * Parser
        , Parser
        , runParser

        -- * Accessors
        , index
        , (.!)
        , unsafeIndex
        , lookup
        , (.:)
        , namedField
        , (.=)
        , record
        , namedRecord
        , header
        ) where

    import Control.Applicative (Alternative, (<|>), empty, Const(..))
    import Control.Monad (MonadPlus, mplus, mzero)
    import qualified Control.Monad.Fail as Fail
    import Data.Attoparsec.ByteString.Char8 (double)
    import qualified Data.Attoparsec.ByteString.Char8 as A8
    import qualified Data.ByteString as B
    import qualified Data.ByteString.Char8 as B8
    import qualified Data.ByteString.Lazy as L
    import qualified Data.ByteString.Short as SBS
    import Data.Functor.Identity
    import Data.List (intercalate)
    import Data.Hashable (Hashable)
    import qualified Data.HashMap.Lazy as HM
    import Data.Int (Int8, Int16, Int32, Int64)
    import qualified Data.IntMap as IM
    import qualified Data.Map as M
    import Data.Scientific (Scientific)
    import Data.Semigroup as Semi (Semigroup, (<>))
    import qualified Data.Text as T
    import qualified Data.Text.Encoding as T
    import qualified Data.Text.Lazy as LT
    import qualified Data.Text.Lazy.Encoding as LT
    import qualified Data.Text.Short as T.S
    import Data.Tuple.Only (Only(..))
    import Data.Vector (Vector, (!))
    import qualified Data.Vector as V
    import qualified Data.Vector.Unboxed as U
    import Data.Word (Word8, Word16, Word32, Word64)
    import GHC.Float (double2Float)
    import GHC.Generics
    import Numeric.Natural
    import Prelude hiding (lookup, takeWhile)

    import Data.Csv.Conversion.Internal
    import Data.Csv.Types

    ------------------------------------------------------------------------
    -- bytestring compatibility

    toStrict   :: L.ByteString -> B.ByteString
    fromStrict :: B.ByteString -> L.ByteString
    toStrict :: ByteString -> ByteString
    toStrict   = ByteString -> ByteString
    L.toStrict
    fromStrict :: ByteString -> ByteString
    fromStrict = ByteString -> ByteString
    L.fromStrict
    {-# INLINE toStrict #-}
    {-# INLINE fromStrict #-}

    ------------------------------------------------------------------------
    -- Type conversion

    ------------------------------------------------------------------------
    -- Index-based conversion

    -- | Options to customise how to generically encode\/decode your
    --   datatype to\/from CSV.
    --
    --   @since 0.5.1.0
    newtype Options = Options
      { Options -> String -> String
    fieldLabelModifier :: String -> String
        -- ^ How to convert Haskell field labels to CSV fields.
        --
        --   @since 0.5.1.0
      }

    instance Show Options where
      show :: Options -> String
    show (Options String -> String
    fld) =
        String
    "Options {"
          String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    ","
             [ String
    "fieldLabelModifier =~ " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> String
    forall a. Show a => a -> String
    show String
    sampleField String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    " -> " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> String
    forall a. Show a => a -> String
    show (String -> String
    fld String
    sampleField)
             ]
          String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "}"
        where
          sampleField :: String
    sampleField = String
    "_column_A"

    -- | Default conversion options.
    --
    --   @
    --   Options
    --   { 'fieldLabelModifier' = id
    --   }
    --   @
    --
    --   @since 0.5.1.0
    defaultOptions :: Options
    defaultOptions :: Options
    defaultOptions = Options
      { fieldLabelModifier :: String -> String
    fieldLabelModifier = String -> String
    forall a. a -> a
    id
      }

    -- | 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
    class FromRecord a where
        parseRecord :: Record -> Parser a

        default parseRecord :: (Generic a, GFromRecord (Rep a)) => Record -> Parser a
        parseRecord = Options -> Record -> Parser a
    forall a.
    (Generic a, GFromRecord (Rep a)) =>
    Options -> Record -> Parser a
    genericParseRecord Options
    defaultOptions

    -- | A configurable CSV record parser.  This function applied to
    --   'defaultOptions' is used as the default for 'parseRecord' when the
    --   type is an instance of 'Generic'.
    --
    --   @since 0.5.1.0
    genericParseRecord :: (Generic a, GFromRecord (Rep a)) => Options -> Record -> Parser a
    genericParseRecord :: forall a.
    (Generic a, GFromRecord (Rep a)) =>
    Options -> Record -> Parser a
    genericParseRecord Options
    opts Record
    r = Rep a (ZonkAny 4) -> a
    forall a x. Generic a => Rep a x -> a
    forall x. Rep a x -> a
    to (Rep a (ZonkAny 4) -> a) -> Parser (Rep a (ZonkAny 4)) -> Parser a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Options -> Record -> Parser (Rep a (ZonkAny 4))
    forall p. Options -> Record -> Parser (Rep a p)
    forall {k} (f :: k -> *) (p :: k).
    GFromRecord f =>
    Options -> Record -> Parser (f p)
    gparseRecord Options
    opts Record
    r

    -- | 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
    class ToRecord a where
        -- | Convert a value to a record.
        toRecord :: a -> Record

        default toRecord :: (Generic a, GToRecord (Rep a) Field) => a -> Record
        toRecord = Options -> a -> Record
    forall a.
    (Generic a, GToRecord (Rep a) ByteString) =>
    Options -> a -> Record
    genericToRecord Options
    defaultOptions

    -- | A configurable CSV record creator.  This function applied to
    --   'defaultOptions' is used as the default for 'toRecord' when the
    --   type is an instance of 'Generic'.
    --
    --   @since 0.5.1.0
    genericToRecord :: (Generic a, GToRecord (Rep a) Field) => Options -> a -> Record
    genericToRecord :: forall a.
    (Generic a, GToRecord (Rep a) ByteString) =>
    Options -> a -> Record
    genericToRecord Options
    opts = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList ([ByteString] -> Record) -> (a -> [ByteString]) -> a -> Record
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Options -> Rep a (ZonkAny 3) -> [ByteString]
    forall p. Options -> Rep a p -> [ByteString]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts (Rep a (ZonkAny 3) -> [ByteString])
    -> (a -> Rep a (ZonkAny 3)) -> a -> [ByteString]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Rep a (ZonkAny 3)
    forall x. a -> Rep a x
    forall a x. Generic a => a -> Rep a x
    from

    instance FromField a => FromRecord (Only a) where
        parseRecord :: Record -> Parser (Only a)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1    = a -> Only a
    forall a. a -> Only a
    Only (a -> Only a) -> Parser a -> Parser (Only a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
            | Bool
    otherwise = Int -> Record -> Parser (Only a)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    1 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    -- TODO: Check if we want all toRecord conversions to be stricter.

    instance ToField a => ToRecord (Only a) where
        toRecord :: Only a -> Record
    toRecord = ByteString -> Record
    forall a. a -> Vector a
    V.singleton (ByteString -> Record)
    -> (Only a -> ByteString) -> Only a -> Record
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> ByteString
    forall a. ToField a => a -> ByteString
    toField (a -> ByteString) -> (Only a -> a) -> Only a -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Only a -> a
    forall a. Only a -> a
    fromOnly

    instance (FromField a, FromField b) => FromRecord (a, b) where
        parseRecord :: Record -> Parser (a, b)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2    = (,) (a -> b -> (a, b)) -> Parser a -> Parser (b -> (a, b))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                              Parser (b -> (a, b)) -> Parser b -> Parser (a, b)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
            | Bool
    otherwise = Int -> Record -> Parser (a, b)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    2 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b) => ToRecord (a, b) where
        toRecord :: (a, b) -> Record
    toRecord (a
    a, b
    b) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b]

    instance (FromField a, FromField b, FromField c) => FromRecord (a, b, c) where
        parseRecord :: Record -> Parser (a, b, c)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    3    = (,,) (a -> b -> c -> (a, b, c))
    -> Parser a -> Parser (b -> c -> (a, b, c))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                               Parser (b -> c -> (a, b, c)) -> Parser b -> Parser (c -> (a, b, c))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                               Parser (c -> (a, b, c)) -> Parser c -> Parser (a, b, c)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    3 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c) =>
             ToRecord (a, b, c) where
        toRecord :: (a, b, c) -> Record
    toRecord (a
    a, b
    b, c
    c) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c]

    instance (FromField a, FromField b, FromField c, FromField d) =>
             FromRecord (a, b, c, d) where
        parseRecord :: Record -> Parser (a, b, c, d)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    4    = (,,,) (a -> b -> c -> d -> (a, b, c, d))
    -> Parser a -> Parser (b -> c -> d -> (a, b, c, d))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                Parser (b -> c -> d -> (a, b, c, d))
    -> Parser b -> Parser (c -> d -> (a, b, c, d))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                Parser (c -> d -> (a, b, c, d))
    -> Parser c -> Parser (d -> (a, b, c, d))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                Parser (d -> (a, b, c, d)) -> Parser d -> Parser (a, b, c, d)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    4 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d) =>
             ToRecord (a, b, c, d) where
        toRecord :: (a, b, c, d) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e) =>
             FromRecord (a, b, c, d, e) where
        parseRecord :: Record -> Parser (a, b, c, d, e)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    5    = (,,,,) (a -> b -> c -> d -> e -> (a, b, c, d, e))
    -> Parser a -> Parser (b -> c -> d -> e -> (a, b, c, d, e))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                 Parser (b -> c -> d -> e -> (a, b, c, d, e))
    -> Parser b -> Parser (c -> d -> e -> (a, b, c, d, e))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                 Parser (c -> d -> e -> (a, b, c, d, e))
    -> Parser c -> Parser (d -> e -> (a, b, c, d, e))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                 Parser (d -> e -> (a, b, c, d, e))
    -> Parser d -> Parser (e -> (a, b, c, d, e))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                 Parser (e -> (a, b, c, d, e)) -> Parser e -> Parser (a, b, c, d, e)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    5 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e) =>
             ToRecord (a, b, c, d, e) where
        toRecord :: (a, b, c, d, e) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f) =>
             FromRecord (a, b, c, d, e, f) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    6    = (,,,,,) (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
    -> Parser a -> Parser (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                  Parser (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
    -> Parser b -> Parser (c -> d -> e -> f -> (a, b, c, d, e, f))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                  Parser (c -> d -> e -> f -> (a, b, c, d, e, f))
    -> Parser c -> Parser (d -> e -> f -> (a, b, c, d, e, f))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                  Parser (d -> e -> f -> (a, b, c, d, e, f))
    -> Parser d -> Parser (e -> f -> (a, b, c, d, e, f))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                  Parser (e -> f -> (a, b, c, d, e, f))
    -> Parser e -> Parser (f -> (a, b, c, d, e, f))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                  Parser (f -> (a, b, c, d, e, f))
    -> Parser f -> Parser (a, b, c, d, e, f)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    6 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f) =>
             ToRecord (a, b, c, d, e, f) where
        toRecord :: (a, b, c, d, e, f) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g) =>
             FromRecord (a, b, c, d, e, f, g) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    7    = (,,,,,,) (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> Parser a
    -> Parser (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                   Parser (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> Parser b
    -> Parser (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                   Parser (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> Parser c -> Parser (d -> e -> f -> g -> (a, b, c, d, e, f, g))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                   Parser (d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> Parser d -> Parser (e -> f -> g -> (a, b, c, d, e, f, g))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                   Parser (e -> f -> g -> (a, b, c, d, e, f, g))
    -> Parser e -> Parser (f -> g -> (a, b, c, d, e, f, g))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                   Parser (f -> g -> (a, b, c, d, e, f, g))
    -> Parser f -> Parser (g -> (a, b, c, d, e, f, g))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                   Parser (g -> (a, b, c, d, e, f, g))
    -> Parser g -> Parser (a, b, c, d, e, f, g)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    7 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g) =>
             ToRecord (a, b, c, d, e, f, g) where
        toRecord :: (a, b, c, d, e, f, g) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h) =>
             FromRecord (a, b, c, d, e, f, g, h) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    8    = (,,,,,,,) (a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> Parser a
    -> Parser
         (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                    Parser
      (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> Parser b
    -> Parser (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                    Parser (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> Parser c
    -> Parser (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                    Parser (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> Parser d
    -> Parser (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                    Parser (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> Parser e -> Parser (f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                    Parser (f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> Parser f -> Parser (g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                    Parser (g -> h -> (a, b, c, d, e, f, g, h))
    -> Parser g -> Parser (h -> (a, b, c, d, e, f, g, h))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                    Parser (h -> (a, b, c, d, e, f, g, h))
    -> Parser h -> Parser (a, b, c, d, e, f, g, h)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g, h)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    8 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h) =>
             ToRecord (a, b, c, d, e, f, g, h) where
        toRecord :: (a, b, c, d, e, f, g, h) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i) =>
             FromRecord (a, b, c, d, e, f, g, h, i) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h, i)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    9    = (,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> (a, b, c, d, e, f, g, h, i))
    -> Parser a
    -> Parser
         (b
          -> c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                     Parser
      (b
       -> c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> Parser b
    -> Parser
         (c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                     Parser
      (c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> Parser c
    -> Parser
         (d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                     Parser (d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> Parser d
    -> Parser (e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                     Parser (e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> Parser e
    -> Parser (f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                     Parser (f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> Parser f -> Parser (g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                     Parser (g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> Parser g -> Parser (h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                     Parser (h -> i -> (a, b, c, d, e, f, g, h, i))
    -> Parser h -> Parser (i -> (a, b, c, d, e, f, g, h, i))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
                                     Parser (i -> (a, b, c, d, e, f, g, h, i))
    -> Parser i -> Parser (a, b, c, d, e, f, g, h, i)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser i
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    8
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g, h, i)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    9 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h, ToField i) =>
             ToRecord (a, b, c, d, e, f, g, h, i) where
        toRecord :: (a, b, c, d, e, f, g, h, i) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h, i
    i) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h, i -> ByteString
    forall a. ToField a => a -> ByteString
    toField i
    i]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j) =>
             FromRecord (a, b, c, d, e, f, g, h, i, j) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h, i, j)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    10    = (,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser a
    -> Parser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> (a, b, c, d, e, f, g, h, i, j))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                       Parser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser b
    -> Parser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                       Parser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser c
    -> Parser
         (d -> e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                       Parser
      (d -> e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser d
    -> Parser
         (e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                       Parser
      (e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser e
    -> Parser (f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                       Parser (f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser f
    -> Parser (g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                       Parser (g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser g
    -> Parser (h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                       Parser (h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser h -> Parser (i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
                                       Parser (i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser i -> Parser (j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser i
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    8
                                       Parser (j -> (a, b, c, d, e, f, g, h, i, j))
    -> Parser j -> Parser (a, b, c, d, e, f, g, h, i, j)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser j
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    9
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g, h, i, j)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    10 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h, ToField i, ToField j) =>
             ToRecord (a, b, c, d, e, f, g, h, i, j) where
        toRecord :: (a, b, c, d, e, f, g, h, i, j) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h, i
    i, j
    j) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h, i -> ByteString
    forall a. ToField a => a -> ByteString
    toField i
    i, j -> ByteString
    forall a. ToField a => a -> ByteString
    toField j
    j]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j,
              FromField k) =>
             FromRecord (a, b, c, d, e, f, g, h, i, j, k) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h, i, j, k)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    11    = (,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser a
    -> Parser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> (a, b, c, d, e, f, g, h, i, j, k))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                        Parser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser b
    -> Parser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                        Parser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser c
    -> Parser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                        Parser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser d
    -> Parser
         (e
          -> f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                        Parser
      (e
       -> f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser e
    -> Parser
         (f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                        Parser
      (f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser f
    -> Parser
         (g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                        Parser (g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser g
    -> Parser (h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                        Parser (h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser h
    -> Parser (i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
                                        Parser (i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser i -> Parser (j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser i
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    8
                                        Parser (j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser j -> Parser (k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser j
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    9
                                        Parser (k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> Parser k -> Parser (a, b, c, d, e, f, g, h, i, j, k)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser k
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    10
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g, h, i, j, k)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    11 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h, ToField i, ToField j, ToField k) =>
             ToRecord (a, b, c, d, e, f, g, h, i, j, k) where
        toRecord :: (a, b, c, d, e, f, g, h, i, j, k) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h, i
    i, j
    j, k
    k) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h, i -> ByteString
    forall a. ToField a => a -> ByteString
    toField i
    i, j -> ByteString
    forall a. ToField a => a -> ByteString
    toField j
    j, k -> ByteString
    forall a. ToField a => a -> ByteString
    toField k
    k]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j,
              FromField k, FromField l) =>
             FromRecord (a, b, c, d, e, f, g, h, i, j, k, l) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    12    = (,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser a
    -> Parser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                         Parser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser b
    -> Parser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                         Parser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser c
    -> Parser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                         Parser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser d
    -> Parser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                         Parser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser e
    -> Parser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                         Parser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser f
    -> Parser
         (g
          -> h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                         Parser
      (g
       -> h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser g
    -> Parser
         (h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                         Parser
      (h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser h
    -> Parser
         (i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
                                         Parser (i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser i
    -> Parser (j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser i
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    8
                                         Parser (j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser j
    -> Parser (k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser j
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    9
                                         Parser (k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser k -> Parser (l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser k
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    10
                                         Parser (l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> Parser l -> Parser (a, b, c, d, e, f, g, h, i, j, k, l)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser l
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    11
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    12 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h, ToField i, ToField j, ToField k, ToField l) =>
             ToRecord (a, b, c, d, e, f, g, h, i, j, k, l) where
        toRecord :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h, i
    i, j
    j, k
    k, l
    l) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h, i -> ByteString
    forall a. ToField a => a -> ByteString
    toField i
    i, j -> ByteString
    forall a. ToField a => a -> ByteString
    toField j
    j, k -> ByteString
    forall a. ToField a => a -> ByteString
    toField k
    k, l -> ByteString
    forall a. ToField a => a -> ByteString
    toField l
    l]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j,
              FromField k, FromField l, FromField m) =>
             FromRecord (a, b, c, d, e, f, g, h, i, j, k, l, m) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    13    = (,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser a
    -> Parser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                          Parser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser b
    -> Parser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                          Parser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser c
    -> Parser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                          Parser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser d
    -> Parser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                          Parser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser e
    -> Parser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                          Parser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser f
    -> Parser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                          Parser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser g
    -> Parser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                          Parser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser h
    -> Parser
         (i -> j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
                                          Parser
      (i -> j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser i
    -> Parser
         (j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser i
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    8
                                          Parser
      (j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser j
    -> Parser (k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser j
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    9
                                          Parser (k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser k
    -> Parser (l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser k
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    10
                                          Parser (l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser l
    -> Parser (m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser l
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    11
                                          Parser (m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> Parser m -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser m
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    12
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    13 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h, ToField i, ToField j, ToField k, ToField l,
              ToField m) =>
             ToRecord (a, b, c, d, e, f, g, h, i, j, k, l, m) where
        toRecord :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h, i
    i, j
    j, k
    k, l
    l, m
    m) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h, i -> ByteString
    forall a. ToField a => a -> ByteString
    toField i
    i, j -> ByteString
    forall a. ToField a => a -> ByteString
    toField j
    j, k -> ByteString
    forall a. ToField a => a -> ByteString
    toField k
    k, l -> ByteString
    forall a. ToField a => a -> ByteString
    toField l
    l,
            m -> ByteString
    forall a. ToField a => a -> ByteString
    toField m
    m]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j,
              FromField k, FromField l, FromField m, FromField n) =>
             FromRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    14    = (,,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser a
    -> Parser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                           Parser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser b
    -> Parser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                           Parser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser c
    -> Parser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                           Parser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser d
    -> Parser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                           Parser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser e
    -> Parser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                           Parser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser f
    -> Parser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                           Parser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser g
    -> Parser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                           Parser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser h
    -> Parser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
                                           Parser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser i
    -> Parser
         (j
          -> k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser i
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    8
                                           Parser
      (j
       -> k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser j
    -> Parser
         (k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser j
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    9
                                           Parser
      (k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser k
    -> Parser
         (l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser k
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    10
                                           Parser (l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser l
    -> Parser (m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser l
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    11
                                           Parser (m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser m
    -> Parser (n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser m
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    12
                                           Parser (n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> Parser n -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser n
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    13
            | Bool
    otherwise = Int -> Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    14 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h, ToField i, ToField j, ToField k, ToField l,
              ToField m, ToField n) =>
             ToRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) where
        toRecord :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h, i
    i, j
    j, k
    k, l
    l, m
    m, n
    n) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h, i -> ByteString
    forall a. ToField a => a -> ByteString
    toField i
    i, j -> ByteString
    forall a. ToField a => a -> ByteString
    toField j
    j, k -> ByteString
    forall a. ToField a => a -> ByteString
    toField k
    k, l -> ByteString
    forall a. ToField a => a -> ByteString
    toField l
    l,
            m -> ByteString
    forall a. ToField a => a -> ByteString
    toField m
    m, n -> ByteString
    forall a. ToField a => a -> ByteString
    toField n
    n]

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j,
              FromField k, FromField l, FromField m, FromField n, FromField o) =>
             FromRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
        parseRecord :: Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    parseRecord Record
    v
            | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    15    = (,,,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser a
    -> Parser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    0
                                            Parser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser b
    -> Parser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser b
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    1
                                            Parser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser c
    -> Parser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser c
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    2
                                            Parser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser d
    -> Parser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser d
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    3
                                            Parser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser e
    -> Parser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser e
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    4
                                            Parser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser f
    -> Parser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser f
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    5
                                            Parser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser g
    -> Parser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser g
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    6
                                            Parser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser h
    -> Parser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser h
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    7
                                            Parser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser i
    -> Parser
         (j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser i
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    8
                                            Parser
      (j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser j
    -> Parser
         (k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser j
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    9
                                            Parser
      (k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser k
    -> Parser
         (l -> m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser k
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    10
                                            Parser
      (l -> m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser l
    -> Parser
         (m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser l
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    11
                                            Parser
      (m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser m
    -> Parser (n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser m
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    12
                                            Parser (n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser n
    -> Parser (o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser n
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    13
                                            Parser (o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> Parser o -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Record -> Int -> Parser o
    forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    14
            | Bool
    otherwise = Int
    -> Record -> Parser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    15 Record
    v
              where
                n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    instance (ToField a, ToField b, ToField c, ToField d, ToField e, ToField f,
              ToField g, ToField h, ToField i, ToField j, ToField k, ToField l,
              ToField m, ToField n, ToField o) =>
             ToRecord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) where
        toRecord :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Record
    toRecord (a
    a, b
    b, c
    c, d
    d, e
    e, f
    f, g
    g, h
    h, i
    i, j
    j, k
    k, l
    l, m
    m, n
    n, o
    o) = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList [
            a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    b, c -> ByteString
    forall a. ToField a => a -> ByteString
    toField c
    c, d -> ByteString
    forall a. ToField a => a -> ByteString
    toField d
    d, e -> ByteString
    forall a. ToField a => a -> ByteString
    toField e
    e, f -> ByteString
    forall a. ToField a => a -> ByteString
    toField f
    f,
            g -> ByteString
    forall a. ToField a => a -> ByteString
    toField g
    g, h -> ByteString
    forall a. ToField a => a -> ByteString
    toField h
    h, i -> ByteString
    forall a. ToField a => a -> ByteString
    toField i
    i, j -> ByteString
    forall a. ToField a => a -> ByteString
    toField j
    j, k -> ByteString
    forall a. ToField a => a -> ByteString
    toField k
    k, l -> ByteString
    forall a. ToField a => a -> ByteString
    toField l
    l,
            m -> ByteString
    forall a. ToField a => a -> ByteString
    toField m
    m, n -> ByteString
    forall a. ToField a => a -> ByteString
    toField n
    n, o -> ByteString
    forall a. ToField a => a -> ByteString
    toField o
    o]

    lengthMismatch :: Int -> Record -> Parser a
    lengthMismatch :: forall a. Int -> Record -> Parser a
    lengthMismatch Int
    expected Record
    v =
        String -> Parser a
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> Parser a) -> String -> Parser a
    forall a b. (a -> b) -> a -> b
    $ String
    "cannot unpack array of length " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++
        Int -> String
    forall a. Show a => a -> String
    show Int
    n String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    " into a " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    desired String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ". Input record: " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++
        Record -> String
    forall a. Show a => a -> String
    show Record
    v
      where
        n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v
        desired :: String
    desired | Int
    expected Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    1 = String
    "Only"
                | Int
    expected Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    2 = String
    "pair"
                | Bool
    otherwise     = Int -> String
    forall a. Show a => a -> String
    show Int
    expected String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "-tuple"

    instance FromField a => FromRecord [a] where
        parseRecord :: Record -> Parser [a]
    parseRecord = (ByteString -> Parser a) -> [ByteString] -> Parser [a]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField ([ByteString] -> Parser [a])
    -> (Record -> [ByteString]) -> Record -> Parser [a]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Record -> [ByteString]
    forall a. Vector a -> [a]
    V.toList

    instance ToField a => ToRecord [a] where
        toRecord :: [a] -> Record
    toRecord = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList ([ByteString] -> Record) -> ([a] -> [ByteString]) -> [a] -> Record
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> ByteString) -> [a] -> [ByteString]
    forall a b. (a -> b) -> [a] -> [b]
    map a -> ByteString
    forall a. ToField a => a -> ByteString
    toField

    instance FromField a => FromRecord (V.Vector a) where
        parseRecord :: Record -> Parser (Vector a)
    parseRecord = (ByteString -> Parser a) -> Record -> Parser (Vector a)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Vector a -> f (Vector b)
    traverse ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField

    instance ToField a => ToRecord (Vector a) where
        toRecord :: Vector a -> Record
    toRecord = (a -> ByteString) -> Vector a -> Record
    forall a b. (a -> b) -> Vector a -> Vector b
    V.map a -> ByteString
    forall a. ToField a => a -> ByteString
    toField

    instance (FromField a, U.Unbox a) => FromRecord (U.Vector a) where
        parseRecord :: Record -> Parser (Vector a)
    parseRecord = (Vector a -> Vector a) -> Parser (Vector a) -> Parser (Vector a)
    forall a b. (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Vector a -> Vector a
    forall (v :: * -> *) a (w :: * -> *).
    (Vector v a, Vector w a) =>
    v a -> w a
    U.convert (Parser (Vector a) -> Parser (Vector a))
    -> (Record -> Parser (Vector a)) -> Record -> Parser (Vector a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (ByteString -> Parser a) -> Record -> Parser (Vector a)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Vector a -> f (Vector b)
    traverse ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField

    instance (ToField a, U.Unbox a) => ToRecord (U.Vector a) where
        toRecord :: Vector a -> Record
    toRecord = (a -> ByteString) -> Vector a -> Record
    forall a b. (a -> b) -> Vector a -> Vector b
    V.map a -> ByteString
    forall a. ToField a => a -> ByteString
    toField (Vector a -> Record)
    -> (Vector a -> Vector a) -> Vector a -> Record
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Vector a -> Vector a
    forall (v :: * -> *) a (w :: * -> *).
    (Vector v a, Vector w a) =>
    v a -> w a
    U.convert

    ------------------------------------------------------------------------
    -- Name-based conversion

    -- | 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 FromNamedRecord Person where
    -- >     parseNamedRecord m = Person <$>
    -- >                          m .: "name" <*>
    -- >                          m .: "age"
    --
    -- Note the use of the @OverloadedStrings@ language extension which
    -- enables 'B8.ByteString' values to be written as string literals.
    class FromNamedRecord a where
        parseNamedRecord :: NamedRecord -> Parser a

        default parseNamedRecord :: (Generic a, GFromNamedRecord (Rep a)) => NamedRecord -> Parser a
        parseNamedRecord = Options -> NamedRecord -> Parser a
    forall a.
    (Generic a, GFromNamedRecord (Rep a)) =>
    Options -> NamedRecord -> Parser a
    genericParseNamedRecord Options
    defaultOptions

    -- | A configurable CSV named record parser.  This function applied to
    --   'defaultOptions' is used as the default for 'parseNamedRecord'
    --   when the type is an instance of 'Generic'.
    --
    --   @since 0.5.1.0
    genericParseNamedRecord :: (Generic a, GFromNamedRecord (Rep a)) => Options -> NamedRecord -> Parser a
    genericParseNamedRecord :: forall a.
    (Generic a, GFromNamedRecord (Rep a)) =>
    Options -> NamedRecord -> Parser a
    genericParseNamedRecord Options
    opts NamedRecord
    r = Rep a (ZonkAny 2) -> a
    forall a x. Generic a => Rep a x -> a
    forall x. Rep a x -> a
    to (Rep a (ZonkAny 2) -> a) -> Parser (Rep a (ZonkAny 2)) -> Parser a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Options -> NamedRecord -> Parser (Rep a (ZonkAny 2))
    forall p. Options -> NamedRecord -> Parser (Rep a p)
    forall {k} (f :: k -> *) (p :: k).
    GFromNamedRecord f =>
    Options -> NamedRecord -> Parser (f p)
    gparseNamedRecord Options
    opts NamedRecord
    r

    -- | A type that can be converted to a single CSV record.
    --
    -- An example type and instance:
    --
    -- > data Person = Person { name :: !Text, age :: !Int }
    -- >
    -- > instance ToNamedRecord Person where
    -- >     toNamedRecord (Person name age) = namedRecord [
    -- >         "name" .= name, "age" .= age]
    class ToNamedRecord a where
        -- | Convert a value to a named record.
        toNamedRecord :: a -> NamedRecord

        default toNamedRecord ::
            (Generic a, GToRecord (Rep a) (B.ByteString, B.ByteString)) =>
            a -> NamedRecord
        toNamedRecord = Options -> a -> NamedRecord
    forall a.
    (Generic a, GToRecord (Rep a) (ByteString, ByteString)) =>
    Options -> a -> NamedRecord
    genericToNamedRecord Options
    defaultOptions

    -- | A configurable CSV named record creator.  This function applied
    --   to 'defaultOptions' is used as the default for 'toNamedRecord' when
    --   the type is an instance of 'Generic'.
    --
    --   @since 0.5.1.0
    genericToNamedRecord :: (Generic a, GToRecord (Rep a) (B.ByteString, B.ByteString))
                            => Options -> a -> NamedRecord
    genericToNamedRecord :: forall a.
    (Generic a, GToRecord (Rep a) (ByteString, ByteString)) =>
    Options -> a -> NamedRecord
    genericToNamedRecord Options
    opts = [(ByteString, ByteString)] -> NamedRecord
    namedRecord ([(ByteString, ByteString)] -> NamedRecord)
    -> (a -> [(ByteString, ByteString)]) -> a -> NamedRecord
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Options -> Rep a (ZonkAny 1) -> [(ByteString, ByteString)]
    forall p. Options -> Rep a p -> [(ByteString, ByteString)]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts (Rep a (ZonkAny 1) -> [(ByteString, ByteString)])
    -> (a -> Rep a (ZonkAny 1)) -> a -> [(ByteString, ByteString)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Rep a (ZonkAny 1)
    forall x. a -> Rep a x
    forall a x. Generic a => a -> Rep a x
    from

    -- | A type that has a default field order when converted to CSV. This
    -- class lets you specify how to get the headers to use for a record
    -- type that's an instance of 'ToNamedRecord'.
    --
    -- To derive an instance, the type is required to only have one
    -- constructor and that constructor must have named fields (also known
    -- as selectors) for all fields.
    --
    -- Right: @data Foo = Foo { foo :: !Int }@
    --
    -- Wrong: @data Bar = Bar Int@
    --
    -- If you try to derive an instance using GHC generics and your type
    -- doesn't have named fields, you will get an error along the lines
    -- of:
    --
    -- > <interactive>:9:10:
    -- >     No instance for (DefaultOrdered (M1 S NoSelector (K1 R Char) ()))
    -- >       arising from a use of ‘Data.Csv.Conversion.$gdmheader’
    -- >     In the expression: Data.Csv.Conversion.$gdmheader
    -- >     In an equation for ‘header’:
    -- >         header = Data.Csv.Conversion.$gdmheader
    -- >     In the instance declaration for ‘DefaultOrdered Foo’
    --
    class DefaultOrdered a where
        -- | The header order for this record. Should include the names
        -- used in the 'NamedRecord' returned by 'toNamedRecord'. Pass
        -- 'undefined' as the argument, together with a type annotation
        -- e.g. @'headerOrder' ('undefined' :: MyRecord)@.
        headerOrder :: a -> Header  -- TODO: Add Generic implementation

        default headerOrder ::
            (Generic a, GToNamedRecordHeader (Rep a)) =>
            a -> Header
        headerOrder = Options -> a -> Record
    forall a.
    (Generic a, GToNamedRecordHeader (Rep a)) =>
    Options -> a -> Record
    genericHeaderOrder Options
    defaultOptions

    -- | A configurable CSV header record generator.  This function
    --   applied to 'defaultOptions' is used as the default for
    --   'headerOrder' when the type is an instance of 'Generic'.
    --
    --   @since 0.5.1.0
    genericHeaderOrder :: (Generic a, GToNamedRecordHeader (Rep a))
                          => Options -> a -> Header
    genericHeaderOrder :: forall a.
    (Generic a, GToNamedRecordHeader (Rep a)) =>
    Options -> a -> Record
    genericHeaderOrder Options
    opts = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList([ByteString] -> Record) -> (a -> [ByteString]) -> a -> Record
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Options -> Rep a (ZonkAny 0) -> [ByteString]
    forall p. Options -> Rep a p -> [ByteString]
    forall {k} (a :: k -> *) (p :: k).
    GToNamedRecordHeader a =>
    Options -> a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts (Rep a (ZonkAny 0) -> [ByteString])
    -> (a -> Rep a (ZonkAny 0)) -> a -> [ByteString]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Rep a (ZonkAny 0)
    forall x. a -> Rep a x
    forall a x. Generic a => a -> Rep a x
    from

    instance (FromField a, FromField b, Ord a) => FromNamedRecord (M.Map a b) where
        parseNamedRecord :: NamedRecord -> Parser (Map a b)
    parseNamedRecord NamedRecord
    m = [(a, b)] -> Map a b
    forall k a. Ord k => [(k, a)] -> Map k a
    M.fromList ([(a, b)] -> Map a b) -> Parser [(a, b)] -> Parser (Map a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
                             (((ByteString, ByteString) -> Parser (a, b))
    -> [(ByteString, ByteString)] -> Parser [(a, b)]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (ByteString, ByteString) -> Parser (a, b)
    forall a b.
    (FromField a, FromField b) =>
    (ByteString, ByteString) -> Parser (a, b)
    parseBoth ([(ByteString, ByteString)] -> Parser [(a, b)])
    -> [(ByteString, ByteString)] -> Parser [(a, b)]
    forall a b. (a -> b) -> a -> b
    $ NamedRecord -> [(ByteString, ByteString)]
    forall k v. HashMap k v -> [(k, v)]
    HM.toList NamedRecord
    m)

    instance (ToField a, ToField b, Ord a) => ToNamedRecord (M.Map a b) where
        toNamedRecord :: Map a b -> NamedRecord
    toNamedRecord = [(ByteString, ByteString)] -> NamedRecord
    forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
    HM.fromList ([(ByteString, ByteString)] -> NamedRecord)
    -> (Map a b -> [(ByteString, ByteString)])
    -> Map a b
    -> NamedRecord
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((a, b) -> (ByteString, ByteString))
    -> [(a, b)] -> [(ByteString, ByteString)]
    forall a b. (a -> b) -> [a] -> [b]
    map (\ (a
    k, b
    v) -> (a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    k, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    v)) ([(a, b)] -> [(ByteString, ByteString)])
    -> (Map a b -> [(a, b)]) -> Map a b -> [(ByteString, ByteString)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Map a b -> [(a, b)]
    forall k a. Map k a -> [(k, a)]
    M.toList

    instance (Eq a, FromField a, FromField b, Hashable a) => FromNamedRecord (HM.HashMap a b) where
        parseNamedRecord :: NamedRecord -> Parser (HashMap a b)
    parseNamedRecord NamedRecord
    m = [(a, b)] -> HashMap a b
    forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
    HM.fromList ([(a, b)] -> HashMap a b)
    -> Parser [(a, b)] -> Parser (HashMap a b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>
                             (((ByteString, ByteString) -> Parser (a, b))
    -> [(ByteString, ByteString)] -> Parser [(a, b)]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (ByteString, ByteString) -> Parser (a, b)
    forall a b.
    (FromField a, FromField b) =>
    (ByteString, ByteString) -> Parser (a, b)
    parseBoth ([(ByteString, ByteString)] -> Parser [(a, b)])
    -> [(ByteString, ByteString)] -> Parser [(a, b)]
    forall a b. (a -> b) -> a -> b
    $ NamedRecord -> [(ByteString, ByteString)]
    forall k v. HashMap k v -> [(k, v)]
    HM.toList NamedRecord
    m)

    instance (Eq a, ToField a, ToField b, Hashable a) => ToNamedRecord (HM.HashMap a b) where
        toNamedRecord :: HashMap a b -> NamedRecord
    toNamedRecord = [(ByteString, ByteString)] -> NamedRecord
    forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
    HM.fromList ([(ByteString, ByteString)] -> NamedRecord)
    -> (HashMap a b -> [(ByteString, ByteString)])
    -> HashMap a b
    -> NamedRecord
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((a, b) -> (ByteString, ByteString))
    -> [(a, b)] -> [(ByteString, ByteString)]
    forall a b. (a -> b) -> [a] -> [b]
    map (\ (a
    k, b
    v) -> (a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    k, b -> ByteString
    forall a. ToField a => a -> ByteString
    toField b
    v)) ([(a, b)] -> [(ByteString, ByteString)])
    -> (HashMap a b -> [(a, b)])
    -> HashMap a b
    -> [(ByteString, ByteString)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . HashMap a b -> [(a, b)]
    forall k v. HashMap k v -> [(k, v)]
    HM.toList

    parseBoth :: (FromField a, FromField b) => (Field, Field) -> Parser (a, b)
    parseBoth :: forall a b.
    (FromField a, FromField b) =>
    (ByteString, ByteString) -> Parser (a, b)
    parseBoth (ByteString
    k, ByteString
    v) = (,) (a -> b -> (a, b)) -> Parser a -> Parser (b -> (a, b))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField ByteString
    k Parser (b -> (a, b)) -> Parser b -> Parser (a, b)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> ByteString -> Parser b
    forall a. FromField a => ByteString -> Parser a
    parseField ByteString
    v

    ------------------------------------------------------------------------
    -- Individual field conversion

    -- | 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
    class FromField a where
        parseField :: Field -> Parser a

    -- | 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"
    class ToField a where
        toField :: a -> Field

    -- | 'Nothing' if the 'Field' is 'B.empty', 'Just' otherwise.
    instance FromField a => FromField (Maybe a) where
        parseField :: ByteString -> Parser (Maybe a)
    parseField ByteString
    s
            | ByteString -> Bool
    B.null ByteString
    s  = Maybe a -> Parser (Maybe a)
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe a
    forall a. Maybe a
    Nothing
            | Bool
    otherwise = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> Parser a -> Parser (Maybe a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField ByteString
    s
        {-# INLINE parseField #-}

    -- | 'Nothing' is encoded as an 'B.empty' field.
    instance ToField a => ToField (Maybe a) where
        toField :: Maybe a -> ByteString
    toField = ByteString -> (a -> ByteString) -> Maybe a -> ByteString
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe ByteString
    B.empty a -> ByteString
    forall a. ToField a => a -> ByteString
    toField
        {-# INLINE toField #-}

    -- | @'Left' field@ if conversion failed, 'Right' otherwise.
    instance FromField a => FromField (Either Field a) where
        parseField :: ByteString -> Parser (Either ByteString a)
    parseField ByteString
    s = case Parser a -> Either String a
    forall a. Parser a -> Either String a
    runParser (ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField ByteString
    s) of
            Left String
    _  -> Either ByteString a -> Parser (Either ByteString a)
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Either ByteString a -> Parser (Either ByteString a))
    -> Either ByteString a -> Parser (Either ByteString a)
    forall a b. (a -> b) -> a -> b
    $ ByteString -> Either ByteString a
    forall a b. a -> Either a b
    Left ByteString
    s
            Right a
    a -> Either ByteString a -> Parser (Either ByteString a)
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Either ByteString a -> Parser (Either ByteString a))
    -> Either ByteString a -> Parser (Either ByteString a)
    forall a b. (a -> b) -> a -> b
    $ a -> Either ByteString a
    forall a b. b -> Either a b
    Right a
    a
        {-# INLINE parseField #-}

    -- | Ignores the 'Field'. Always succeeds.
    instance FromField () where
        parseField :: ByteString -> Parser ()
    parseField ByteString
    _ = () -> Parser ()
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ()
        {-# INLINE parseField #-}

    -- | @since 0.5.2.0
    instance FromField a => FromField (Identity a) where
        parseField :: ByteString -> Parser (Identity a)
    parseField = (a -> Identity a) -> Parser a -> Parser (Identity a)
    forall a b. (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Identity a
    forall a. a -> Identity a
    Identity (Parser a -> Parser (Identity a))
    -> (ByteString -> Parser a) -> ByteString -> Parser (Identity a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField
        {-# INLINE parseField #-}

    -- | @since 0.5.2.0
    instance ToField a => ToField (Identity a) where
        toField :: Identity a -> ByteString
    toField = a -> ByteString
    forall a. ToField a => a -> ByteString
    toField (a -> ByteString) -> (Identity a -> a) -> Identity a -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Identity a -> a
    forall a. Identity a -> a
    runIdentity
        {-# INLINE toField #-}

    -- | @since 0.5.2.0
    instance FromField a => FromField (Const a b) where
        parseField :: ByteString -> Parser (Const a b)
    parseField = (a -> Const a b) -> Parser a -> Parser (Const a b)
    forall a b. (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> Const a b
    forall {k} a (b :: k). a -> Const a b
    Const (Parser a -> Parser (Const a b))
    -> (ByteString -> Parser a) -> ByteString -> Parser (Const a b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField
        {-# INLINE parseField #-}

    -- | @since 0.5.2.0
    instance ToField a => ToField (Const a b) where
        toField :: Const a b -> ByteString
    toField = a -> ByteString
    forall a. ToField a => a -> ByteString
    toField (a -> ByteString) -> (Const a b -> a) -> Const a b -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Const a b -> a
    forall {k} a (b :: k). Const a b -> a
    getConst
        {-# INLINE toField #-}

    -- | Assumes UTF-8 encoding.
    instance FromField Char where
        parseField :: ByteString -> Parser Char
    parseField ByteString
    s =
            case ByteString -> Either UnicodeException Text
    T.decodeUtf8' ByteString
    s of
              Left UnicodeException
    e -> String -> Parser Char
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> Parser Char) -> String -> Parser Char
    forall a b. (a -> b) -> a -> b
    $ UnicodeException -> String
    forall a. Show a => a -> String
    show UnicodeException
    e
              Right Text
    t
                | Text -> Int -> Ordering
    T.compareLength Text
    t Int
    1 Ordering -> Ordering -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ordering
    EQ -> Char -> Parser Char
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (HasCallStack => Text -> Char
    Text -> Char
    T.head Text
    t)
                | Bool
    otherwise -> String -> ByteString -> Maybe String -> Parser Char
    forall a. String -> ByteString -> Maybe String -> Parser a
    typeError String
    "Char" ByteString
    s Maybe String
    forall a. Maybe a
    Nothing
        {-# INLINE parseField #-}

    -- | Uses UTF-8 encoding.
    instance ToField Char where
        toField :: Char -> ByteString
    toField = ByteString -> ByteString
    forall a. ToField a => a -> ByteString
    toField (ByteString -> ByteString)
    -> (Char -> ByteString) -> Char -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> ByteString
    T.encodeUtf8 (Text -> ByteString) -> (Char -> Text) -> Char -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Char -> Text
    T.singleton
        {-# INLINE toField #-}

    -- | Accepts the same syntax as 'rational'. Ignores whitespace.
    --
    -- @since 0.5.1.0
    instance FromField Scientific where
      parseField :: ByteString -> Parser Scientific
    parseField ByteString
    s = case Parser Scientific -> ByteString -> Either String Scientific
    forall a. Parser a -> ByteString -> Either String a
    parseOnly (Parser ()
    ws Parser () -> Parser Scientific -> Parser Scientific
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Parser Scientific
    A8.scientific Parser Scientific -> Parser () -> Parser Scientific
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Parser ()
    ws) ByteString
    s of
                       Left String
    err -> String -> ByteString -> Maybe String -> Parser Scientific
    forall a. String -> ByteString -> Maybe String -> Parser a
    typeError String
    "Scientific" ByteString
    s (String -> Maybe String
    forall a. a -> Maybe a
    Just String
    err)
                       Right Scientific
    n  -> Scientific -> Parser Scientific
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Scientific
    n
      {-# INLINE parseField #-}

    -- | Uses decimal notation or scientific notation, depending on the number.
    --
    -- @since 0.5.1.0
    instance ToField Scientific where
      toField :: Scientific -> ByteString
    toField = Scientific -> ByteString
    scientific
      {-# INLINE toField #-}

    -- | Accepts same syntax as 'rational'. Ignores whitespace.
    instance FromField Double where
        parseField :: ByteString -> Parser Double
    parseField = ByteString -> Parser Double
    parseDouble
        {-# INLINE parseField #-}

    -- | Uses decimal notation or scientific notation, depending on the
    -- number.
    instance ToField Double where
        toField :: Double -> ByteString
    toField = Double -> ByteString
    forall a. RealFloat a => a -> ByteString
    realFloat
        {-# INLINE toField #-}

    -- | Accepts same syntax as 'rational'. Ignores whitespace.
    instance FromField Float where
        parseField :: ByteString -> Parser Float
    parseField ByteString
    s = Double -> Float
    double2Float (Double -> Float) -> Parser Double -> Parser Float
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ByteString -> Parser Double
    parseDouble ByteString
    s
        {-# INLINE parseField #-}

    -- | Uses decimal notation or scientific notation, depending on the
    -- number.
    instance ToField Float where
        toField :: Float -> ByteString
    toField = Float -> ByteString
    forall a. RealFloat a => a -> ByteString
    realFloat
        {-# INLINE toField #-}

    parseDouble :: B.ByteString -> Parser Double
    parseDouble :: ByteString -> Parser Double
    parseDouble ByteString
    s = case Parser Double -> ByteString -> Either String Double
    forall a. Parser a -> ByteString -> Either String a
    parseOnly (Parser ()
    ws Parser () -> Parser Double -> Parser Double
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Parser Double
    double Parser Double -> Parser () -> Parser Double
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Parser ()
    ws) ByteString
    s of
        Left String
    err -> String -> ByteString -> Maybe String -> Parser Double
    forall a. String -> ByteString -> Maybe String -> Parser a
    typeError String
    "Double" ByteString
    s (String -> Maybe String
    forall a. a -> Maybe a
    Just String
    err)
        Right Double
    n  -> Double -> Parser Double
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Double
    n
    {-# INLINE parseDouble #-}

    -- | Accepts a signed decimal number. Ignores whitespace.
    instance FromField Int where
        parseField :: ByteString -> Parser Int
    parseField = String -> ByteString -> Parser Int
    forall a. (Integral a, Num a) => String -> ByteString -> Parser a
    parseSigned String
    "Int"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding with optional sign.
    instance ToField Int where
        toField :: Int -> ByteString
    toField = Int -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts a signed decimal number. Ignores whitespace.
    instance FromField Integer where
        parseField :: ByteString -> Parser Integer
    parseField = String -> ByteString -> Parser Integer
    forall a. (Integral a, Num a) => String -> ByteString -> Parser a
    parseSigned String
    "Integer"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding with optional sign.
    instance ToField Integer where
        toField :: Integer -> ByteString
    toField = Integer -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts a signed decimal number. Ignores whitespace.
    instance FromField Int8 where
        parseField :: ByteString -> Parser Int8
    parseField = String -> ByteString -> Parser Int8
    forall a. (Integral a, Num a) => String -> ByteString -> Parser a
    parseSigned String
    "Int8"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding with optional sign.
    instance ToField Int8 where
        toField :: Int8 -> ByteString
    toField = Int8 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts a signed decimal number. Ignores whitespace.
    instance FromField Int16 where
        parseField :: ByteString -> Parser Int16
    parseField = String -> ByteString -> Parser Int16
    forall a. (Integral a, Num a) => String -> ByteString -> Parser a
    parseSigned String
    "Int16"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding with optional sign.
    instance ToField Int16 where
        toField :: Int16 -> ByteString
    toField = Int16 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts a signed decimal number. Ignores whitespace.
    instance FromField Int32 where
        parseField :: ByteString -> Parser Int32
    parseField = String -> ByteString -> Parser Int32
    forall a. (Integral a, Num a) => String -> ByteString -> Parser a
    parseSigned String
    "Int32"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding with optional sign.
    instance ToField Int32 where
        toField :: Int32 -> ByteString
    toField = Int32 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts a signed decimal number. Ignores whitespace.
    instance FromField Int64 where
        parseField :: ByteString -> Parser Int64
    parseField = String -> ByteString -> Parser Int64
    forall a. (Integral a, Num a) => String -> ByteString -> Parser a
    parseSigned String
    "Int64"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding with optional sign.
    instance ToField Int64 where
        toField :: Int64 -> ByteString
    toField = Int64 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts an unsigned decimal number. Ignores whitespace.
    instance FromField Word where
        parseField :: ByteString -> Parser Word
    parseField = String -> ByteString -> Parser Word
    forall a. Integral a => String -> ByteString -> Parser a
    parseUnsigned String
    "Word"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding.
    instance ToField Word where
        toField :: Word -> ByteString
    toField = Word -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts an unsigned decimal number. Ignores whitespace.
    --
    -- @since 0.5.1.0
    instance FromField Natural where
        parseField :: ByteString -> Parser Natural
    parseField = String -> ByteString -> Parser Natural
    forall a. Integral a => String -> ByteString -> Parser a
    parseUnsigned String
    "Natural"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding.
    --
    -- @since 0.5.1.0
    instance ToField Natural where
        toField :: Natural -> ByteString
    toField = Natural -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts an unsigned decimal number. Ignores whitespace.
    instance FromField Word8 where
        parseField :: ByteString -> Parser Word8
    parseField = String -> ByteString -> Parser Word8
    forall a. Integral a => String -> ByteString -> Parser a
    parseUnsigned String
    "Word8"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding.
    instance ToField Word8 where
        toField :: Word8 -> ByteString
    toField = Word8 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts an unsigned decimal number. Ignores whitespace.
    instance FromField Word16 where
        parseField :: ByteString -> Parser Word16
    parseField = String -> ByteString -> Parser Word16
    forall a. Integral a => String -> ByteString -> Parser a
    parseUnsigned String
    "Word16"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding.
    instance ToField Word16 where
        toField :: Word16 -> ByteString
    toField = Word16 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts an unsigned decimal number. Ignores whitespace.
    instance FromField Word32 where
        parseField :: ByteString -> Parser Word32
    parseField = String -> ByteString -> Parser Word32
    forall a. Integral a => String -> ByteString -> Parser a
    parseUnsigned String
    "Word32"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding.
    instance ToField Word32 where
        toField :: Word32 -> ByteString
    toField = Word32 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    -- | Accepts an unsigned decimal number. Ignores whitespace.
    instance FromField Word64 where
        parseField :: ByteString -> Parser Word64
    parseField = String -> ByteString -> Parser Word64
    forall a. Integral a => String -> ByteString -> Parser a
    parseUnsigned String
    "Word64"
        {-# INLINE parseField #-}

    -- | Uses decimal encoding.
    instance ToField Word64 where
        toField :: Word64 -> ByteString
    toField = Word64 -> ByteString
    forall a. Integral a => a -> ByteString
    decimal
        {-# INLINE toField #-}

    instance FromField B.ByteString where
        parseField :: ByteString -> Parser ByteString
    parseField = ByteString -> Parser ByteString
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
        {-# INLINE parseField #-}

    instance ToField B.ByteString where
        toField :: ByteString -> ByteString
    toField = ByteString -> ByteString
    forall a. a -> a
    id
        {-# INLINE toField #-}

    instance FromField L.ByteString where
        parseField :: ByteString -> Parser ByteString
    parseField = ByteString -> Parser ByteString
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ByteString -> Parser ByteString)
    -> (ByteString -> ByteString) -> ByteString -> Parser ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ByteString
    fromStrict
        {-# INLINE parseField #-}

    instance ToField L.ByteString where
        toField :: ByteString -> ByteString
    toField = ByteString -> ByteString
    toStrict
        {-# INLINE toField #-}

    instance FromField SBS.ShortByteString where
        parseField :: ByteString -> Parser ShortByteString
    parseField = ShortByteString -> Parser ShortByteString
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ShortByteString -> Parser ShortByteString)
    -> (ByteString -> ShortByteString)
    -> ByteString
    -> Parser ShortByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ShortByteString
    SBS.toShort
        {-# INLINE parseField #-}

    instance ToField SBS.ShortByteString where
        toField :: ShortByteString -> ByteString
    toField = ShortByteString -> ByteString
    SBS.fromShort
        {-# INLINE toField #-}

    -- | Assumes UTF-8 encoding. Fails on invalid byte sequences.
    --
    -- @since 0.5.0.0
    instance FromField T.S.ShortText where
        parseField :: ByteString -> Parser ShortText
    parseField = Parser ShortText
    -> (ShortText -> Parser ShortText)
    -> Maybe ShortText
    -> Parser ShortText
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (String -> Parser ShortText
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "Invalid UTF-8 stream") ShortText -> Parser ShortText
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Maybe ShortText -> Parser ShortText)
    -> (ByteString -> Maybe ShortText)
    -> ByteString
    -> Parser ShortText
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Maybe ShortText
    T.S.fromByteString
        {-# INLINE parseField #-}

    -- | Uses UTF-8 encoding.
    --
    -- @since 0.5.0.0
    instance ToField T.S.ShortText where
        toField :: ShortText -> ByteString
    toField = ShortText -> ByteString
    T.S.toByteString
        {-# INLINE toField #-}

    -- | Assumes UTF-8 encoding. Fails on invalid byte sequences.
    instance FromField T.Text where
        parseField :: ByteString -> Parser Text
    parseField = (UnicodeException -> Parser Text)
    -> (Text -> Parser Text)
    -> Either UnicodeException Text
    -> Parser Text
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either (String -> Parser Text
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> Parser Text)
    -> (UnicodeException -> String) -> UnicodeException -> Parser Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . UnicodeException -> String
    forall a. Show a => a -> String
    show) Text -> Parser Text
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Either UnicodeException Text -> Parser Text)
    -> (ByteString -> Either UnicodeException Text)
    -> ByteString
    -> Parser Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Either UnicodeException Text
    T.decodeUtf8'
        {-# INLINE parseField #-}

    -- | Uses UTF-8 encoding.
    instance ToField T.Text where
        toField :: Text -> ByteString
    toField = ByteString -> ByteString
    forall a. ToField a => a -> ByteString
    toField (ByteString -> ByteString)
    -> (Text -> ByteString) -> Text -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> ByteString
    T.encodeUtf8
        {-# INLINE toField #-}

    -- | Assumes UTF-8 encoding. Fails on invalid byte sequences.
    instance FromField LT.Text where
        parseField :: ByteString -> Parser Text
    parseField = (UnicodeException -> Parser Text)
    -> (Text -> Parser Text)
    -> Either UnicodeException Text
    -> Parser Text
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either (String -> Parser Text
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> Parser Text)
    -> (UnicodeException -> String) -> UnicodeException -> Parser Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . UnicodeException -> String
    forall a. Show a => a -> String
    show) (Text -> Parser Text
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (Text -> Parser Text) -> (Text -> Text) -> Text -> Parser Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> Text
    LT.fromStrict) (Either UnicodeException Text -> Parser Text)
    -> (ByteString -> Either UnicodeException Text)
    -> ByteString
    -> Parser Text
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Either UnicodeException Text
    T.decodeUtf8'
        {-# INLINE parseField #-}

    -- | Uses UTF-8 encoding.
    instance ToField LT.Text where
        toField :: Text -> ByteString
    toField = ByteString -> ByteString
    forall a. ToField a => a -> ByteString
    toField (ByteString -> ByteString)
    -> (Text -> ByteString) -> Text -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> ByteString
    toStrict (ByteString -> ByteString)
    -> (Text -> ByteString) -> Text -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Text -> ByteString
    LT.encodeUtf8
        {-# INLINE toField #-}

    -- | Assumes UTF-8 encoding. Fails on invalid byte sequences.
    instance FromField [Char] where
        parseField :: ByteString -> Parser String
    parseField = (Text -> String) -> Parser Text -> Parser String
    forall a b. (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Text -> String
    T.unpack (Parser Text -> Parser String)
    -> (ByteString -> Parser Text) -> ByteString -> Parser String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ByteString -> Parser Text
    forall a. FromField a => ByteString -> Parser a
    parseField
        {-# INLINE parseField #-}

    -- | Uses UTF-8 encoding.
    instance ToField [Char] where
        toField :: String -> ByteString
    toField = Text -> ByteString
    forall a. ToField a => a -> ByteString
    toField (Text -> ByteString) -> (String -> Text) -> String -> ByteString
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> Text
    T.pack
        {-# INLINE toField #-}

    parseSigned :: (Integral a, Num a) => String -> B.ByteString -> Parser a
    parseSigned :: forall a. (Integral a, Num a) => String -> ByteString -> Parser a
    parseSigned String
    typ ByteString
    s = case Parser a -> ByteString -> Either String a
    forall a. Parser a -> ByteString -> Either String a
    parseOnly (Parser ()
    ws Parser () -> Parser a -> Parser a
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Parser a -> Parser a
    forall a. Num a => Parser a -> Parser a
    A8.signed Parser a
    forall a. Integral a => Parser a
    A8.decimal Parser a -> Parser () -> Parser a
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Parser ()
    ws) ByteString
    s of
        Left String
    err -> String -> ByteString -> Maybe String -> Parser a
    forall a. String -> ByteString -> Maybe String -> Parser a
    typeError String
    typ ByteString
    s (String -> Maybe String
    forall a. a -> Maybe a
    Just String
    err)
        Right a
    n  -> a -> Parser a
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    n
    {-# INLINE parseSigned #-}

    parseUnsigned :: Integral a => String -> B.ByteString -> Parser a
    parseUnsigned :: forall a. Integral a => String -> ByteString -> Parser a
    parseUnsigned String
    typ ByteString
    s = case Parser a -> ByteString -> Either String a
    forall a. Parser a -> ByteString -> Either String a
    parseOnly (Parser ()
    ws Parser () -> Parser a -> Parser a
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Parser a
    forall a. Integral a => Parser a
    A8.decimal Parser a -> Parser () -> Parser a
    forall a b.
    Parser ByteString a -> Parser ByteString b -> Parser ByteString a
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Parser ()
    ws) ByteString
    s of
        Left String
    err -> String -> ByteString -> Maybe String -> Parser a
    forall a. String -> ByteString -> Maybe String -> Parser a
    typeError String
    typ ByteString
    s (String -> Maybe String
    forall a. a -> Maybe a
    Just String
    err)
        Right a
    n  -> a -> Parser a
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    n
    {-# INLINE parseUnsigned #-}

    ws :: A8.Parser ()
    ws :: Parser ()
    ws = (Char -> Bool) -> Parser ()
    A8.skipWhile (\Char
    c -> Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    ' ' Bool -> Bool -> Bool
    || Char
    c Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    == Char
    '\t')

    ------------------------------------------------------------------------
    -- Custom version of attoparsec @parseOnly@ function which fails if
    -- there is leftover content after parsing a field.
    parseOnly :: A8.Parser a -> B.ByteString -> Either String a
    parseOnly :: forall a. Parser a -> ByteString -> Either String a
    parseOnly Parser a
    parser ByteString
    input = IResult ByteString a -> Either String a
    forall {b}. IResult ByteString b -> Either String b
    go (Parser a -> ByteString -> IResult ByteString a
    forall a. Parser a -> ByteString -> Result a
    A8.parse Parser a
    parser ByteString
    input) where
      go :: IResult ByteString b -> Either String b
    go (A8.Fail ByteString
    _ [String]
    _ String
    err) = String -> Either String b
    forall a b. a -> Either a b
    Left String
    err
      go (A8.Partial ByteString -> IResult ByteString b
    f)    = IResult ByteString b -> Either String b
    forall {b}. IResult ByteString b -> Either String b
    go2 (ByteString -> IResult ByteString b
    f ByteString
    B.empty)
      go (A8.Done ByteString
    leftover b
    result)
        | ByteString -> Bool
    B.null ByteString
    leftover = b -> Either String b
    forall a b. b -> Either a b
    Right b
    result
        | Bool
    otherwise = String -> Either String b
    forall a b. a -> Either a b
    Left (String
    "incomplete field parse, leftover: "
                            String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ [Word8] -> String
    forall a. Show a => a -> String
    show (ByteString -> [Word8]
    B.unpack ByteString
    leftover))

      go2 :: IResult ByteString b -> Either String b
    go2 (A8.Fail ByteString
    _ [String]
    _ String
    err) = String -> Either String b
    forall a b. a -> Either a b
    Left String
    err
      go2 (A8.Partial ByteString -> IResult ByteString b
    _)    = String -> Either String b
    forall a. HasCallStack => String -> a
    error String
    "parseOnly: impossible error!"
      go2 (A8.Done ByteString
    leftover b
    result)
        | ByteString -> Bool
    B.null ByteString
    leftover = b -> Either String b
    forall a b. b -> Either a b
    Right b
    result
        | Bool
    otherwise = String -> Either String b
    forall a b. a -> Either a b
    Left (String
    "incomplete field parse, leftover: "
                            String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ [Word8] -> String
    forall a. Show a => a -> String
    show (ByteString -> [Word8]
    B.unpack ByteString
    leftover))
    {-# INLINE parseOnly #-}

    typeError :: String -> B.ByteString -> Maybe String -> Parser a
    typeError :: forall a. String -> ByteString -> Maybe String -> Parser a
    typeError String
    typ ByteString
    s Maybe String
    mmsg =
        String -> Parser a
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> Parser a) -> String -> Parser a
    forall a b. (a -> b) -> a -> b
    $ String
    "expected " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    typ String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ", got " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> String
    forall a. Show a => a -> String
    show (ByteString -> String
    B8.unpack ByteString
    s) String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    cause
      where
        cause :: String
    cause = case Maybe String
    mmsg of
            Just String
    msg -> String
    " (" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    msg String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ")"
            Maybe String
    Nothing  -> String
    ""

    ------------------------------------------------------------------------
    -- Constructors and accessors

    -- | Retrieve the /n/th 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.
    index :: FromField a => Record -> Int -> Parser a
    index :: forall a. FromField a => Record -> Int -> Parser a
    index Record
    v Int
    idx = ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField (Record
    v Record -> Int -> ByteString
    forall a. Vector a -> Int -> a
    ! Int
    idx)
    {-# INLINE index #-}

    -- | Alias for 'index'.
    (.!) :: FromField a => Record -> Int -> Parser a
    .! :: forall a. FromField a => Record -> Int -> Parser a
    (.!) = Record -> Int -> Parser a
    forall a. FromField a => Record -> Int -> Parser a
    index
    {-# INLINE (.!) #-}
    infixl 9 .!

    -- | Like 'index' but without bounds checking.
    unsafeIndex :: FromField a => Record -> Int -> Parser a
    unsafeIndex :: forall a. FromField a => Record -> Int -> Parser a
    unsafeIndex Record
    v Int
    idx = ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField (Record -> Int -> ByteString
    forall a. Vector a -> Int -> a
    V.unsafeIndex Record
    v Int
    idx)
    {-# INLINE unsafeIndex #-}

    -- | 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.
    lookup :: FromField a => NamedRecord -> B.ByteString -> Parser a
    lookup :: forall a. FromField a => NamedRecord -> ByteString -> Parser a
    lookup NamedRecord
    m ByteString
    name = Parser a
    -> (ByteString -> Parser a) -> Maybe ByteString -> Parser a
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe (String -> Parser a
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    err) ByteString -> Parser a
    forall {a} {m :: * -> *}.
    (FromField a, MonadFail m) =>
    ByteString -> m a
    parseField' (Maybe ByteString -> Parser a) -> Maybe ByteString -> Parser a
    forall a b. (a -> b) -> a -> b
    $ ByteString -> NamedRecord -> Maybe ByteString
    forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
    HM.lookup ByteString
    name NamedRecord
    m
      where err :: String
    err = String
    "no field named " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> String
    forall a. Show a => a -> String
    show (ByteString -> String
    B8.unpack ByteString
    name)
            parseField' :: ByteString -> m a
    parseField' ByteString
    fld = case Parser a -> Either String a
    forall a. Parser a -> Either String a
    runParser (ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField ByteString
    fld) of
              Left String
    e -> String -> m a
    forall a. String -> m a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail (String -> m a) -> String -> m a
    forall a b. (a -> b) -> a -> b
    $ String
    "in named field " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String -> String
    forall a. Show a => a -> String
    show (ByteString -> String
    B8.unpack ByteString
    name) String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    ": " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    e
              Right a
    res -> a -> m a
    forall a. a -> m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    res
    {-# INLINE lookup #-}

    -- | Alias for 'lookup'.
    (.:) :: FromField a => NamedRecord -> B.ByteString -> Parser a
    .: :: forall a. FromField a => NamedRecord -> ByteString -> Parser a
    (.:) = NamedRecord -> ByteString -> Parser a
    forall a. FromField a => NamedRecord -> ByteString -> Parser a
    lookup
    {-# INLINE (.:) #-}

    -- | Construct a pair from a name and a value.  For use with
    -- 'namedRecord'.
    namedField :: ToField a => B.ByteString -> a -> (B.ByteString, B.ByteString)
    namedField :: forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
    namedField ByteString
    name a
    val = (ByteString
    name, a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    val)
    {-# INLINE namedField #-}

    -- | Alias for 'namedField'.
    (.=) :: ToField a => B.ByteString -> a -> (B.ByteString, B.ByteString)
    .= :: forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
    (.=) = ByteString -> a -> (ByteString, ByteString)
    forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
    namedField
    {-# INLINE (.=) #-}

    -- | Construct a record from a list of 'B.ByteString's.  Use 'toField'
    -- to convert values to 'B.ByteString's for use with 'record'.
    record :: [B.ByteString] -> Record
    record :: [ByteString] -> Record
    record = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList

    -- | Construct a named record from a list of name-value 'B.ByteString'
    -- pairs.  Use '.=' to construct such a pair from a name and a value.
    namedRecord :: [(B.ByteString, B.ByteString)] -> NamedRecord
    namedRecord :: [(ByteString, ByteString)] -> NamedRecord
    namedRecord = [(ByteString, ByteString)] -> NamedRecord
    forall k v. (Eq k, Hashable k) => [(k, v)] -> HashMap k v
    HM.fromList

    -- | Construct a header from a list of 'B.ByteString's.
    header :: [B.ByteString] -> Header
    header :: [ByteString] -> Record
    header = [ByteString] -> Record
    forall a. [a] -> Vector a
    V.fromList

    ------------------------------------------------------------------------
    -- Parser for converting records to data types

    -- | Failure continuation.
    type Failure f r   = String -> f r
    -- | Success continuation.
    type Success a f r = a -> f r

    -- | 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.
    newtype Parser a = Parser {
          forall a.
    Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    unParser :: forall (f :: * -> *) (r :: *).
                      Failure f r
                   -> Success a f r
                   -> f r
        }

    instance Monad Parser where
        Parser a
    m >>= :: forall a b. Parser a -> (a -> Parser b) -> Parser b
    >>= a -> Parser b
    g = (forall (f :: * -> *) r. Failure f r -> Success b f r -> f r)
    -> Parser b
    forall a.
    (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    Parser ((forall (f :: * -> *) r. Failure f r -> Success b f r -> f r)
     -> Parser b)
    -> (forall (f :: * -> *) r. Failure f r -> Success b f r -> f r)
    -> Parser b
    forall a b. (a -> b) -> a -> b
    $ \Failure f r
    kf Success b f r
    ks -> let ks' :: a -> f r
    ks' a
    a = Parser b
    -> forall (f :: * -> *) r. Failure f r -> Success b f r -> f r
    forall a.
    Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    unParser (a -> Parser b
    g a
    a) Failure f r
    kf Success b f r
    ks
                                     in Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    forall a.
    Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    unParser Parser a
    m Failure f r
    kf a -> f r
    ks'
        {-# INLINE (>>=) #-}
        >> :: forall a b. Parser a -> Parser b -> Parser b
    (>>) = Parser a -> Parser b -> Parser b
    forall a b. Parser a -> Parser b -> Parser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    (*>)
        {-# INLINE (>>) #-}
        return :: forall a. a -> Parser a
    return = a -> Parser a
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
        {-# INLINE return #-}

    #if !MIN_VERSION_base(4,13,0)
        fail = Fail.fail
        {-# INLINE fail #-}
    #endif

    -- | @since 0.5.0.0
    instance Fail.MonadFail Parser where
        fail :: forall a. String -> Parser a
    fail String
    msg = (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    forall a.
    (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    Parser ((forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
     -> Parser a)
    -> (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    forall a b. (a -> b) -> a -> b
    $ \Failure f r
    kf Success a f r
    _ks -> Failure f r
    kf String
    msg
        {-# INLINE fail #-}

    instance Functor Parser where
        fmap :: forall a b. (a -> b) -> Parser a -> Parser b
    fmap a -> b
    f Parser a
    m = (forall (f :: * -> *) r. Failure f r -> Success b f r -> f r)
    -> Parser b
    forall a.
    (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    Parser ((forall (f :: * -> *) r. Failure f r -> Success b f r -> f r)
     -> Parser b)
    -> (forall (f :: * -> *) r. Failure f r -> Success b f r -> f r)
    -> Parser b
    forall a b. (a -> b) -> a -> b
    $ \Failure f r
    kf Success b f r
    ks -> let ks' :: a -> f r
    ks' a
    a = Success b f r
    ks (a -> b
    f a
    a)
                                      in Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    forall a.
    Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    unParser Parser a
    m Failure f r
    kf a -> f r
    ks'
        {-# INLINE fmap #-}

    instance Applicative Parser where
        pure :: forall a. a -> Parser a
    pure a
    a = (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    forall a.
    (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    Parser ((forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
     -> Parser a)
    -> (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    forall a b. (a -> b) -> a -> b
    $ \Failure f r
    _kf Success a f r
    ks -> Success a f r
    ks a
    a
        {-# INLINE pure #-}
        <*> :: forall a b. Parser (a -> b) -> Parser a -> Parser b
    (<*>) = Parser (a -> b) -> Parser a -> Parser b
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    apP
        {-# INLINE (<*>) #-}

    instance Alternative Parser where
        empty :: forall a. Parser a
    empty = String -> Parser a
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "empty"
        {-# INLINE empty #-}
        <|> :: forall a. Parser a -> Parser a -> Parser a
    (<|>) = Parser a -> Parser a -> Parser a
    forall a. Parser a -> Parser a -> Parser a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    mplus
        {-# INLINE (<|>) #-}

    instance MonadPlus Parser where
        mzero :: forall a. Parser a
    mzero = String -> Parser a
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "mzero"
        {-# INLINE mzero #-}
        mplus :: forall a. Parser a -> Parser a -> Parser a
    mplus Parser a
    a Parser a
    b = (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    forall a.
    (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    Parser ((forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
     -> Parser a)
    -> (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
    -> Parser a
    forall a b. (a -> b) -> a -> b
    $ \Failure f r
    kf Success a f r
    ks -> let kf' :: p -> f r
    kf' p
    _ = Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    forall a.
    Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    unParser Parser a
    b Failure f r
    kf Success a f r
    ks
                                       in Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    forall a.
    Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    unParser Parser a
    a Failure f r
    forall {p}. p -> f r
    kf' Success a f r
    ks
        {-# INLINE mplus #-}

    -- | @since 0.5.0.0
    instance Semi.Semigroup (Parser a) where
        <> :: Parser a -> Parser a -> Parser a
    (<>) = Parser a -> Parser a -> Parser a
    forall a. Parser a -> Parser a -> Parser a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    mplus
        {-# INLINE (<>) #-}

    instance Monoid (Parser a) where
        mempty :: Parser a
    mempty  = String -> Parser a
    forall a. String -> Parser a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    "mempty"
        {-# INLINE mempty #-}
        mappend :: Parser a -> Parser a -> Parser a
    mappend = Parser a -> Parser a -> Parser a
    forall a. Semigroup a => a -> a -> a
    (Semi.<>)
        {-# INLINE mappend #-}

    apP :: Parser (a -> b) -> Parser a -> Parser b
    apP :: forall a b. Parser (a -> b) -> Parser a -> Parser b
    apP Parser (a -> b)
    d Parser a
    e = do
      b <- Parser (a -> b)
    d
      a <- e
      pure (b a)
    {-# INLINE apP #-}

    -- | 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.
    runParser :: Parser a -> Either String a
    runParser :: forall a. Parser a -> Either String a
    runParser Parser a
    p = Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    forall a.
    Parser a
    -> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
    unParser Parser a
    p Failure (Either String) a
    forall a b. a -> Either a b
    left Success a (Either String) a
    forall {b} {a}. b -> Either a b
    right
      where
        left :: a -> Either a b
    left !a
    errMsg = a -> Either a b
    forall a b. a -> Either a b
    Left a
    errMsg
        right :: b -> Either a b
    right !b
    x = b -> Either a b
    forall a b. b -> Either a b
    Right b
    x
    {-# INLINE runParser #-}

    ------------------------------------------------------------------------
    -- Generics

    class GFromRecord f where
        gparseRecord :: Options -> Record -> Parser (f p)

    instance GFromRecordSum f Record => GFromRecord (M1 i n f) where
        gparseRecord :: forall (p :: k). Options -> Record -> Parser (M1 i n f p)
    gparseRecord Options
    opts Record
    v =
            case Int
    -> IntMap (Record -> Parser (f p))
    -> Maybe (Record -> Parser (f p))
    forall a. Int -> IntMap a -> Maybe a
    IM.lookup Int
    n (Options -> IntMap (Record -> Parser (f p))
    forall (p :: k). Options -> IntMap (Record -> Parser (f p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordSum f r =>
    Options -> IntMap (r -> Parser (f p))
    gparseRecordSum Options
    opts) of
                Maybe (Record -> Parser (f p))
    Nothing -> Int -> Record -> Parser (M1 i n f p)
    forall a. Int -> Record -> Parser a
    lengthMismatch Int
    n Record
    v
                Just Record -> Parser (f p)
    p -> f p -> M1 i n f p
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (f p -> M1 i n f p) -> Parser (f p) -> Parser (M1 i n f p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Record -> Parser (f p)
    p Record
    v
          where
            n :: Int
    n = Record -> Int
    forall a. Vector a -> Int
    V.length Record
    v

    class GFromNamedRecord f where
        gparseNamedRecord :: Options -> NamedRecord -> Parser (f p)

    instance GFromRecordSum f NamedRecord => GFromNamedRecord (M1 i n f) where
        gparseNamedRecord :: forall (p :: k). Options -> NamedRecord -> Parser (M1 i n f p)
    gparseNamedRecord Options
    opts NamedRecord
    v =
            ((NamedRecord -> Parser (f p))
     -> Parser (M1 i n f p) -> Parser (M1 i n f p))
    -> Parser (M1 i n f p)
    -> [NamedRecord -> Parser (f p)]
    -> Parser (M1 i n f p)
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\NamedRecord -> Parser (f p)
    f Parser (M1 i n f p)
    p -> Parser (M1 i n f p)
    p Parser (M1 i n f p) -> Parser (M1 i n f p) -> Parser (M1 i n f p)
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> f p -> M1 i n f p
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (f p -> M1 i n f p) -> Parser (f p) -> Parser (M1 i n f p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamedRecord -> Parser (f p)
    f NamedRecord
    v) Parser (M1 i n f p)
    forall a. Parser a
    forall (f :: * -> *) a. Alternative f => f a
    empty (IntMap (NamedRecord -> Parser (f p))
    -> [NamedRecord -> Parser (f p)]
    forall a. IntMap a -> [a]
    IM.elems (Options -> IntMap (NamedRecord -> Parser (f p))
    forall (p :: k). Options -> IntMap (NamedRecord -> Parser (f p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordSum f r =>
    Options -> IntMap (r -> Parser (f p))
    gparseRecordSum Options
    opts))

    class GFromRecordSum f r where
        gparseRecordSum :: Options -> IM.IntMap (r -> Parser (f p))

    instance (GFromRecordSum a r, GFromRecordSum b r) => GFromRecordSum (a :+: b) r where
        gparseRecordSum :: forall (p :: k). Options -> IntMap (r -> Parser ((:+:) a b p))
    gparseRecordSum Options
    opts =
            ((r -> Parser ((:+:) a b p))
     -> (r -> Parser ((:+:) a b p)) -> r -> Parser ((:+:) a b p))
    -> IntMap (r -> Parser ((:+:) a b p))
    -> IntMap (r -> Parser ((:+:) a b p))
    -> IntMap (r -> Parser ((:+:) a b p))
    forall a. (a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
    IM.unionWith (\r -> Parser ((:+:) a b p)
    a r -> Parser ((:+:) a b p)
    b r
    r -> r -> Parser ((:+:) a b p)
    a r
    r Parser ((:+:) a b p)
    -> Parser ((:+:) a b p) -> Parser ((:+:) a b p)
    forall a. Parser a -> Parser a -> Parser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> r -> Parser ((:+:) a b p)
    b r
    r)
                ((Parser (a p) -> Parser ((:+:) a b p))
    -> (r -> Parser (a p)) -> r -> Parser ((:+:) a b p)
    forall a b. (a -> b) -> (r -> a) -> r -> b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (a p -> (:+:) a b p
    forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
    L1 (a p -> (:+:) a b p) -> Parser (a p) -> Parser ((:+:) a b p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>) ((r -> Parser (a p)) -> r -> Parser ((:+:) a b p))
    -> IntMap (r -> Parser (a p)) -> IntMap (r -> Parser ((:+:) a b p))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Options -> IntMap (r -> Parser (a p))
    forall (p :: k). Options -> IntMap (r -> Parser (a p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordSum f r =>
    Options -> IntMap (r -> Parser (f p))
    gparseRecordSum Options
    opts)
                ((Parser (b p) -> Parser ((:+:) a b p))
    -> (r -> Parser (b p)) -> r -> Parser ((:+:) a b p)
    forall a b. (a -> b) -> (r -> a) -> r -> b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (b p -> (:+:) a b p
    forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
    R1 (b p -> (:+:) a b p) -> Parser (b p) -> Parser ((:+:) a b p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>) ((r -> Parser (b p)) -> r -> Parser ((:+:) a b p))
    -> IntMap (r -> Parser (b p)) -> IntMap (r -> Parser ((:+:) a b p))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Options -> IntMap (r -> Parser (b p))
    forall (p :: k). Options -> IntMap (r -> Parser (b p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordSum f r =>
    Options -> IntMap (r -> Parser (f p))
    gparseRecordSum Options
    opts)

    instance GFromRecordProd f r => GFromRecordSum (M1 i n f) r where
        gparseRecordSum :: forall (p :: k). Options -> IntMap (r -> Parser (M1 i n f p))
    gparseRecordSum Options
    opts = Int
    -> (r -> Parser (M1 i n f p)) -> IntMap (r -> Parser (M1 i n f p))
    forall a. Int -> a -> IntMap a
    IM.singleton Int
    n ((Parser (f p) -> Parser (M1 i n f p))
    -> (r -> Parser (f p)) -> r -> Parser (M1 i n f p)
    forall a b. (a -> b) -> (r -> a) -> r -> b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (f p -> M1 i n f p
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (f p -> M1 i n f p) -> Parser (f p) -> Parser (M1 i n f p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>) r -> Parser (f p)
    forall {p :: k}. r -> Parser (f p)
    f)
          where
            (Int
    n, r -> Parser (f p)
    f) = Options -> Int -> (Int, r -> Parser (f p))
    forall (p :: k). Options -> Int -> (Int, r -> Parser (f p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordProd f r =>
    Options -> Int -> (Int, r -> Parser (f p))
    gparseRecordProd Options
    opts Int
    0

    class GFromRecordProd f r where
        gparseRecordProd :: Options -> Int -> (Int, r -> Parser (f p))

    instance GFromRecordProd U1 r where
        gparseRecordProd :: forall (p :: k). Options -> Int -> (Int, r -> Parser (U1 p))
    gparseRecordProd Options
    _ Int
    n = (Int
    n, Parser (U1 p) -> r -> Parser (U1 p)
    forall a b. a -> b -> a
    const (U1 p -> Parser (U1 p)
    forall a. a -> Parser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure U1 p
    forall k (p :: k). U1 p
    U1))

    instance (GFromRecordProd a r, GFromRecordProd b r) => GFromRecordProd (a :*: b) r where
        gparseRecordProd :: forall (p :: k). Options -> Int -> (Int, r -> Parser ((:*:) a b p))
    gparseRecordProd Options
    opts Int
    n0 = (Int
    n2, r -> Parser ((:*:) a b p)
    forall {p :: k}. r -> Parser ((:*:) a b p)
    f)
          where
            f :: r -> Parser ((:*:) a b p)
    f r
    r = a p -> b p -> (:*:) a b p
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    (:*:) (a p -> b p -> (:*:) a b p)
    -> Parser (a p) -> Parser (b p -> (:*:) a b p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> r -> Parser (a p)
    forall {p :: k}. r -> Parser (a p)
    fa r
    r Parser (b p -> (:*:) a b p) -> Parser (b p) -> Parser ((:*:) a b p)
    forall a b. Parser (a -> b) -> Parser a -> Parser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> r -> Parser (b p)
    forall {p :: k}. r -> Parser (b p)
    fb r
    r
            (Int
    n1, r -> Parser (a p)
    fa) = Options -> Int -> (Int, r -> Parser (a p))
    forall (p :: k). Options -> Int -> (Int, r -> Parser (a p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordProd f r =>
    Options -> Int -> (Int, r -> Parser (f p))
    gparseRecordProd Options
    opts Int
    n0
            (Int
    n2, r -> Parser (b p)
    fb) = Options -> Int -> (Int, r -> Parser (b p))
    forall (p :: k). Options -> Int -> (Int, r -> Parser (b p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordProd f r =>
    Options -> Int -> (Int, r -> Parser (f p))
    gparseRecordProd Options
    opts Int
    n1

    instance GFromRecordProd f Record => GFromRecordProd (M1 i n f) Record where
        gparseRecordProd :: forall (p :: k).
    Options -> Int -> (Int, Record -> Parser (M1 i n f p))
    gparseRecordProd Options
    opts Int
    n = (Parser (f p) -> Parser (M1 i n f p))
    -> (Record -> Parser (f p)) -> Record -> Parser (M1 i n f p)
    forall a b. (a -> b) -> (Record -> a) -> Record -> b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (f p -> M1 i n f p
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (f p -> M1 i n f p) -> Parser (f p) -> Parser (M1 i n f p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$>) ((Record -> Parser (f p)) -> Record -> Parser (M1 i n f p))
    -> (Int, Record -> Parser (f p))
    -> (Int, Record -> Parser (M1 i n f p))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Options -> Int -> (Int, Record -> Parser (f p))
    forall (p :: k). Options -> Int -> (Int, Record -> Parser (f p))
    forall {k} (f :: k -> *) r (p :: k).
    GFromRecordProd f r =>
    Options -> Int -> (Int, r -> Parser (f p))
    gparseRecordProd Options
    opts Int
    n

    instance FromField a => GFromRecordProd (K1 i a) Record where
        gparseRecordProd :: forall (p :: k).
    Options -> Int -> (Int, Record -> Parser (K1 i a p))
    gparseRecordProd Options
    _ Int
    n = (Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1, \Record
    v -> a -> K1 i a p
    forall k i c (p :: k). c -> K1 i c p
    K1 (a -> K1 i a p) -> Parser a -> Parser (K1 i a p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ByteString -> Parser a
    forall a. FromField a => ByteString -> Parser a
    parseField (Record -> Int -> ByteString
    forall a. Vector a -> Int -> a
    V.unsafeIndex Record
    v Int
    n))

    data Proxy s (f :: * -> *) a = Proxy

    instance (FromField a, Selector s) => GFromRecordProd (M1 S s (K1 i a)) NamedRecord where
        gparseRecordProd :: forall (p :: k).
    Options -> Int -> (Int, NamedRecord -> Parser (M1 S s (K1 i a) p))
    gparseRecordProd Options
    opts Int
    n = (Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1, \NamedRecord
    v -> (K1 i a p -> M1 S s (K1 i a) p
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (K1 i a p -> M1 S s (K1 i a) p)
    -> (a -> K1 i a p) -> a -> M1 S s (K1 i a) p
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> K1 i a p
    forall k i c (p :: k). c -> K1 i c p
    K1) (a -> M1 S s (K1 i a) p) -> Parser a -> Parser (M1 S s (K1 i a) p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> NamedRecord
    v NamedRecord -> ByteString -> Parser a
    forall a. FromField a => NamedRecord -> ByteString -> Parser a
    .: ByteString
    name)
          where
            name :: ByteString
    name = Text -> ByteString
    T.encodeUtf8 (String -> Text
    T.pack (Options -> String -> String
    fieldLabelModifier Options
    opts (Proxy s (ZonkAny 9) a -> String
    forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
           (f :: k1 -> *) (a :: k1).
    Selector s =>
    t s f a -> String
    forall k1 (t :: Meta -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
           (a :: k1).
    t s f a -> String
    selName (Proxy s f a
    forall {k} {k} (s :: k) (f :: * -> *) (a :: k). Proxy s f a
    forall {f :: * -> *}. Proxy s f a
    Proxy :: Proxy s f a))))

    class GToRecord a f where
        gtoRecord :: Options -> a p -> [f]

    instance GToRecord U1 f where
        gtoRecord :: forall (p :: k). Options -> U1 p -> [f]
    gtoRecord Options
    _ U1 p
    U1 = []

    instance (GToRecord a f, GToRecord b f) => GToRecord (a :*: b) f where
        gtoRecord :: forall (p :: k). Options -> (:*:) a b p -> [f]
    gtoRecord Options
    opts (a p
    a :*: b p
    b) = Options -> a p -> [f]
    forall (p :: k). Options -> a p -> [f]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts a p
    a [f] -> [f] -> [f]
    forall a. [a] -> [a] -> [a]
    ++ Options -> b p -> [f]
    forall (p :: k). Options -> b p -> [f]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts b p
    b

    instance (GToRecord a f, GToRecord b f) => GToRecord (a :+: b) f where
        gtoRecord :: forall (p :: k). Options -> (:+:) a b p -> [f]
    gtoRecord Options
    opts (L1 a p
    a) = Options -> a p -> [f]
    forall (p :: k). Options -> a p -> [f]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts a p
    a
        gtoRecord Options
    opts (R1 b p
    b) = Options -> b p -> [f]
    forall (p :: k). Options -> b p -> [f]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts b p
    b

    instance GToRecord a f => GToRecord (M1 D c a) f where
        gtoRecord :: forall (p :: k). Options -> M1 D c a p -> [f]
    gtoRecord Options
    opts (M1 a p
    a) = Options -> a p -> [f]
    forall (p :: k). Options -> a p -> [f]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts a p
    a

    instance GToRecord a f => GToRecord (M1 C c a) f where
        gtoRecord :: forall (p :: k). Options -> M1 C c a p -> [f]
    gtoRecord Options
    opts (M1 a p
    a) = Options -> a p -> [f]
    forall (p :: k). Options -> a p -> [f]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts a p
    a

    instance GToRecord a Field => GToRecord (M1 S c a) Field where
        gtoRecord :: forall (p :: k). Options -> M1 S c a p -> [ByteString]
    gtoRecord Options
    opts (M1 a p
    a) = Options -> a p -> [ByteString]
    forall (p :: k). Options -> a p -> [ByteString]
    forall {k} (a :: k -> *) f (p :: k).
    GToRecord a f =>
    Options -> a p -> [f]
    gtoRecord Options
    opts a p
    a

    instance ToField a => GToRecord (K1 i a) Field where
        gtoRecord :: forall (p :: k). Options -> K1 i a p -> [ByteString]
    gtoRecord Options
    _ (K1 a
    a) = [a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a]

    instance (ToField a, Selector s) => GToRecord (M1 S s (K1 i a)) (B.ByteString, B.ByteString) where
        gtoRecord :: forall (p :: k).
    Options -> M1 S s (K1 i a) p -> [(ByteString, ByteString)]
    gtoRecord Options
    opts m :: M1 S s (K1 i a) p
    m@(M1 (K1 a
    a)) = [ByteString
    name ByteString -> ByteString -> (ByteString, ByteString)
    forall a. ToField a => ByteString -> a -> (ByteString, ByteString)
    .= a -> ByteString
    forall a. ToField a => a -> ByteString
    toField a
    a]
          where
            name :: ByteString
    name = Text -> ByteString
    T.encodeUtf8 (String -> Text
    T.pack (Options -> String -> String
    fieldLabelModifier Options
    opts (M1 S s (K1 i a) p -> String
    forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
           (f :: k1 -> *) (a :: k1).
    Selector s =>
    t s f a -> String
    forall k1 (t :: Meta -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
           (a :: k1).
    t s f a -> String
    selName M1 S s (K1 i a) p
    m)))

    -- We statically fail on sum types and product types without selectors
    -- (field names).

    class GToNamedRecordHeader a
      where
        gtoNamedRecordHeader :: Options -> a p -> [Name]

    instance GToNamedRecordHeader U1
      where
        gtoNamedRecordHeader :: forall (p :: k). Options -> U1 p -> [ByteString]
    gtoNamedRecordHeader Options
    _ U1 p
    _ = []

    instance (GToNamedRecordHeader a, GToNamedRecordHeader b) =>
             GToNamedRecordHeader (a :*: b)
      where
        gtoNamedRecordHeader :: forall (p :: k). Options -> (:*:) a b p -> [ByteString]
    gtoNamedRecordHeader Options
    opts (:*:) a b p
    _ = Options -> a (ZonkAny 7) -> [ByteString]
    forall (p :: k). Options -> a p -> [ByteString]
    forall {k} (a :: k -> *) (p :: k).
    GToNamedRecordHeader a =>
    Options -> a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts (a p
    forall {p :: k}. a p
    forall a. HasCallStack => a
    undefined :: a p) [ByteString] -> [ByteString] -> [ByteString]
    forall a. [a] -> [a] -> [a]
    ++
                                      Options -> b (ZonkAny 8) -> [ByteString]
    forall (p :: k). Options -> b p -> [ByteString]
    forall {k} (a :: k -> *) (p :: k).
    GToNamedRecordHeader a =>
    Options -> a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts (b p
    forall {p :: k}. b p
    forall a. HasCallStack => a
    undefined :: b p)

    instance GToNamedRecordHeader a => GToNamedRecordHeader (M1 D c a)
      where
        gtoNamedRecordHeader :: forall (p :: k). Options -> M1 D c a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts M1 D c a p
    _ = Options -> a (ZonkAny 6) -> [ByteString]
    forall (p :: k). Options -> a p -> [ByteString]
    forall {k} (a :: k -> *) (p :: k).
    GToNamedRecordHeader a =>
    Options -> a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts (a p
    forall {p :: k}. a p
    forall a. HasCallStack => a
    undefined :: a p)

    instance GToNamedRecordHeader a => GToNamedRecordHeader (M1 C c a)
      where
        gtoNamedRecordHeader :: forall (p :: k). Options -> M1 C c a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts M1 C c a p
    _ = Options -> a (ZonkAny 5) -> [ByteString]
    forall (p :: k). Options -> a p -> [ByteString]
    forall {k} (a :: k -> *) (p :: k).
    GToNamedRecordHeader a =>
    Options -> a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts (a p
    forall {p :: k}. a p
    forall a. HasCallStack => a
    undefined :: a p)

    -- | Instance to ensure that you cannot derive DefaultOrdered for
    -- constructors without selectors.
    instance DefaultOrdered (M1 S ('MetaSel 'Nothing srcpk srcstr decstr) a ())
             => GToNamedRecordHeader (M1 S ('MetaSel 'Nothing srcpk srcstr decstr) a)
      where
        gtoNamedRecordHeader :: forall p.
    Options
    -> M1 S ('MetaSel 'Nothing srcpk srcstr decstr) a p -> [ByteString]
    gtoNamedRecordHeader Options
    _ M1 S ('MetaSel 'Nothing srcpk srcstr decstr) a p
    _ =
            String -> [ByteString]
    forall a. HasCallStack => String -> a
    error String
    "You cannot derive DefaultOrdered for constructors without selectors."

    instance Selector s => GToNamedRecordHeader (M1 S s a)
      where
        gtoNamedRecordHeader :: forall (p :: k). Options -> M1 S s a p -> [ByteString]
    gtoNamedRecordHeader Options
    opts M1 S s a p
    m
            | String -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    null String
    name = String -> [ByteString]
    forall a. HasCallStack => String -> a
    error String
    "Cannot derive DefaultOrdered for constructors without selectors"
            | Bool
    otherwise = [String -> ByteString
    B8.pack (Options -> String -> String
    fieldLabelModifier Options
    opts (M1 S s a p -> String
    forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
           (f :: k1 -> *) (a :: k1).
    Selector s =>
    t s f a -> String
    forall k1 (t :: Meta -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
           (a :: k1).
    t s f a -> String
    selName M1 S s a p
    m))]
          where name :: String
    name = M1 S s a p -> String
    forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
           (f :: k1 -> *) (a :: k1).
    Selector s =>
    t s f a -> String
    forall k1 (t :: Meta -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
           (a :: k1).
    t s f a -> String
    selName M1 S s a p
    m