    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE RecordWildCards, FlexibleInstances, DefaultSignatures #-}

    ------------------------------------------------------------------------------
    -- |
    -- Module:      Database.PostgreSQL.Simple.FromRow
    -- Copyright:   (c) 2012 Leon P Smith
    -- License:     BSD3
    -- Maintainer:  Leon P Smith <leon@melding-monads.com>
    -- Stability:   experimental
    --
    -- The 'FromRow' typeclass, for converting a row of results
    -- returned by a SQL query into a more useful Haskell representation.
    --
    -- Predefined instances are provided for tuples containing up to ten
    -- elements.  The instances for 'Maybe' types return 'Nothing' if all
    -- the columns that would have been otherwise consumed are null,  otherwise
    -- it attempts a regular conversion.
    --
    ------------------------------------------------------------------------------

    module Database.PostgreSQL.Simple.FromRow
         ( FromRow(..)
         , RowParser
         , field
         , fieldWith
         , numFieldsRemaining
         ) where

    import           Prelude hiding (null)
    import           Control.Applicative (Applicative(..), (<$>), (<|>), (*>), liftA2)
    import           Control.Monad (replicateM, replicateM_)
    import           Control.Monad.Trans.State.Strict
    import           Control.Monad.Trans.Reader
    import           Control.Monad.Trans.Class
    import           Data.ByteString (ByteString)
    import qualified Data.ByteString.Char8 as B
    import           Data.Vector (Vector)
    import qualified Data.Vector as V
    import           Database.PostgreSQL.Simple.Types (Only(..))
    import qualified Database.PostgreSQL.LibPQ as PQ
    import           Database.PostgreSQL.Simple.Internal
    import           Database.PostgreSQL.Simple.Compat
    import           Database.PostgreSQL.Simple.FromField
    import           Database.PostgreSQL.Simple.Ok
    import           Database.PostgreSQL.Simple.Types ((:.)(..), Null)
    import           Database.PostgreSQL.Simple.TypeInfo

    import           GHC.Generics

    -- | A collection type that can be converted from a sequence of fields.
    -- Instances are provided for tuples up to 10 elements and lists of any length.
    --
    -- Note that instances can be defined outside of postgresql-simple,  which is
    -- often useful.   For example, here's an instance for a user-defined pair:
    --
    -- @
    -- data User = User { name :: String, fileQuota :: Int }
    --
    -- instance 'FromRow' User where
    --     fromRow = User \<$\> 'field' \<*\> 'field'
    -- @
    --
    -- The number of calls to 'field' must match the number of fields returned
    -- in a single row of the query result.  Otherwise,  a 'ConversionFailed'
    -- exception will be thrown.
    --
    -- You can also derive 'FromRow' for your data type using GHC generics, like
    -- this:
    --
    -- @
    -- \{-# LANGUAGE DeriveAnyClass \#-}
    -- \{-# LANGUAGE DeriveGeneric  \#-}
    --
    -- import "GHC.Generics" ('GHC.Generics.Generic')
    -- import "Database.PostgreSQL.Simple" ('FromRow')
    --
    -- data User = User { name :: String, fileQuota :: Int }
    --   deriving ('GHC.Generics.Generic', 'FromRow')
    -- @
    --
    -- Note that this only works for product types (e.g. records) and does not
    -- support sum types or recursive types.
    --
    -- Note that 'field' evaluates its result to WHNF, so the caveats listed in
    -- mysql-simple and very early versions of postgresql-simple no longer apply.
    -- Instead, look at the caveats associated with user-defined implementations
    -- of 'fromField'.

    class FromRow a where
        fromRow :: RowParser a
        default fromRow :: (Generic a, GFromRow (Rep a)) => RowParser a
        fromRow = Rep a (ZonkAny 0) -> a
    forall a x. Generic a => Rep a x -> a
    forall x. Rep a x -> a
    to (Rep a (ZonkAny 0) -> a)
    -> RowParser (Rep a (ZonkAny 0)) -> RowParser a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (Rep a (ZonkAny 0))
    forall p. RowParser (Rep a p)
    forall (f :: * -> *) p. GFromRow f => RowParser (f p)
    gfromRow

    getvalue :: PQ.Result -> PQ.Row -> PQ.Column -> Maybe ByteString
    getvalue :: Result -> Row -> Column -> Maybe ByteString
    getvalue Result
    result Row
    row Column
    col = IO (Maybe ByteString) -> Maybe ByteString
    forall a. IO a -> a
    unsafeDupablePerformIO (Result -> Row -> Column -> IO (Maybe ByteString)
    PQ.getvalue' Result
    result Row
    row Column
    col)

    nfields :: PQ.Result -> PQ.Column
    nfields :: Result -> Column
    nfields Result
    result = IO Column -> Column
    forall a. IO a -> a
    unsafeDupablePerformIO (Result -> IO Column
    PQ.nfields Result
    result)

    getTypeInfoByCol :: Row -> PQ.Column -> Conversion TypeInfo
    getTypeInfoByCol :: Row -> Column -> Conversion TypeInfo
    getTypeInfoByCol Row{Row
    Result
    row :: Row
    rowresult :: Result
    rowresult :: Row -> Result
    row :: Row -> Row
    ..} Column
    col =
        (Connection -> IO (Ok TypeInfo)) -> Conversion TypeInfo
    forall a. (Connection -> IO (Ok a)) -> Conversion a
    Conversion ((Connection -> IO (Ok TypeInfo)) -> Conversion TypeInfo)
    -> (Connection -> IO (Ok TypeInfo)) -> Conversion TypeInfo
    forall a b. (a -> b) -> a -> b
    $ \Connection
    conn -> do
          oid <- Result -> Column -> IO Oid
    PQ.ftype Result
    rowresult Column
    col
          Ok <$> getTypeInfo conn oid

    getTypenameByCol :: Row -> PQ.Column -> Conversion ByteString
    getTypenameByCol :: Row -> Column -> Conversion ByteString
    getTypenameByCol Row
    row Column
    col = TypeInfo -> ByteString
    typname (TypeInfo -> ByteString)
    -> Conversion TypeInfo -> Conversion ByteString
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Row -> Column -> Conversion TypeInfo
    getTypeInfoByCol Row
    row Column
    col

    fieldWith :: FieldParser a -> RowParser a
    fieldWith :: forall a. FieldParser a -> RowParser a
    fieldWith FieldParser a
    fieldP = ReaderT Row (StateT Column Conversion) a -> RowParser a
    forall a. ReaderT Row (StateT Column Conversion) a -> RowParser a
    RP (ReaderT Row (StateT Column Conversion) a -> RowParser a)
    -> ReaderT Row (StateT Column Conversion) a -> RowParser a
    forall a b. (a -> b) -> a -> b
    $ do
        let unCol :: Column -> Int
    unCol (PQ.Col CInt
    x) = CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    x :: Int
        r@Row{..} <- ReaderT Row (StateT Column Conversion) Row
    forall (m :: * -> *) r. Monad m => ReaderT r m r
    ask
        column <- lift get
        lift (put (column + 1))
        let ncols = Result -> Column
    nfields Result
    rowresult
        if (column >= ncols)
        then lift $ lift $ do
            vals <- mapM (getTypenameByCol r) [0..ncols-1]
            let err = [Char] -> Maybe Oid -> [Char] -> [Char] -> [Char] -> ResultError
    ConversionFailed
                    (Int -> [Char]
    forall a. Show a => a -> [Char]
    show (Column -> Int
    unCol Column
    ncols) [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    " values: " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [ByteString] -> [Char]
    forall a. Show a => a -> [Char]
    show ((ByteString -> ByteString) -> [ByteString] -> [ByteString]
    forall a b. (a -> b) -> [a] -> [b]
    map ByteString -> ByteString
    ellipsis [ByteString]
    vals))
                    Maybe Oid
    forall a. Maybe a
    Nothing
                    [Char]
    ""
                    ([Char]
    "at least " [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ Int -> [Char]
    forall a. Show a => a -> [Char]
    show (Column -> Int
    unCol Column
    column Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1)
                      [Char] -> [Char] -> [Char]
    forall a. [a] -> [a] -> [a]
    ++ [Char]
    " slots in target type")
                    [Char]
    "mismatch between number of columns to \
                    \convert and number in target type"
            conversionError err
        else do
          let !result = Result
    rowresult
              !typeOid = IO Oid -> Oid
    forall a. IO a -> a
    unsafeDupablePerformIO (Result -> Column -> IO Oid
    PQ.ftype Result
    result Column
    column)
              !field' = Field{Oid
    Column
    Result
    column :: Column
    result :: Result
    typeOid :: Oid
    typeOid :: Oid
    column :: Column
    result :: Result
    ..}
          lift (lift (fieldP field' (getvalue result row column)))

    field :: FromField a => RowParser a
    field :: forall a. FromField a => RowParser a
    field = FieldParser a -> RowParser a
    forall a. FieldParser a -> RowParser a
    fieldWith FieldParser a
    forall a. FromField a => FieldParser a
    fromField

    ellipsis :: ByteString -> ByteString
    ellipsis :: ByteString -> ByteString
    ellipsis ByteString
    bs
        | ByteString -> Int
    B.length ByteString
    bs Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    > Int
    15 = Int -> ByteString -> ByteString
    B.take Int
    10 ByteString
    bs ByteString -> ByteString -> ByteString
    `B.append` ByteString
    "[...]"
        | Bool
    otherwise        = ByteString
    bs

    numFieldsRemaining :: RowParser Int
    numFieldsRemaining :: RowParser Int
    numFieldsRemaining = ReaderT Row (StateT Column Conversion) Int -> RowParser Int
    forall a. ReaderT Row (StateT Column Conversion) a -> RowParser a
    RP (ReaderT Row (StateT Column Conversion) Int -> RowParser Int)
    -> ReaderT Row (StateT Column Conversion) Int -> RowParser Int
    forall a b. (a -> b) -> a -> b
    $ do
        Row{..} <- ReaderT Row (StateT Column Conversion) Row
    forall (m :: * -> *) r. Monad m => ReaderT r m r
    ask
        column <- lift get
        return $! (\(PQ.Col CInt
    x) -> CInt -> Int
    forall a b. (Integral a, Num b) => a -> b
    fromIntegral CInt
    x) (nfields rowresult - column)

    null :: RowParser Null
    null :: RowParser Null
    null =  RowParser Null
    forall a. FromField a => RowParser a
    field

    instance (FromField a) => FromRow (Only a) where
        fromRow :: RowParser (Only a)
    fromRow = a -> Only a
    forall a. a -> Only a
    Only (a -> Only a) -> RowParser a -> RowParser (Only a)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field

    instance (FromField a) => FromRow (Maybe (Only a)) where
        fromRow :: RowParser (Maybe (Only a))
    fromRow =  (RowParser Null
    null RowParser Null
    -> RowParser (Maybe (Only a)) -> RowParser (Maybe (Only a))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (Only a) -> RowParser (Maybe (Only a))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (Only a)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (Only a))
    -> RowParser (Maybe (Only a)) -> RowParser (Maybe (Only a))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> (Only a -> Maybe (Only a)
    forall a. a -> Maybe a
    Just (Only a -> Maybe (Only a))
    -> RowParser (Only a) -> RowParser (Maybe (Only a))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (Only a)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b) => FromRow (a,b) where
        fromRow :: RowParser (a, b)
    fromRow = (,) (a -> b -> (a, b)) -> RowParser a -> RowParser (b -> (a, b))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser (b -> (a, b)) -> RowParser b -> RowParser (a, b)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b) => FromRow (Maybe (a,b)) where
        fromRow :: RowParser (Maybe (a, b))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b)) -> RowParser (Maybe (a, b))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b) -> RowParser (Maybe (a, b))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b))
    -> RowParser (Maybe (a, b)) -> RowParser (Maybe (a, b))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b) -> Maybe (a, b)
    forall a. a -> Maybe a
    Just ((a, b) -> Maybe (a, b))
    -> RowParser (a, b) -> RowParser (Maybe (a, b))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c) => FromRow (a,b,c) where
        fromRow :: RowParser (a, b, c)
    fromRow = (,,) (a -> b -> c -> (a, b, c))
    -> RowParser a -> RowParser (b -> c -> (a, b, c))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser (b -> c -> (a, b, c))
    -> RowParser b -> RowParser (c -> (a, b, c))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser (c -> (a, b, c)) -> RowParser c -> RowParser (a, b, c)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c) => FromRow (Maybe (a,b,c)) where
        fromRow :: RowParser (Maybe (a, b, c))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c)) -> RowParser (Maybe (a, b, c))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c) -> RowParser (Maybe (a, b, c))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c))
    -> RowParser (Maybe (a, b, c)) -> RowParser (Maybe (a, b, c))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c) -> Maybe (a, b, c)
    forall a. a -> Maybe a
    Just ((a, b, c) -> Maybe (a, b, c))
    -> RowParser (a, b, c) -> RowParser (Maybe (a, b, c))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d) =>
        FromRow (a,b,c,d) where
        fromRow :: RowParser (a, b, c, d)
    fromRow = (,,,) (a -> b -> c -> d -> (a, b, c, d))
    -> RowParser a -> RowParser (b -> c -> d -> (a, b, c, d))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser (b -> c -> d -> (a, b, c, d))
    -> RowParser b -> RowParser (c -> d -> (a, b, c, d))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser (c -> d -> (a, b, c, d))
    -> RowParser c -> RowParser (d -> (a, b, c, d))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser (d -> (a, b, c, d))
    -> RowParser d -> RowParser (a, b, c, d)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d) =>
        FromRow (Maybe (a,b,c,d)) where
        fromRow :: RowParser (Maybe (a, b, c, d))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d)) -> RowParser (Maybe (a, b, c, d))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d) -> RowParser (Maybe (a, b, c, d))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d))
    -> RowParser (Maybe (a, b, c, d)) -> RowParser (Maybe (a, b, c, d))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d) -> Maybe (a, b, c, d)
    forall a. a -> Maybe a
    Just ((a, b, c, d) -> Maybe (a, b, c, d))
    -> RowParser (a, b, c, d) -> RowParser (Maybe (a, b, c, d))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d, FromField e) =>
        FromRow (a,b,c,d,e) where
        fromRow :: RowParser (a, b, c, d, e)
    fromRow = (,,,,) (a -> b -> c -> d -> e -> (a, b, c, d, e))
    -> RowParser a -> RowParser (b -> c -> d -> e -> (a, b, c, d, e))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser (b -> c -> d -> e -> (a, b, c, d, e))
    -> RowParser b -> RowParser (c -> d -> e -> (a, b, c, d, e))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser (c -> d -> e -> (a, b, c, d, e))
    -> RowParser c -> RowParser (d -> e -> (a, b, c, d, e))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser (d -> e -> (a, b, c, d, e))
    -> RowParser d -> RowParser (e -> (a, b, c, d, e))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser (e -> (a, b, c, d, e))
    -> RowParser e -> RowParser (a, b, c, d, e)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d, FromField e) =>
        FromRow (Maybe (a,b,c,d,e)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e))
    -> RowParser (Maybe (a, b, c, d, e))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e) -> RowParser (Maybe (a, b, c, d, e))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e))
    -> RowParser (Maybe (a, b, c, d, e))
    -> RowParser (Maybe (a, b, c, d, e))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e) -> Maybe (a, b, c, d, e)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e) -> Maybe (a, b, c, d, e))
    -> RowParser (a, b, c, d, e) -> RowParser (Maybe (a, b, c, d, e))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f) =>
        FromRow (a,b,c,d,e,f) where
        fromRow :: RowParser (a, b, c, d, e, f)
    fromRow = (,,,,,) (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
    -> RowParser a
    -> RowParser (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
    -> RowParser b
    -> RowParser (c -> d -> e -> f -> (a, b, c, d, e, f))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser (c -> d -> e -> f -> (a, b, c, d, e, f))
    -> RowParser c -> RowParser (d -> e -> f -> (a, b, c, d, e, f))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser (d -> e -> f -> (a, b, c, d, e, f))
    -> RowParser d -> RowParser (e -> f -> (a, b, c, d, e, f))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser (e -> f -> (a, b, c, d, e, f))
    -> RowParser e -> RowParser (f -> (a, b, c, d, e, f))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                          RowParser (f -> (a, b, c, d, e, f))
    -> RowParser f -> RowParser (a, b, c, d, e, f)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f) =>
        FromRow (Maybe (a,b,c,d,e,f)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f))
    -> RowParser (Maybe (a, b, c, d, e, f))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f) -> RowParser (Maybe (a, b, c, d, e, f))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f))
    -> RowParser (Maybe (a, b, c, d, e, f))
    -> RowParser (Maybe (a, b, c, d, e, f))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f) -> Maybe (a, b, c, d, e, f)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f) -> Maybe (a, b, c, d, e, f))
    -> RowParser (a, b, c, d, e, f)
    -> RowParser (Maybe (a, b, c, d, e, f))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g) =>
        FromRow (a,b,c,d,e,f,g) where
        fromRow :: RowParser (a, b, c, d, e, f, g)
    fromRow = (,,,,,,) (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> RowParser a
    -> RowParser (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> RowParser b
    -> RowParser (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> RowParser c
    -> RowParser (d -> e -> f -> g -> (a, b, c, d, e, f, g))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser (d -> e -> f -> g -> (a, b, c, d, e, f, g))
    -> RowParser d -> RowParser (e -> f -> g -> (a, b, c, d, e, f, g))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser (e -> f -> g -> (a, b, c, d, e, f, g))
    -> RowParser e -> RowParser (f -> g -> (a, b, c, d, e, f, g))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                           RowParser (f -> g -> (a, b, c, d, e, f, g))
    -> RowParser f -> RowParser (g -> (a, b, c, d, e, f, g))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser (g -> (a, b, c, d, e, f, g))
    -> RowParser g -> RowParser (a, b, c, d, e, f, g)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g) =>
        FromRow (Maybe (a,b,c,d,e,f,g)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g))
    -> RowParser (Maybe (a, b, c, d, e, f, g))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g)
    -> RowParser (Maybe (a, b, c, d, e, f, g))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g))
    -> RowParser (Maybe (a, b, c, d, e, f, g))
    -> RowParser (Maybe (a, b, c, d, e, f, g))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g) -> Maybe (a, b, c, d, e, f, g)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g) -> Maybe (a, b, c, d, e, f, g))
    -> RowParser (a, b, c, d, e, f, g)
    -> RowParser (Maybe (a, b, c, d, e, f, g))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h) =>
        FromRow (a,b,c,d,e,f,g,h) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h)
    fromRow = (,,,,,,,) (a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> RowParser b
    -> RowParser
         (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> RowParser c
    -> RowParser (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> RowParser d
    -> RowParser (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> RowParser e
    -> RowParser (f -> g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                            RowParser (f -> g -> h -> (a, b, c, d, e, f, g, h))
    -> RowParser f -> RowParser (g -> h -> (a, b, c, d, e, f, g, h))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser (g -> h -> (a, b, c, d, e, f, g, h))
    -> RowParser g -> RowParser (h -> (a, b, c, d, e, f, g, h))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser (h -> (a, b, c, d, e, f, g, h))
    -> RowParser h -> RowParser (a, b, c, d, e, f, g, h)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h) -> Maybe (a, b, c, d, e, f, g, h)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h) -> Maybe (a, b, c, d, e, f, g, h))
    -> RowParser (a, b, c, d, e, f, g, h)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i) =>
        FromRow (a,b,c,d,e,f,g,h,i) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i)
    fromRow = (,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> (a, b, c, d, e, f, g, h, i))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser b
    -> RowParser
         (c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser c
    -> RowParser
         (d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser d
    -> RowParser (e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser (e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser e
    -> RowParser (f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                             RowParser (f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser f
    -> RowParser (g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser (g -> h -> i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser g -> RowParser (h -> i -> (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser (h -> i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser h -> RowParser (i -> (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser (i -> (a, b, c, d, e, f, g, h, i))
    -> RowParser i -> RowParser (a, b, c, d, e, f, g, h, i)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i) -> Maybe (a, b, c, d, e, f, g, h, i)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i) -> Maybe (a, b, c, d, e, f, g, h, i))
    -> RowParser (a, b, c, d, e, f, g, h, i)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j) =>
        FromRow (a,b,c,d,e,f,g,h,i,j) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j)
    fromRow = (,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser b
    -> RowParser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser c
    -> RowParser
         (d -> e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d -> e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser d
    -> RowParser
         (e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser e
    -> RowParser
         (f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                              RowParser (f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser f
    -> RowParser (g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser (g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser g
    -> RowParser (h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser (h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser h
    -> RowParser (i -> j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser (i -> j -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser i -> RowParser (j -> (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser (j -> (a, b, c, d, e, f, g, h, i, j))
    -> RowParser j -> RowParser (a, b, c, d, e, f, g, h, i, j)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j)
    -> Maybe (a, b, c, d, e, f, g, h, i, j)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j)
     -> Maybe (a, b, c, d, e, f, g, h, i, j))
    -> RowParser (a, b, c, d, e, f, g, h, i, j)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i, j)
    forall a. FromRow a => RowParser a
    fromRow)

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j,
              FromField k) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k)
    fromRow = (,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser b
    -> RowParser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser c
    -> RowParser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser d
    -> RowParser
         (e
          -> f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser e
    -> RowParser
         (f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                               RowParser
      (f -> g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser f
    -> RowParser
         (g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g -> h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser g
    -> RowParser
         (h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser (h -> i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser h
    -> RowParser (i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser (i -> j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser i
    -> RowParser (j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser (j -> k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser j
    -> RowParser (k -> (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                               RowParser (k -> (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser k -> RowParser (a, b, c, d, e, f, g, h, i, j, k)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field

    instance (FromField a, FromField b, FromField c, FromField d, FromField e,
              FromField f, FromField g, FromField h, FromField i, FromField j,
              FromField k) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k)
    forall a. FromRow a => RowParser a
    fromRow)

    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) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l)
    fromRow = (,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser b
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser c
    -> RowParser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser d
    -> RowParser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser e
    -> RowParser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser f
    -> RowParser
         (g
          -> h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser g
    -> RowParser
         (h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h -> i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser h
    -> RowParser
         (i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i -> j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser i
    -> RowParser (j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser (j -> k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser j
    -> RowParser (k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                RowParser (k -> l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser k
    -> RowParser (l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser (l -> (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser l -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field

    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) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l)
    forall a. FromRow a => RowParser a
    fromRow)

    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) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m)
    fromRow = (,,,,,,,,,,,,) (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))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser b
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser c
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser d
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser e
    -> RowParser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                 RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser f
    -> RowParser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser g
    -> RowParser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser h
    -> RowParser
         (i -> j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i -> j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser i
    -> RowParser
         (j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j -> k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser j
    -> RowParser
         (k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                 RowParser (k -> l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser k
    -> RowParser (l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser (l -> m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser l
    -> RowParser (m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser (m -> (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser m -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field

    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) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m)
    -> RowParser (Maybe (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
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m)
    forall a. FromRow a => RowParser a
    fromRow)

    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) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m,n) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    fromRow = (,,,,,,,,,,,,,) (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))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser b
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser c
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser d
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser e
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                  RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser f
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser g
    -> RowParser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser h
    -> RowParser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser i
    -> RowParser
         (j
          -> k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j
       -> k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser j
    -> RowParser
         (k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                  RowParser
      (k -> l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser k
    -> RowParser
         (l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser
      (l -> m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser l
    -> RowParser (m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser (m -> n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser m
    -> RowParser (n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field RowParser (n -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser n
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser n
    forall a. FromField a => RowParser a
    field

    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) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m,n)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m, n)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    -> RowParser (Maybe (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
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
    forall a. FromRow a => RowParser a
    fromRow)

    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) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    fromRow = (,,,,,,,,,,,,,,) (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))
    -> RowParser a
    -> RowParser
         (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
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser b
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser c
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser d
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (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))
    -> RowParser e
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                   RowParser
      (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))
    -> RowParser f
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser g
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser h
    -> RowParser
         (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. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser i
    -> RowParser
         (j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser j
    -> RowParser
         (k
          -> l
          -> m
          -> n
          -> o
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                   RowParser
      (k
       -> l
       -> m
       -> n
       -> o
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser k
    -> RowParser
         (l -> m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser
      (l -> m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser l
    -> RowParser
         (m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser
      (m -> n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser m
    -> RowParser
         (n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field RowParser (n -> o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser n
    -> RowParser (o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser n
    forall a. FromField a => RowParser a
    field RowParser (o -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser o
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser o
    forall a. FromField a => RowParser a
    field

    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) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    -> RowParser (Maybe (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
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
    forall a. FromRow a => RowParser a
    fromRow)

    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,
              FromField p) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    fromRow = (,,,,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser a
    -> RowParser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser b
    -> RowParser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser c
    -> RowParser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser d
    -> RowParser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser e
    -> RowParser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                    RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser f
    -> RowParser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser g
    -> RowParser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser h
    -> RowParser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser i
    -> RowParser
         (j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser j
    -> RowParser
         (k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                    RowParser
      (k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser k
    -> RowParser
         (l
          -> m
          -> n
          -> o
          -> p
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser
      (l
       -> m
       -> n
       -> o
       -> p
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser l
    -> RowParser
         (m
          -> n -> o -> p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser
      (m
       -> n -> o -> p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser m
    -> RowParser
         (n -> o -> p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field RowParser
      (n -> o -> p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser n
    -> RowParser
         (o -> p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser n
    forall a. FromField a => RowParser a
    field RowParser
      (o -> p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser o
    -> RowParser
         (p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser o
    forall a. FromField a => RowParser a
    field
                                    RowParser (p -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser p
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser p
    forall a. FromField a => RowParser a
    field

    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,
              FromField p) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p)) where
        fromRow :: RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    forall a. Maybe a
    Nothing)
               RowParser (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p)
    forall a. FromRow a => RowParser a
    fromRow)

    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,
              FromField p, FromField q) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    fromRow = (,,,,,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser a
    -> RowParser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser b
    -> RowParser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser c
    -> RowParser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser d
    -> RowParser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser e
    -> RowParser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                      RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser f
    -> RowParser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser g
    -> RowParser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser h
    -> RowParser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser i
    -> RowParser
         (j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser j
    -> RowParser
         (k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                      RowParser
      (k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser k
    -> RowParser
         (l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser
      (l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser l
    -> RowParser
         (m
          -> n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser
      (m
       -> n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser m
    -> RowParser
         (n
          -> o
          -> p
          -> q
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field RowParser
      (n
       -> o
       -> p
       -> q
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser n
    -> RowParser
         (o
          -> p -> q -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser n
    forall a. FromField a => RowParser a
    field RowParser
      (o
       -> p -> q -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser o
    -> RowParser
         (p -> q -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser o
    forall a. FromField a => RowParser a
    field
                                      RowParser
      (p -> q -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser p
    -> RowParser
         (q -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser p
    forall a. FromField a => RowParser a
    field RowParser
      (q -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser q
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser q
    forall a. FromField a => RowParser a
    field

    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,
              FromField p, FromField q) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q)) where
        fromRow :: RowParser
      (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    forall a. Maybe a
    Nothing)
               RowParser
      (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q)
    forall a. FromRow a => RowParser a
    fromRow)

    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,
              FromField p, FromField q, FromField r) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    fromRow = (,,,,,,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser a
    -> RowParser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser b
    -> RowParser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser c
    -> RowParser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser d
    -> RowParser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser e
    -> RowParser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                      RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser f
    -> RowParser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser g
    -> RowParser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser h
    -> RowParser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser i
    -> RowParser
         (j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser j
    -> RowParser
         (k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                      RowParser
      (k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser k
    -> RowParser
         (l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser
      (l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser l
    -> RowParser
         (m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser
      (m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser m
    -> RowParser
         (n
          -> o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field RowParser
      (n
       -> o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser n
    -> RowParser
         (o
          -> p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser n
    forall a. FromField a => RowParser a
    field RowParser
      (o
       -> p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser o
    -> RowParser
         (p
          -> q
          -> r
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser o
    forall a. FromField a => RowParser a
    field
                                      RowParser
      (p
       -> q
       -> r
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser p
    -> RowParser
         (q -> r -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser p
    forall a. FromField a => RowParser a
    field RowParser
      (q -> r -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser q
    -> RowParser
         (r -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser q
    forall a. FromField a => RowParser a
    field RowParser
      (r -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser r
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser r
    forall a. FromField a => RowParser a
    field

    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,
              FromField p, FromField q, FromField r) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r)) where
        fromRow :: RowParser
      (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    forall a. Maybe a
    Nothing)
               RowParser
      (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    -> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r)
    forall a. FromRow a => RowParser a
    fromRow)

    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,
              FromField p, FromField q, FromField r, FromField s) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s) where
        fromRow :: RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    fromRow = (,,,,,,,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser a
    -> RowParser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser b
    -> RowParser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser c
    -> RowParser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser d
    -> RowParser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser e
    -> RowParser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                       RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser f
    -> RowParser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser g
    -> RowParser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser h
    -> RowParser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser i
    -> RowParser
         (j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser j
    -> RowParser
         (k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                       RowParser
      (k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser k
    -> RowParser
         (l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser
      (l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser l
    -> RowParser
         (m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser
      (m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser m
    -> RowParser
         (n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field RowParser
      (n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser n
    -> RowParser
         (o
          -> p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser n
    forall a. FromField a => RowParser a
    field RowParser
      (o
       -> p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser o
    -> RowParser
         (p
          -> q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser o
    forall a. FromField a => RowParser a
    field
                                       RowParser
      (p
       -> q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser p
    -> RowParser
         (q
          -> r
          -> s
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser p
    forall a. FromField a => RowParser a
    field RowParser
      (q
       -> r
       -> s
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser q
    -> RowParser
         (r
          -> s -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser q
    forall a. FromField a => RowParser a
    field RowParser
      (r
       -> s -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser r
    -> RowParser
         (s -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser r
    forall a. FromField a => RowParser a
    field RowParser
      (s -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser s
    -> RowParser
         (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser s
    forall a. FromField a => RowParser a
    field

    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,
              FromField p, FromField q, FromField r, FromField s) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s)) where
        fromRow :: RowParser
      (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    forall a. Maybe a
    Nothing)
               RowParser
      (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
     -> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    -> RowParser
         (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    -> RowParser
         (Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s)
    forall a. FromRow a => RowParser a
    fromRow)

    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,
              FromField p, FromField q, FromField r, FromField s, FromField t) =>
        FromRow (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t) where
        fromRow :: RowParser
      (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    fromRow = (,,,,,,,,,,,,,,,,,,,) (a
     -> b
     -> c
     -> d
     -> e
     -> f
     -> g
     -> h
     -> i
     -> j
     -> k
     -> l
     -> m
     -> n
     -> o
     -> p
     -> q
     -> r
     -> s
     -> t
     -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser a
    -> RowParser
         (b
          -> c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field RowParser
      (b
       -> c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser b
    -> RowParser
         (c
          -> d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromField a => RowParser a
    field RowParser
      (c
       -> d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser c
    -> RowParser
         (d
          -> e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser c
    forall a. FromField a => RowParser a
    field RowParser
      (d
       -> e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser d
    -> RowParser
         (e
          -> f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser d
    forall a. FromField a => RowParser a
    field RowParser
      (e
       -> f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser e
    -> RowParser
         (f
          -> g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser e
    forall a. FromField a => RowParser a
    field
                                        RowParser
      (f
       -> g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser f
    -> RowParser
         (g
          -> h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser f
    forall a. FromField a => RowParser a
    field RowParser
      (g
       -> h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser g
    -> RowParser
         (h
          -> i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser g
    forall a. FromField a => RowParser a
    field RowParser
      (h
       -> i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser h
    -> RowParser
         (i
          -> j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser h
    forall a. FromField a => RowParser a
    field RowParser
      (i
       -> j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser i
    -> RowParser
         (j
          -> k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser i
    forall a. FromField a => RowParser a
    field RowParser
      (j
       -> k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser j
    -> RowParser
         (k
          -> l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser j
    forall a. FromField a => RowParser a
    field
                                        RowParser
      (k
       -> l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser k
    -> RowParser
         (l
          -> m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser k
    forall a. FromField a => RowParser a
    field RowParser
      (l
       -> m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser l
    -> RowParser
         (m
          -> n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser l
    forall a. FromField a => RowParser a
    field RowParser
      (m
       -> n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser m
    -> RowParser
         (n
          -> o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser m
    forall a. FromField a => RowParser a
    field RowParser
      (n
       -> o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser n
    -> RowParser
         (o
          -> p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser n
    forall a. FromField a => RowParser a
    field RowParser
      (o
       -> p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser o
    -> RowParser
         (p
          -> q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser o
    forall a. FromField a => RowParser a
    field
                                        RowParser
      (p
       -> q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser p
    -> RowParser
         (q
          -> r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser p
    forall a. FromField a => RowParser a
    field RowParser
      (q
       -> r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser q
    -> RowParser
         (r
          -> s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser q
    forall a. FromField a => RowParser a
    field RowParser
      (r
       -> s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser r
    -> RowParser
         (s
          -> t
          -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser r
    forall a. FromField a => RowParser a
    field RowParser
      (s
       -> t
       -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser s
    -> RowParser
         (t -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser s
    forall a. FromField a => RowParser a
    field RowParser
      (t -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser t
    -> RowParser
         (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser t
    forall a. FromField a => RowParser a
    field

    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,
              FromField p, FromField q, FromField r, FromField s, FromField t) =>
        FromRow (Maybe (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t)) where
        fromRow :: RowParser
      (Maybe
         (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    fromRow =  (RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>
                    RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null -> RowParser Null -> RowParser Null
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> RowParser Null
    null RowParser Null
    -> RowParser
         (Maybe
            (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser
         (Maybe
            (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a b. RowParser a -> RowParser b -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    -> RowParser
         (Maybe
            (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure Maybe (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    forall a. Maybe a
    Nothing)
               RowParser
      (Maybe
         (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser
         (Maybe
            (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser
         (Maybe
            (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall a. RowParser a -> RowParser a -> RowParser a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    <|> ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    -> Maybe
         (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    forall a. a -> Maybe a
    Just ((a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
     -> Maybe
          (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    -> RowParser
         (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    -> RowParser
         (Maybe
            (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser
      (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t)
    forall a. FromRow a => RowParser a
    fromRow)

    instance FromField a => FromRow [a] where
        fromRow :: RowParser [a]
    fromRow = do
          n <- RowParser Int
    numFieldsRemaining
          replicateM n field

    instance FromField a => FromRow (Maybe [a]) where
        fromRow :: RowParser (Maybe [a])
    fromRow = do
          n <- RowParser Int
    numFieldsRemaining
          (replicateM_ n null *> pure Nothing) <|> (Just <$> replicateM n field)

    instance FromField a => FromRow (Vector a) where
        fromRow :: RowParser (Vector a)
    fromRow = do
          n <- RowParser Int
    numFieldsRemaining
          V.replicateM n field

    instance FromField a => FromRow (Maybe (Vector a)) where
        fromRow :: RowParser (Maybe (Vector a))
    fromRow = do
          n <- RowParser Int
    numFieldsRemaining
          (replicateM_ n null *> pure Nothing) <|> (Just <$> V.replicateM n field)

    instance (FromRow a, FromRow b) => FromRow (a :. b) where
        fromRow :: RowParser (a :. b)
    fromRow = a -> b -> a :. b
    forall h t. h -> t -> h :. t
    (:.) (a -> b -> a :. b) -> RowParser a -> RowParser (b -> a :. b)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromRow a => RowParser a
    fromRow RowParser (b -> a :. b) -> RowParser b -> RowParser (a :. b)
    forall a b. RowParser (a -> b) -> RowParser a -> RowParser b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> RowParser b
    forall a. FromRow a => RowParser a
    fromRow

    -- Type class for default implementation of FromRow using generics
    class GFromRow f where
        gfromRow :: RowParser (f p)

    instance GFromRow f => GFromRow (M1 c i f) where
        gfromRow :: forall p. RowParser (M1 c i f p)
    gfromRow = f p -> M1 c i f p
    forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
    M1 (f p -> M1 c i f p) -> RowParser (f p) -> RowParser (M1 c i f p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser (f p)
    forall p. RowParser (f p)
    forall (f :: * -> *) p. GFromRow f => RowParser (f p)
    gfromRow

    instance (GFromRow f, GFromRow g) => GFromRow (f :*: g) where
        gfromRow :: forall p. RowParser ((:*:) f g p)
    gfromRow = (f p -> g p -> (:*:) f g p)
    -> RowParser (f p) -> RowParser (g p) -> RowParser ((:*:) f g p)
    forall a b c.
    (a -> b -> c) -> RowParser a -> RowParser b -> RowParser c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 f p -> g p -> (:*:) f g p
    forall k (f :: k -> *) (g :: k -> *) (p :: k).
    f p -> g p -> (:*:) f g p
    (:*:) RowParser (f p)
    forall p. RowParser (f p)
    forall (f :: * -> *) p. GFromRow f => RowParser (f p)
    gfromRow RowParser (g p)
    forall p. RowParser (g p)
    forall (f :: * -> *) p. GFromRow f => RowParser (f p)
    gfromRow

    instance (FromField a) => GFromRow (K1 R a) where
        gfromRow :: forall p. RowParser (K1 R a p)
    gfromRow = a -> K1 R a p
    forall k i c (p :: k). c -> K1 i c p
    K1 (a -> K1 R a p) -> RowParser a -> RowParser (K1 R a p)
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> RowParser a
    forall a. FromField a => RowParser a
    field

    instance GFromRow U1 where
        gfromRow :: forall p. RowParser (U1 p)
    gfromRow = U1 p -> RowParser (U1 p)
    forall a. a -> RowParser a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure U1 p
    forall k (p :: k). U1 p
    U1