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

-----------------------------------------------------------------------------
-- |
-- Module      :  Data.CSV.Conduit.Conversion
-- Copyright   :  Ozgun Ataman, Johan Tibell
-- License     :  BSD3
--
-- Maintainer  :  Ozgun Ataman <ozataman@gmail.com>
-- Stability   :  experimental
--
-- This module has been shamelessly taken from Johan Tibell's nicely
-- put together cassava package, which itself borrows the approach
-- from Bryan O'Sullivan's widely used aeson package.
--
-- We make the necessary adjustments and some simplifications here to
-- bolt this parsing interface onto our underlying "CSV" typeclass.
----------------------------------------------------------------------------

module Data.CSV.Conduit.Conversion
    (
    -- * Type conversion
      Only(..)
    , Named (..)
    , NamedOrdered (..)
    , Record
    , NamedRecord
    , NamedRecordOrdered
    , FromRecord(..)
    , FromNamedRecord(..)
    , FromNamedRecordOrdered(..)
    , ToNamedRecord(..)
    , ToNamedRecordOrdered(..)
    , FromField(..)
    , ToRecord(..)
    , ToField(..)
    , Field

    -- * Parser
    , Parser
    , runParser

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

import Control.Applicative as A
import Control.Monad (MonadPlus, mplus, mzero)
import Data.Attoparsec.ByteString.Char8 (double, parseOnly)
import qualified Data.Attoparsec.ByteString.Char8 as A8
import qualified Data.ByteString as B
import qualified Data.ByteString.Char8 as B8
import qualified Data.ByteString.Lazy as L
import Data.Int (Int8, Int16, Int32, Int64)
import Data.Kind (Type)
import qualified Data.Map as M
import qualified Data.Map.Ordered as MO
import Data.Semigroup as Semigroup
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.Text.Lazy as LT
import qualified Data.Text.Lazy.Encoding as LT
import Data.Traversable as DT
import Data.Vector (Vector, (!))
import qualified Data.Vector as V
import qualified Data.Vector.Unboxed as U
import Data.Word as W
import GHC.Float (double2Float)
import Prelude hiding (lookup, takeWhile)

#ifdef GENERICS
import GHC.Generics
import qualified Data.IntMap as IM
#endif

import Data.CSV.Conduit.Conversion.Internal


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

toStrict   :: L.ByteString -> B.ByteString
fromStrict :: B.ByteString -> L.ByteString
#if MIN_VERSION_bytestring(0,10,0)
toStrict :: ByteString -> ByteString
toStrict   = ByteString -> ByteString
L.toStrict
fromStrict :: ByteString -> ByteString
fromStrict = ByteString -> ByteString
L.fromStrict
#else
toStrict   = B.concat . L.toChunks
fromStrict = L.fromChunks . (:[])
#endif
{-# INLINE toStrict #-}
{-# INLINE fromStrict #-}

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



-- | A shorthand for the ByteString case of 'MapRow'
type NamedRecord = M.Map B8.ByteString B8.ByteString
type NamedRecordOrdered = MO.OMap B8.ByteString B8.ByteString


-- | A wrapper around custom haskell types that can directly be
-- converted/parsed from an incoming CSV stream.
--
-- We define this wrapper to stop GHC from complaining
-- about overlapping instances. Just use 'getNamed' to get your
-- object out of the wrapper.
newtype Named a = Named { Named a -> a
getNamed :: a } deriving (Named a -> Named a -> Bool
(Named a -> Named a -> Bool)
-> (Named a -> Named a -> Bool) -> Eq (Named a)
forall a. Eq a => Named a -> Named a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Named a -> Named a -> Bool
$c/= :: forall a. Eq a => Named a -> Named a -> Bool
== :: Named a -> Named a -> Bool
$c== :: forall a. Eq a => Named a -> Named a -> Bool
Eq,Int -> Named a -> ShowS
[Named a] -> ShowS
Named a -> String
(Int -> Named a -> ShowS)
-> (Named a -> String) -> ([Named a] -> ShowS) -> Show (Named a)
forall a. Show a => Int -> Named a -> ShowS
forall a. Show a => [Named a] -> ShowS
forall a. Show a => Named a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Named a] -> ShowS
$cshowList :: forall a. Show a => [Named a] -> ShowS
show :: Named a -> String
$cshow :: forall a. Show a => Named a -> String
showsPrec :: Int -> Named a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Named a -> ShowS
Show,ReadPrec [Named a]
ReadPrec (Named a)
Int -> ReadS (Named a)
ReadS [Named a]
(Int -> ReadS (Named a))
-> ReadS [Named a]
-> ReadPrec (Named a)
-> ReadPrec [Named a]
-> Read (Named a)
forall a. Read a => ReadPrec [Named a]
forall a. Read a => ReadPrec (Named a)
forall a. Read a => Int -> ReadS (Named a)
forall a. Read a => ReadS [Named a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Named a]
$creadListPrec :: forall a. Read a => ReadPrec [Named a]
readPrec :: ReadPrec (Named a)
$creadPrec :: forall a. Read a => ReadPrec (Named a)
readList :: ReadS [Named a]
$creadList :: forall a. Read a => ReadS [Named a]
readsPrec :: Int -> ReadS (Named a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Named a)
Read,Eq (Named a)
Eq (Named a)
-> (Named a -> Named a -> Ordering)
-> (Named a -> Named a -> Bool)
-> (Named a -> Named a -> Bool)
-> (Named a -> Named a -> Bool)
-> (Named a -> Named a -> Bool)
-> (Named a -> Named a -> Named a)
-> (Named a -> Named a -> Named a)
-> Ord (Named a)
Named a -> Named a -> Bool
Named a -> Named a -> Ordering
Named a -> Named a -> Named a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Named a)
forall a. Ord a => Named a -> Named a -> Bool
forall a. Ord a => Named a -> Named a -> Ordering
forall a. Ord a => Named a -> Named a -> Named a
min :: Named a -> Named a -> Named a
$cmin :: forall a. Ord a => Named a -> Named a -> Named a
max :: Named a -> Named a -> Named a
$cmax :: forall a. Ord a => Named a -> Named a -> Named a
>= :: Named a -> Named a -> Bool
$c>= :: forall a. Ord a => Named a -> Named a -> Bool
> :: Named a -> Named a -> Bool
$c> :: forall a. Ord a => Named a -> Named a -> Bool
<= :: Named a -> Named a -> Bool
$c<= :: forall a. Ord a => Named a -> Named a -> Bool
< :: Named a -> Named a -> Bool
$c< :: forall a. Ord a => Named a -> Named a -> Bool
compare :: Named a -> Named a -> Ordering
$ccompare :: forall a. Ord a => Named a -> Named a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Named a)
Ord)
newtype NamedOrdered a = NamedOrdered { NamedOrdered a -> a
getNamedOrdered :: a } deriving (NamedOrdered a -> NamedOrdered a -> Bool
(NamedOrdered a -> NamedOrdered a -> Bool)
-> (NamedOrdered a -> NamedOrdered a -> Bool)
-> Eq (NamedOrdered a)
forall a. Eq a => NamedOrdered a -> NamedOrdered a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NamedOrdered a -> NamedOrdered a -> Bool
$c/= :: forall a. Eq a => NamedOrdered a -> NamedOrdered a -> Bool
== :: NamedOrdered a -> NamedOrdered a -> Bool
$c== :: forall a. Eq a => NamedOrdered a -> NamedOrdered a -> Bool
Eq,Int -> NamedOrdered a -> ShowS
[NamedOrdered a] -> ShowS
NamedOrdered a -> String
(Int -> NamedOrdered a -> ShowS)
-> (NamedOrdered a -> String)
-> ([NamedOrdered a] -> ShowS)
-> Show (NamedOrdered a)
forall a. Show a => Int -> NamedOrdered a -> ShowS
forall a. Show a => [NamedOrdered a] -> ShowS
forall a. Show a => NamedOrdered a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NamedOrdered a] -> ShowS
$cshowList :: forall a. Show a => [NamedOrdered a] -> ShowS
show :: NamedOrdered a -> String
$cshow :: forall a. Show a => NamedOrdered a -> String
showsPrec :: Int -> NamedOrdered a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> NamedOrdered a -> ShowS
Show,ReadPrec [NamedOrdered a]
ReadPrec (NamedOrdered a)
Int -> ReadS (NamedOrdered a)
ReadS [NamedOrdered a]
(Int -> ReadS (NamedOrdered a))
-> ReadS [NamedOrdered a]
-> ReadPrec (NamedOrdered a)
-> ReadPrec [NamedOrdered a]
-> Read (NamedOrdered a)
forall a. Read a => ReadPrec [NamedOrdered a]
forall a. Read a => ReadPrec (NamedOrdered a)
forall a. Read a => Int -> ReadS (NamedOrdered a)
forall a. Read a => ReadS [NamedOrdered a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NamedOrdered a]
$creadListPrec :: forall a. Read a => ReadPrec [NamedOrdered a]
readPrec :: ReadPrec (NamedOrdered a)
$creadPrec :: forall a. Read a => ReadPrec (NamedOrdered a)
readList :: ReadS [NamedOrdered a]
$creadList :: forall a. Read a => ReadS [NamedOrdered a]
readsPrec :: Int -> ReadS (NamedOrdered a)
$creadsPrec :: forall a. Read a => Int -> ReadS (NamedOrdered a)
Read,Eq (NamedOrdered a)
Eq (NamedOrdered a)
-> (NamedOrdered a -> NamedOrdered a -> Ordering)
-> (NamedOrdered a -> NamedOrdered a -> Bool)
-> (NamedOrdered a -> NamedOrdered a -> Bool)
-> (NamedOrdered a -> NamedOrdered a -> Bool)
-> (NamedOrdered a -> NamedOrdered a -> Bool)
-> (NamedOrdered a -> NamedOrdered a -> NamedOrdered a)
-> (NamedOrdered a -> NamedOrdered a -> NamedOrdered a)
-> Ord (NamedOrdered a)
NamedOrdered a -> NamedOrdered a -> Bool
NamedOrdered a -> NamedOrdered a -> Ordering
NamedOrdered a -> NamedOrdered a -> NamedOrdered a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (NamedOrdered a)
forall a. Ord a => NamedOrdered a -> NamedOrdered a -> Bool
forall a. Ord a => NamedOrdered a -> NamedOrdered a -> Ordering
forall a.
Ord a =>
NamedOrdered a -> NamedOrdered a -> NamedOrdered a
min :: NamedOrdered a -> NamedOrdered a -> NamedOrdered a
$cmin :: forall a.
Ord a =>
NamedOrdered a -> NamedOrdered a -> NamedOrdered a
max :: NamedOrdered a -> NamedOrdered a -> NamedOrdered a
$cmax :: forall a.
Ord a =>
NamedOrdered a -> NamedOrdered a -> NamedOrdered a
>= :: NamedOrdered a -> NamedOrdered a -> Bool
$c>= :: forall a. Ord a => NamedOrdered a -> NamedOrdered a -> Bool
> :: NamedOrdered a -> NamedOrdered a -> Bool
$c> :: forall a. Ord a => NamedOrdered a -> NamedOrdered a -> Bool
<= :: NamedOrdered a -> NamedOrdered a -> Bool
$c<= :: forall a. Ord a => NamedOrdered a -> NamedOrdered a -> Bool
< :: NamedOrdered a -> NamedOrdered a -> Bool
$c< :: forall a. Ord a => NamedOrdered a -> NamedOrdered a -> Bool
compare :: NamedOrdered a -> NamedOrdered a -> Ordering
$ccompare :: forall a. Ord a => NamedOrdered a -> NamedOrdered a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (NamedOrdered a)
Ord)

-- | A record corresponds to a single line in a CSV file.
type Record = Vector B8.ByteString

-- | A single field within a record.
type Field = B8.ByteString


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

-- | A type that can be converted from a single CSV record, with the
-- possibility of failure.
--
-- When writing an instance, use 'empty', 'mzero', or 'fail' to make a
-- conversion fail, e.g. if a 'Record' has the wrong number of
-- columns.
--
-- Given this example data:
--
-- > John,56
-- > Jane,55
--
-- here's an example type and instance:
--
-- > data Person = Person { name :: !Text, age :: !Int }
-- >
-- > instance FromRecord Person where
-- >     parseRecord v
-- >         | length v == 2 = Person <$>
-- >                           v .! 0 <*>
-- >                           v .! 1
-- >         | otherwise     = mzero
class FromRecord a where
    parseRecord :: Record -> Parser a
  
#ifdef GENERICS
    default parseRecord :: (Generic a, GFromRecord (Rep a)) => Record -> Parser a
    parseRecord Record
r = Rep a Any -> a
forall a x. Generic a => Rep a x -> a
to (Rep a Any -> a) -> Parser (Rep a Any) -> Parser a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
A.<$> Record -> Parser (Rep a Any)
forall (f :: * -> *) p. GFromRecord f => Record -> Parser (f p)
gparseRecord Record
r
#endif

-- | Haskell lacks a single-element tuple type, so if you CSV data
-- with just one column you can use the 'Only' type to represent a
-- single-column result.
newtype Only a = Only {
      Only a -> a
fromOnly :: a
    } deriving (Only a -> Only a -> Bool
(Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool) -> Eq (Only a)
forall a. Eq a => Only a -> Only a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Only a -> Only a -> Bool
$c/= :: forall a. Eq a => Only a -> Only a -> Bool
== :: Only a -> Only a -> Bool
$c== :: forall a. Eq a => Only a -> Only a -> Bool
Eq, Eq (Only a)
Eq (Only a)
-> (Only a -> Only a -> Ordering)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Bool)
-> (Only a -> Only a -> Only a)
-> (Only a -> Only a -> Only a)
-> Ord (Only a)
Only a -> Only a -> Bool
Only a -> Only a -> Ordering
Only a -> Only a -> Only a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Only a)
forall a. Ord a => Only a -> Only a -> Bool
forall a. Ord a => Only a -> Only a -> Ordering
forall a. Ord a => Only a -> Only a -> Only a
min :: Only a -> Only a -> Only a
$cmin :: forall a. Ord a => Only a -> Only a -> Only a
max :: Only a -> Only a -> Only a
$cmax :: forall a. Ord a => Only a -> Only a -> Only a
>= :: Only a -> Only a -> Bool
$c>= :: forall a. Ord a => Only a -> Only a -> Bool
> :: Only a -> Only a -> Bool
$c> :: forall a. Ord a => Only a -> Only a -> Bool
<= :: Only a -> Only a -> Bool
$c<= :: forall a. Ord a => Only a -> Only a -> Bool
< :: Only a -> Only a -> Bool
$c< :: forall a. Ord a => Only a -> Only a -> Bool
compare :: Only a -> Only a -> Ordering
$ccompare :: forall a. Ord a => Only a -> Only a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Only a)
Ord, ReadPrec [Only a]
ReadPrec (Only a)
Int -> ReadS (Only a)
ReadS [Only a]
(Int -> ReadS (Only a))
-> ReadS [Only a]
-> ReadPrec (Only a)
-> ReadPrec [Only a]
-> Read (Only a)
forall a. Read a => ReadPrec [Only a]
forall a. Read a => ReadPrec (Only a)
forall a. Read a => Int -> ReadS (Only a)
forall a. Read a => ReadS [Only a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Only a]
$creadListPrec :: forall a. Read a => ReadPrec [Only a]
readPrec :: ReadPrec (Only a)
$creadPrec :: forall a. Read a => ReadPrec (Only a)
readList :: ReadS [Only a]
$creadList :: forall a. Read a => ReadS [Only a]
readsPrec :: Int -> ReadS (Only a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Only a)
Read, Int -> Only a -> ShowS
[Only a] -> ShowS
Only a -> String
(Int -> Only a -> ShowS)
-> (Only a -> String) -> ([Only a] -> ShowS) -> Show (Only a)
forall a. Show a => Int -> Only a -> ShowS
forall a. Show a => [Only a] -> ShowS
forall a. Show a => Only a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Only a] -> ShowS
$cshowList :: forall a. Show a => [Only a] -> ShowS
show :: Only a -> String
$cshow :: forall a. Show a => Only a -> String
showsPrec :: Int -> Only a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Only a -> ShowS
Show)

-- | A type that can be converted to a single CSV record.
--
-- An example type and instance:
--
-- > data Person = Person { name :: !Text, age :: !Int }
-- >
-- > instance ToRecord Person where
-- >     toRecord (Person name age) = record [
-- >         toField name, toField age]
--
-- Outputs data on this form:
--
-- > John,56
-- > Jane,55
class ToRecord a where
    toRecord :: a -> Record

#ifdef GENERICS
    default toRecord :: (Generic a, GToRecord (Rep a) Field) => a -> Record
    toRecord = [ByteString] -> Record
forall a. [a] -> Vector a
V.fromList ([ByteString] -> Record) -> (a -> [ByteString]) -> a -> Record
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a Any -> [ByteString]
forall (a :: * -> *) f p. GToRecord a f => a p -> [f]
gtoRecord (Rep a Any -> [ByteString])
-> (a -> Rep a Any) -> a -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall a x. Generic a => a -> Rep a x
from
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | A type that can be converted from a single CSV record, with the
-- possibility of failure.
--
-- When writing an instance, use 'empty', 'mzero', or 'fail' to make a
-- conversion fail, e.g. if a 'Record' has the wrong number of
-- columns.
--
-- Given this example data:
--
-- > name,age
-- > John,56
-- > Jane,55
--
-- here's an example type and instance:
--
-- > {-# LANGUAGE OverloadedStrings #-}
-- >
-- > data Person = Person { name :: !Text, age :: !Int }
-- >
-- > instance FromNamedRecord Person where
-- >     parseNamedRecord m = Person <$>
-- >                          m .: "name" <*>
-- >                          m .: "age"
--
-- Note the use of the @OverloadedStrings@ language extension which
-- enables 'B8.ByteString' values to be written as string literals.
class FromNamedRecord a where
    parseNamedRecord :: NamedRecord -> Parser a

#ifdef GENERICS
    default parseNamedRecord :: (Generic a, GFromNamedRecord (Rep a)) => NamedRecord -> Parser a
    parseNamedRecord NamedRecord
r = Rep a Any -> a
forall a x. Generic a => Rep a x -> a
to (Rep a Any -> a) -> Parser (Rep a Any) -> Parser a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NamedRecord -> Parser (Rep a Any)
forall (f :: * -> *) p.
GFromNamedRecord f =>
NamedRecord -> Parser (f p)
gparseNamedRecord NamedRecord
r
#endif

class FromNamedRecordOrdered a where
    parseNamedRecordOrdered :: NamedRecordOrdered -> Parser a

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

#ifdef GENERICS
    default toNamedRecord :: (Generic a, GToRecord (Rep a) (B.ByteString, B.ByteString)) => a -> NamedRecord
    toNamedRecord = [(ByteString, ByteString)] -> NamedRecord
namedRecord ([(ByteString, ByteString)] -> NamedRecord)
-> (a -> [(ByteString, ByteString)]) -> a -> NamedRecord
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a Any -> [(ByteString, ByteString)]
forall (a :: * -> *) f p. GToRecord a f => a p -> [f]
gtoRecord (Rep a Any -> [(ByteString, ByteString)])
-> (a -> Rep a Any) -> a -> [(ByteString, ByteString)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall a x. Generic a => a -> Rep a x
from
#endif

class ToNamedRecordOrdered a where
    toNamedRecordOrdered :: a -> NamedRecordOrdered

instance FromField a => FromNamedRecord (M.Map B.ByteString a) where
    parseNamedRecord :: NamedRecord -> Parser (Map ByteString a)
parseNamedRecord NamedRecord
m = (ByteString -> Parser a)
-> NamedRecord -> Parser (Map ByteString a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ByteString -> Parser a
forall a. FromField a => ByteString -> Parser a
parseField NamedRecord
m

instance FromField a => FromNamedRecordOrdered (MO.OMap B.ByteString a) where
    parseNamedRecordOrdered :: NamedRecordOrdered -> Parser (OMap ByteString a)
parseNamedRecordOrdered NamedRecordOrdered
m = (ByteString -> Parser a)
-> NamedRecordOrdered -> Parser (OMap ByteString a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse ByteString -> Parser a
forall a. FromField a => ByteString -> Parser a
parseField NamedRecordOrdered
m

instance ToField a => ToNamedRecord (M.Map B.ByteString a) where
    toNamedRecord :: Map ByteString a -> NamedRecord
toNamedRecord = (a -> ByteString) -> Map ByteString a -> NamedRecord
forall a b k. (a -> b) -> Map k a -> Map k b
M.map a -> ByteString
forall a. ToField a => a -> ByteString
toField

instance ToField a => ToNamedRecordOrdered (MO.OMap B.ByteString a) where
    toNamedRecordOrdered :: OMap ByteString a -> NamedRecordOrdered
toNamedRecordOrdered OMap ByteString a
a = [(ByteString, ByteString)] -> NamedRecordOrdered
forall k v. Ord k => [(k, v)] -> OMap k v
MO.fromList ([(ByteString, ByteString)] -> NamedRecordOrdered)
-> [(ByteString, ByteString)] -> NamedRecordOrdered
forall a b. (a -> b) -> a -> b
$ ((ByteString, a) -> (ByteString, ByteString))
-> [(ByteString, a)] -> [(ByteString, ByteString)]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> ByteString) -> (ByteString, a) -> (ByteString, ByteString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> ByteString
forall a. ToField a => a -> ByteString
toField) ([(ByteString, a)] -> [(ByteString, ByteString)])
-> [(ByteString, a)] -> [(ByteString, ByteString)]
forall a b. (a -> b) -> a -> b
$ OMap ByteString a -> [(ByteString, a)]
forall k v. OMap k v -> [(k, v)]
MO.assocs OMap ByteString a
a

-- instance FromField a => FromNamedRecord (HM.HashMap B.ByteString a) where
--     parseNamedRecord m = traverse (\ s -> parseField s) m

-- instance ToField a => ToNamedRecord (HM.HashMap B.ByteString a) where
--     toNamedRecord = HM.map toField

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

-- | A type that can be converted from a single CSV field, with the
-- possibility of failure.
--
-- When writing an instance, use 'empty', 'mzero', or 'fail' to make a
-- conversion fail, e.g. if a 'Field' can't be converted to the given
-- type.
--
-- Example type and instance:
--
-- > {-# LANGUAGE OverloadedStrings #-}
-- >
-- > data Color = Red | Green | Blue
-- >
-- > instance FromField Color where
-- >     parseField s
-- >         | s == "R"  = pure Red
-- >         | s == "G"  = pure Green
-- >         | s == "B"  = pure Blue
-- >         | otherwise = mzero
class FromField a where
    parseField :: Field -> Parser a

-- | A type that can be converted to a single CSV field.
--
-- Example type and instance:
--
-- > {-# LANGUAGE OverloadedStrings #-}
-- >
-- > data Color = Red | Green | Blue
-- >
-- > instance ToField Color where
-- >     toField Red   = "R"
-- >     toField Green = "G"
-- >     toField Blue  = "B"
class ToField a where
    toField :: a -> Field

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Retrieve the /n/th field in the given record. The result is
-- 'empty' if the value cannot be converted to the desired type.
-- Raises an exception if the index is out of bounds.
--
-- 'index' is a simple convenience function that is equivalent to
-- @'parseField' (v '!' idx)@. If you're certain that the index is not
-- out of bounds, using 'unsafeIndex' is somewhat faster.
index :: FromField a => Record -> Int -> Parser a
index :: Record -> Int -> Parser a
index Record
v Int
idx = ByteString -> Parser a
forall a. FromField a => ByteString -> Parser a
parseField (Record
v Record -> Int -> ByteString
forall a. Vector a -> Int -> a
! Int
idx)
{-# INLINE index #-}

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

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

-- | Retrieve a field in the given record by name.  The result is
-- 'empty' if the field is missing or if the value cannot be converted
-- to the desired type.
lookup :: FromField a => NamedRecord -> B.ByteString -> Parser a
lookup :: NamedRecord -> ByteString -> Parser a
lookup NamedRecord
m ByteString
name = Parser a
-> (ByteString -> Parser a) -> Maybe ByteString -> Parser a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
err) ByteString -> Parser a
forall a. FromField a => ByteString -> Parser a
parseField (Maybe ByteString -> Parser a) -> Maybe ByteString -> Parser a
forall a b. (a -> b) -> a -> b
$ ByteString -> NamedRecord -> Maybe ByteString
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup ByteString
name NamedRecord
m
  where err :: String
err = String
"no field named " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show (ByteString -> String
B8.unpack ByteString
name)
{-# INLINE lookup #-}

lookupOrdered :: FromField a => NamedRecordOrdered -> B.ByteString -> Parser a
lookupOrdered :: NamedRecordOrdered -> ByteString -> Parser a
lookupOrdered NamedRecordOrdered
m ByteString
name = Parser a
-> (ByteString -> Parser a) -> Maybe ByteString -> Parser a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
err) ByteString -> Parser a
forall a. FromField a => ByteString -> Parser a
parseField (Maybe ByteString -> Parser a) -> Maybe ByteString -> Parser a
forall a b. (a -> b) -> a -> b
$ ByteString -> NamedRecordOrdered -> Maybe ByteString
forall k v. Ord k => k -> OMap k v -> Maybe v
MO.lookup ByteString
name NamedRecordOrdered
m
  where err :: String
err = String
"no field named " String -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
forall a. Show a => a -> String
show (ByteString -> String
B8.unpack ByteString
name)
{-# INLINE lookupOrdered #-}

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

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

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

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

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

namedRecordOrdered :: [(B.ByteString, B.ByteString)] -> NamedRecordOrdered
namedRecordOrdered :: [(ByteString, ByteString)] -> NamedRecordOrdered
namedRecordOrdered = [(ByteString, ByteString)] -> NamedRecordOrdered
forall k v. Ord k => [(k, v)] -> OMap k v
MO.fromList

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

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

-- | Conversion of a field to a value might fail e.g. if the field is
-- malformed. This possibility is captured by the 'Parser' type, which
-- lets you compose several field conversions together in such a way
-- that if any of them fail, the whole record conversion fails.
newtype Parser a = Parser {
      Parser a
-> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
unParser :: forall f r.
                  Failure f r
               -> Success a f r
               -> f r
    }

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

#if MIN_VERSION_base(4,13,0)
instance MonadFail Parser where
#endif

    fail :: String -> Parser a
fail String
msg = (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
-> Parser a
forall a.
(forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
-> Parser a
Parser ((forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
 -> Parser a)
-> (forall (f :: * -> *) r. Failure f r -> Success a f r -> f r)
-> Parser a
forall a b. (a -> b) -> a -> b
$ \Failure f r
kf Success a f r
_ks -> Failure f r
kf String
msg
    {-# INLINE fail #-}

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

instance Applicative Parser where
    pure :: a -> Parser a
pure  = a -> Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return
    {-# INLINE pure #-}
    <*> :: Parser (a -> b) -> Parser a -> Parser b
(<*>) = Parser (a -> b) -> Parser a -> Parser b
forall a b. Parser (a -> b) -> Parser a -> Parser b
apP
    {-# INLINE (<*>) #-}

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

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

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

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

-- | Run a 'Parser', returning either @'Left' errMsg@ or @'Right'
-- result@. Forces the value in the 'Left' or 'Right' constructors to
-- weak head normal form.
--
-- You most likely won't need to use this function directly, but it's
-- included for completeness.
runParser :: Parser a -> Either String a
runParser :: Parser a -> Either String a
runParser Parser a
p = Parser a
-> Failure (Either String) a
-> Success a (Either String) a
-> Either String a
forall a.
Parser a
-> forall (f :: * -> *) r. Failure f r -> Success a f r -> f r
unParser Parser a
p Failure (Either String) a
forall a b. a -> Either a b
left Success a (Either String) a
forall b a. b -> Either a b
right
  where
    left :: a -> Either a b
left !a
errMsg = a -> Either a b
forall a b. a -> Either a b
Left a
errMsg
    right :: b -> Either a b
right !b
x = b -> Either a b
forall a b. b -> Either a b
Right b
x
{-# INLINE runParser #-}

#ifdef GENERICS

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

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

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

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

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

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

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

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

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

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

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

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

#if MIN_VERSION_base(4,9,0)
data Proxy (s :: Meta) (f :: Type -> Type) a = Proxy
#else
data Proxy s (f :: * -> *) a = Proxy
#endif

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


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

instance GToRecord U1 f where
    gtoRecord :: U1 p -> [f]
gtoRecord U1 p
U1 = []

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

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

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

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

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

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

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

#endif