-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Auto-generate a command-line parser for your datatype
--
-- This library auto-generates an
-- optparse-applicative-compatible Parser from any data
-- type that derives the Generic interface.
--
-- See the documentation in Options.Generic for an example of how
-- to use this library
@package optparse-generic
@version 1.4.5
-- | This library auto-generates command-line parsers for data types using
-- Haskell's built-in support for generic programming. The best way to
-- understand how this library works is to walk through a few examples.
--
-- For example, suppose that you want to parse a record with named fields
-- like this:
--
--
-- -- Example.hs
--
-- {-# LANGUAGE DeriveGeneric #-}
-- {-# LANGUAGE OverloadedStrings #-}
--
-- import Options.Generic
--
-- data Example = Example { foo :: Int, bar :: Double }
-- deriving (Generic, Show)
--
-- instance ParseRecord Example
--
-- main = do
-- x <- getRecord "Test program"
-- print (x :: Example)
--
--
-- Named fields translate to flags which you can provide in any order:
--
--
-- $ stack build optparse-generic
-- $ stack runghc Example.hs -- --bar 2.5 --foo 1
-- Example {foo = 1, bar = 2.5}
--
--
-- This also auto-generates --help output:
--
--
-- $ stack runghc Example.hs -- --help
-- Test program
--
-- Usage: Example.hs --foo INT --bar DOUBLE
--
-- Available options:
-- -h,--help Show this help text
--
--
-- You can also add help descriptions to each field, like this:
--
--
-- {-# LANGUAGE DataKinds #-}
-- {-# LANGUAGE DeriveGeneric #-}
-- {-# LANGUAGE OverloadedStrings #-}
-- {-# LANGUAGE TypeOperators #-}
--
-- import Options.Generic
--
-- data Example = Example
-- { foo :: Int <?> "Documentation for the foo flag"
-- , bar :: Double <?> "Documentation for the bar flag"
-- } deriving (Generic, Show)
--
-- instance ParseRecord Example
--
-- main = do
-- x <- getRecord "Test program"
-- print (x :: Example)
--
--
-- ... which produces the following --help output:
--
--
-- $ stack runghc Example.hs -- --help
-- Test program
--
-- Usage: Example.hs --foo INT --bar DOUBLE
--
-- Available options:
-- -h,--help Show this help text
-- --foo INT Documentation for the foo flag
-- --bar DOUBLE Documentation for the bar flag
--
--
-- However, any fields you document will be wrapped in the Helpful
-- constructor:
--
--
-- $ stack runghc Example.hs -- --foo 1 --bar 2.5
-- Example {foo = Helpful {unHelpful = 1}, bar = Helpful {unHelpful = 2.5}}
--
--
-- To avoid this, while still being able to document your fields, you may
-- generalize the definition of your record with a parameter w,
-- and use unwrapRecord.
--
--
-- {-# LANGUAGE DataKinds #-}
-- {-# LANGUAGE DeriveGeneric #-}
-- {-# LANGUAGE FlexibleInstances #-} -- One more extension.
-- {-# LANGUAGE OverloadedStrings #-}
-- {-# LANGUAGE StandaloneDeriving #-} -- To derive Show
-- {-# LANGUAGE TypeOperators #-}
--
-- import Options.Generic
--
-- data Example w = Example
-- { foo :: w ::: Int <?> "Documentation for the foo flag"
-- , bar :: w ::: Double <?> "Documentation for the bar flag"
-- } deriving (Generic)
--
-- instance ParseRecord (Example Wrapped)
-- deriving instance Show (Example Unwrapped)
--
-- main = do
-- x <- unwrapRecord "Test program"
-- print (x :: Example Unwrapped)
--
--
-- Example Unwrapped is equivalent to a record type with simple
-- fields:
--
--
-- $ stack runghc Example.hs -- --foo 1 --bar 2.5
-- Example {foo = 1, bar = 2.5}
--
--
-- You can also add default values to each Readable field, like
-- this:
--
--
-- {-# LANGUAGE DataKinds #-}
-- {-# LANGUAGE DeriveGeneric #-}
-- {-# LANGUAGE OverloadedStrings #-}
-- {-# LANGUAGE TypeOperators #-}
--
-- import Options.Generic
--
-- data Example = Example
-- { foo :: Int <!> "1"
-- , bar :: String <!> "hello"
-- } deriving (Generic, Show)
--
-- instance ParseRecord Example
--
-- main = do
-- x <- getRecord "Test program"
-- print (x :: Example)
--
--
-- Default values will work alongside help descriptions and unwrapping.
--
-- For the following examples I encourage you to test what
-- --help output they generate.
--
-- This library will also do the right thing if the fields have no
-- labels:
--
--
-- data Example = Example Int Double deriving (Generic, Show)
--
--
-- Fields without labels translate into positional command-line
-- arguments:
--
--
-- $ stack runghc Example.hs -- 1 2.5
-- Example 1 2.5
--
--
-- Certain types of fields are given special treatment, such as in this
-- example:
--
--
-- data Example = Example
-- { switch :: Bool
-- , list :: [Int]
-- , optional :: Maybe Int
-- , first :: First Int
-- , last :: Last Int
-- , sum :: Sum Int
-- , product :: Product Int
-- } deriving (Generic, Show)
--
--
-- This gives the following behavior:
--
--
-- $ stack runghc Example.hs --
-- --switch
-- --optional 1
-- --list 1 --list 2
-- --first 1 --first 2
-- --last 1 --last 2
-- --sum 1 --sum 2
-- --product 1 --product 2
-- Example {switch = True, list = [1,2], optional = Just 1, first = First
-- {getFirst = Just 1}, last = Last {getLast = Just 2}, sum = Sum {getSum =
-- 3}, product = Product {getProduct = 2}}
--
-- $ stack runghc Example.hs
-- Example {switch = False, list = [], optional = Nothing, first = First
-- {getFirst = Nothing}, second = Last {getLast = Nothing}, sum = Sum {getSum
-- = 0}, product = Product {getProduct = 1}}
--
--
-- If a datatype has multiple constructors:
--
--
-- data Example
-- = Create { name :: Text, duration :: Maybe Int }
-- | Kill { name :: Text }
-- deriving (Generic, Show)
--
--
-- ... then they will translate into subcommands named after each
-- constructor:
--
--
-- $ stack runghc Example.hs -- create --name foo --duration=60
-- Create {name = "foo", duration = Just 60}
-- $ stack runghc Example.hs -- kill --name foo
-- Kill {name = "foo"}
--
--
-- This library also provides out-of-the-box support for many existing
-- types, like tuples and Either.
--
--
-- {-# LANGUAGE DeriveGeneric #-}
-- {-# LANGUAGE OverloadedStrings #-}
--
-- import Options.Generic
--
-- main = do
-- x <- getRecord "Test program"
-- print (x :: Either Double Int)
--
--
--
-- $ stack runghc Example.hs -- left 1.0
-- Left 1.0
-- $ stack runghc Example.hs -- right 2
-- Right 2
--
--
--
-- main = do
-- x <- getRecord "Test program"
-- print (x :: (Double, Int))
--
--
--
-- $ stack runghc Example.hs -- 1.0 2
-- (1.0,2)
--
--
-- ... and you can also just parse a single value:
--
--
-- main = do
-- x <- getRecord "Test program"
-- print (x :: Int)
--
--
--
-- $ stack runghc Example.hs -- 2
-- 2
--
--
-- However, there are some types that this library cannot generate
-- sensible command-line parsers for, such as:
--
--
-- - recursive types:
data Example = Example { foo :: Example
-- }
-- - records whose fields are other records
data Outer = Outer {
-- foo :: Inner } deriving (Show, Generic) data Inner = Inner { bar ::
-- Int } deriving (Show, Generic)
-- - record fields with nested Maybes or nested lists
data
-- Example = Example { foo :: Maybe (Maybe Int) } data Example = Example
-- { foo :: [[Int]] }
--
--
-- If you try to auto-generate a parser for these types you will get an
-- error at compile time that will look something like this:
--
--
-- No instance for (ParseFields TheTypeOfYourField)
-- arising from a use of ‘Options.Generic.$gdmparseRecord’
-- In the expression: Options.Generic.$gdmparseRecord
-- In an equation for ‘parseRecord’:
-- parseRecord = Options.Generic.$gdmparseRecord
-- In the instance declaration for ‘ParseRecord TheTypeOfYourRecord’
--
--
-- You can customize the library's default behavior using the
-- parseRecordWithModifiers utility, like this:
--
--
-- {-# LANGUAGE DeriveGeneric #-}
-- {-# LANGUAGE OverloadedStrings #-}
--
-- import Options.Generic
--
-- data Example = Example { foo :: Int, bar :: Double }
-- deriving (Generic, Show)
--
-- modifiers :: Modifiers
-- modifiers = defaultModifiers
-- { shortNameModifier = firstLetter
-- }
--
-- instance ParseRecord Example where
-- parseRecord = parseRecordWithModifiers modifiers
--
-- main = do
-- x <- getRecord "Test program"
-- print (x :: Example)
--
module Options.Generic
-- | Marshal any value that implements ParseRecord from the command
-- line
--
-- If you need to modify the top-level ParserInfo or
-- ParserPrefs use the getRecordWith function.
getRecord :: (MonadIO io, ParseRecord a) => Text -> io a
-- | Marshal any value that implements ParseRecord from the command
-- line
--
-- This is the lower-level sibling of 'getRecord and lets you modify the
-- ParserInfo and ParserPrefs records.
getRecordWith :: (MonadIO io, ParseRecord a) => InfoMod a -> PrefsMod -> io a
-- | Marshal any value that implements ParseRecord from the commmand
-- line alongside an io action that prints the help message.
getWithHelp :: (MonadIO io, ParseRecord a) => Text -> io (a, io ())
-- | Pure version of getRecord
--
-- If you need to modify the parser's ParserInfo or
-- ParserPrefs, use getRecordPureWith.
--
--
-- >>> :set -XOverloadedStrings
--
-- >>> getRecordPure ["1"] :: Maybe Int
-- Just 1
--
-- >>> getRecordPure ["1", "2"] :: Maybe [Int]
-- Just [1,2]
--
-- >>> getRecordPure ["Foo"] :: Maybe Int
-- Nothing
--
getRecordPure :: ParseRecord a => [Text] -> Maybe a
-- | Pure version of getRecordWith
--
-- Like getRecordWith, this is a sibling of 'getRecordPure and
-- exposes the monoidal modifier structures for ParserInfo and
-- ParserPrefs to you.
--
--
-- >>> :set -XOverloadedStrings
--
-- >>> getRecordPureWith ["1"] mempty mempty :: Maybe Int
-- Just 1
--
-- >>> getRecordPureWith ["1", "2"] mempty mempty :: Maybe [Int]
-- Just [1,2]
--
-- >>> getRecordPureWith ["Foo"] mempty mempty :: Maybe Int
-- Nothing
--
getRecordPureWith :: ParseRecord a => [Text] -> InfoMod a -> PrefsMod -> Maybe a
-- | Marshal any value that implements ParseRecord from the command
-- line and unwrap its fields
unwrapRecord :: (Functor io, MonadIO io, ParseRecord (f Wrapped), Unwrappable f) => Text -> io (f Unwrapped)
-- | Marshal any value that implements ParseRecord from the command
-- line and unwrap its fields alongside an io action to print the help
-- message
unwrapWithHelp :: (MonadIO io, ParseRecord (f Wrapped), Unwrappable f) => Text -> io (f Unwrapped, io ())
-- | Pure version of unwrapRecord
unwrapRecordPure :: (ParseRecord (f Wrapped), Unwrappable f) => [Text] -> Maybe (f Unwrapped)
-- | Unwrap the fields of a constructor
unwrap :: forall f. Unwrappable f => f Wrapped -> f Unwrapped
-- | A class for types that can be parsed from the command line
--
-- This class has a default implementation for any type that implements
-- Generic and you can derive Generic for many types by
-- enabling the DeriveGeneric language extension
--
-- You can also use getOnly to create a ParseRecord
-- instance from a ParseFields instance:
--
--
-- instance ParseRecord MyType where
-- parseRecord = fmap getOnly parseRecord
--
class ParseRecord a
parseRecord :: ParseRecord a => Parser a
parseRecord :: (ParseRecord a, Generic a, GenericParseRecord (Rep a)) => Parser a
-- | A class for all types that can be parsed from zero or more
-- arguments/options on the command line
--
-- parseFields has a default implementation for any type that
-- implements ParseField
class ParseRecord a => ParseFields a
parseFields :: ParseFields a => Maybe Text -> Maybe Text -> Maybe Char -> Maybe String -> Parser a
parseFields :: (ParseFields a, ParseField a) => Maybe Text -> Maybe Text -> Maybe Char -> Maybe String -> Parser a
-- | A class for all record fields that can be parsed from exactly one
-- option or argument on the command line
--
-- parseField has a default implementation for any type that
-- implements Read and Typeable. You can derive Read
-- for many types and you can derive Typeable for any type if you
-- enable the DeriveDataTypeable language extension
class ParseField a
parseField :: ParseField a => Maybe Text -> Maybe Text -> Maybe Char -> Maybe String -> Parser a
parseField :: (ParseField a, Read a) => Maybe Text -> Maybe Text -> Maybe Char -> Maybe String -> Parser a
-- | The only reason for this method is to provide a special case for
-- handling Strings. All other instances should just fall back on
-- the default implementation for parseListOfField
parseListOfField :: ParseField a => Maybe Text -> Maybe Text -> Maybe Char -> Maybe String -> Parser [a]
readField :: ParseField a => ReadM a
readField :: (ParseField a, Read a) => ReadM a
metavar :: ParseField a => proxy a -> String
metavar :: (ParseField a, Typeable a) => proxy a -> String
-- | The 1-tuple type or single-value "collection".
--
-- This type is structurally equivalent to the Identity type, but
-- its intent is more about serving as the anonymous 1-tuple type missing
-- from Haskell for attaching typeclass instances.
--
-- Parameter usage example:
--
--
-- encodeSomething (Only (42::Int))
--
--
-- Result usage example:
--
--
-- xs <- decodeSomething
-- forM_ xs $ \(Only id) -> {- ... -}
--
newtype Only a
Only :: a -> Only a
[fromOnly] :: Only a -> a
-- | This is a convenience function that you can use if you want to create
-- a ParseRecord instance that just defers to the
-- ParseFields instance for the same type:
--
--
-- instance ParseRecord MyType where
-- parseRecord = fmap getOnly parseRecord
--
getOnly :: Only a -> a
readIntegralBounded :: forall a. (Integral a, Bounded a, Typeable a, ParseField a) => ReadM a
-- | Options for customizing derived ParseRecord implementations for
-- Generic types
--
-- You can either create the Modifiers record directly:
--
--
-- modifiers :: Modifiers
-- modifiers = Modifiers
-- { fieldNameModifier = ...
-- , constructorNameModifier = ...
-- , shortNameModifier = ...
-- }
--
--
-- ... or you can tweak the defaultModifiers:
--
--
-- modifiers :: Modifiers
-- modifiers = defaultModifiers { fieldNameModifier = ... }
--
--
-- ... or you can use/tweak a predefined Modifier, like
-- lispCaseModifiers
--
-- The parseRecordWithModifiers function uses this
-- Modifiers record when generating a Generic
-- implementation of ParseRecord
data Modifiers
Modifiers :: (String -> String) -> (String -> String) -> (String -> Maybe Char) -> Modifiers
-- | Transform the name of derived fields (Default: id)
[fieldNameModifier] :: Modifiers -> String -> String
-- | Transform the name of derived constructors (Default: map
-- toLower)
[constructorNameModifier] :: Modifiers -> String -> String
-- | Derives an optional short name from the field name (Default: \_
-- -> Nothing)
[shortNameModifier] :: Modifiers -> String -> Maybe Char
-- | Use parseRecordWithModifiers when you want to tweak the
-- behavior of a derived ParseRecord implementation, like this:
--
--
-- myModifiers :: Modifiers
-- myModifiers = defaultModifiers { constructorNameModifier = id }
--
-- instance ParseRecord MyType where
-- parseRecord = parseRecordWithModifiers myModifiers
--
--
-- This will still require that you derive Generic for your type
-- to automate most of the implementation, but the Modifiers that
-- you pass will change how the implementation generates the command line
-- interface
parseRecordWithModifiers :: (Generic a, GenericParseRecord (Rep a)) => Modifiers -> Parser a
-- | These are the default modifiers used if you derive a Generic
-- implementation. You can customize this and pass the result to
-- parseRecordWithModifiers if you would like to modify the
-- derived implementation:
--
--
-- myModifiers :: Modifiers
-- myModifiers = defaultModifiers { constructorNameModifier = id }
--
-- instance ParseRecord MyType where
-- parseRecord = parseRecordWithModifiers myModifiers
--
defaultModifiers :: Modifiers
-- | Convert field and constructor names from CamelCase to
-- lisp-case.
--
-- Leading underscores are dropped, allowing one to use option names
-- which are Haskell keywords or otherwise conflicting identifiers.
--
--
-- BuildCommand -> build-command
-- someFlag -> --some-flag
-- _type -> --type
-- _splitAt -> --split-at
--
lispCaseModifiers :: Modifiers
-- | Use this for the shortNameModifier field of the
-- Modifiers record if you want to use the first letter of each
-- option as the short name
firstLetter :: String -> Maybe Char
class GenericParseRecord f
genericParseRecord :: GenericParseRecord f => Modifiers -> Parser (f p)
-- | Use this to annotate a field with a type-level string (i.e. a
-- Symbol) representing the help description for that field:
--
--
-- data Example = Example
-- { foo :: Int <?> "Documentation for the foo flag"
-- , bar :: Double <?> "Documentation for the bar flag"
-- } deriving (Generic, Show)
--
newtype () (field :: *) (help :: Symbol)
Helpful :: field -> () (field :: *) (help :: Symbol)
[unHelpful] :: () (field :: *) (help :: Symbol) -> field
-- | Use this to annotate a field with a type-level string (i.e. a
-- Symbol) representing the default value for that field:
--
--
-- data Example = Example
-- { foo :: Int <!> "1"
-- , bar :: Double <!> "0.5"
-- } deriving (Generic, Show)
--
newtype () (field :: *) (value :: Symbol)
DefValue :: field -> () (field :: *) (value :: Symbol)
[unDefValue] :: () (field :: *) (value :: Symbol) -> field
-- | Use this to annotate a field with a type-level char (i.e. a
-- Symbol) representing the short name of the field (only the
-- first character of the symbol is used):
--
--
-- data Example = Example
-- { foo :: Int <#> "f"
-- , bar :: Double <#> "b"
-- } deriving (Generic, Show)
--
newtype (<#>) (field :: *) (value :: Symbol)
ShortName :: field -> (<#>) (field :: *) (value :: Symbol)
[unShortName] :: (<#>) (field :: *) (value :: Symbol) -> field
-- | A type family to extract fields wrapped using (<?>)
type family (:::) wrap wrapped
infixr 0 :::
-- | Flag to keep fields wrapped
data Wrapped
-- | Flag to unwrap fields annotated using (<?>)
data Unwrapped
-- | Constraint for types whose fields can be unwrapped
type Unwrappable f = (Generic (f Wrapped), Generic (f Unwrapped), GenericUnwrappable (Rep (f Wrapped)) (Rep (f Unwrapped)))
-- | Representable types of kind *. This class is derivable in GHC
-- with the DeriveGeneric flag on.
--
-- A Generic instance must satisfy the following laws:
--
--
-- from . to ≡ id
-- to . from ≡ id
--
class Generic a
-- | A space efficient, packed, unboxed Unicode text type.
data Text
-- | Boolean monoid under conjunction (&&).
--
--
-- >>> getAll (All True <> mempty <> All False)
-- False
--
--
--
-- >>> getAll (mconcat (map (\x -> All (even x)) [2,4,6,7,8]))
-- False
--
newtype All
All :: Bool -> All
[getAll] :: All -> Bool
-- | Boolean monoid under disjunction (||).
--
--
-- >>> getAny (Any True <> mempty <> Any False)
-- True
--
--
--
-- >>> getAny (mconcat (map (\x -> Any (even x)) [2,4,6,7,8]))
-- True
--
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool
-- | Maybe monoid returning the leftmost non-Nothing value.
--
-- First a is isomorphic to Alt Maybe
-- a, but precedes it historically.
--
--
-- >>> getFirst (First (Just "hello") <> First Nothing <> First (Just "world"))
-- Just "hello"
--
--
-- Use of this type is discouraged. Note the following equivalence:
--
--
-- Data.Monoid.First x === Maybe (Data.Semigroup.First x)
--
--
-- In addition to being equivalent in the structural sense, the two also
-- have Monoid instances that behave the same. This type will be
-- marked deprecated in GHC 8.8, and removed in GHC 8.10. Users are
-- advised to use the variant from Data.Semigroup and wrap it in
-- Maybe.
newtype First a
First :: Maybe a -> First a
[getFirst] :: First a -> Maybe a
-- | Maybe monoid returning the rightmost non-Nothing value.
--
-- Last a is isomorphic to Dual (First
-- a), and thus to Dual (Alt Maybe a)
--
--
-- >>> getLast (Last (Just "hello") <> Last Nothing <> Last (Just "world"))
-- Just "world"
--
--
-- Use of this type is discouraged. Note the following equivalence:
--
--
-- Data.Monoid.Last x === Maybe (Data.Semigroup.Last x)
--
--
-- In addition to being equivalent in the structural sense, the two also
-- have Monoid instances that behave the same. This type will be
-- marked deprecated in GHC 8.8, and removed in GHC 8.10. Users are
-- advised to use the variant from Data.Semigroup and wrap it in
-- Maybe.
newtype Last a
Last :: Maybe a -> Last a
[getLast] :: Last a -> Maybe a
-- | Monoid under addition.
--
--
-- >>> getSum (Sum 1 <> Sum 2 <> mempty)
-- 3
--
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a
-- | Monoid under multiplication.
--
--
-- >>> getProduct (Product 3 <> Product 4 <> mempty)
-- 12
--
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a
instance GHC.Show.Show field => GHC.Show.Show (field Options.Generic. help)
instance GHC.Generics.Generic (field Options.Generic. help)
instance GHC.Show.Show field => GHC.Show.Show (field Options.Generic. value)
instance GHC.Generics.Generic (field Options.Generic. value)
instance GHC.Show.Show field => GHC.Show.Show (field Options.Generic.<#> value)
instance GHC.Generics.Generic (field Options.Generic.<#> value)
instance GHC.Show.Show a => GHC.Show.Show (Options.Generic.Only_ a)
instance GHC.Generics.Generic (Options.Generic.Only_ a)
instance Options.Generic.GenericUnwrappable GHC.Generics.U1 GHC.Generics.U1
instance Options.Generic.GenericUnwrappable f f' => Options.Generic.GenericUnwrappable (GHC.Generics.M1 i c f) (GHC.Generics.M1 i c f')
instance (Options.Generic.GenericUnwrappable f f', Options.Generic.GenericUnwrappable g g') => Options.Generic.GenericUnwrappable (f GHC.Generics.:+: g) (f' GHC.Generics.:+: g')
instance (Options.Generic.GenericUnwrappable f f', Options.Generic.GenericUnwrappable g g') => Options.Generic.GenericUnwrappable (f GHC.Generics.:*: g) (f' GHC.Generics.:*: g')
instance Options.Generic.GenericUnwrappable (GHC.Generics.K1 i c) (GHC.Generics.K1 i c)
instance Options.Generic.GenericUnwrappable (GHC.Generics.K1 i field) (GHC.Generics.K1 i c) => Options.Generic.GenericUnwrappable (GHC.Generics.K1 i (field Options.Generic. helper)) (GHC.Generics.K1 i c)
instance Options.Generic.GenericUnwrappable (GHC.Generics.K1 i field) (GHC.Generics.K1 i c) => Options.Generic.GenericUnwrappable (GHC.Generics.K1 i (field Options.Generic. defVal)) (GHC.Generics.K1 i c)
instance Options.Generic.GenericUnwrappable (GHC.Generics.K1 i field) (GHC.Generics.K1 i c) => Options.Generic.GenericUnwrappable (GHC.Generics.K1 i (field Options.Generic.<#> defVal)) (GHC.Generics.K1 i c)
instance Options.Generic.ParseFields GHC.Types.Char
instance Options.Generic.ParseFields GHC.Types.Double
instance Options.Generic.ParseFields GHC.Types.Float
instance Options.Generic.ParseFields GHC.Types.Int
instance Options.Generic.ParseFields GHC.Int.Int8
instance Options.Generic.ParseFields GHC.Int.Int16
instance Options.Generic.ParseFields GHC.Int.Int32
instance Options.Generic.ParseFields GHC.Int.Int64
instance Options.Generic.ParseFields GHC.Integer.Type.Integer
instance Options.Generic.ParseFields GHC.Types.Ordering
instance Options.Generic.ParseFields Data.Void.Void
instance Options.Generic.ParseFields GHC.Word.Word8
instance Options.Generic.ParseFields GHC.Word.Word16
instance Options.Generic.ParseFields GHC.Word.Word32
instance Options.Generic.ParseFields GHC.Word.Word64
instance Options.Generic.ParseFields Data.ByteString.Internal.ByteString
instance Options.Generic.ParseFields Data.ByteString.Lazy.Internal.ByteString
instance Options.Generic.ParseFields Data.Text.Internal.Text
instance Options.Generic.ParseFields Data.Text.Internal.Lazy.Text
instance Options.Generic.ParseFields Filesystem.Path.Internal.FilePath
instance Options.Generic.ParseFields Data.Time.Calendar.Days.Day
instance Options.Generic.ParseFields GHC.Natural.Natural
instance Options.Generic.ParseFields GHC.Types.Bool
instance Options.Generic.ParseFields ()
instance Options.Generic.ParseFields Data.Semigroup.Internal.Any
instance Options.Generic.ParseFields Data.Semigroup.Internal.All
instance Options.Generic.ParseField a => Options.Generic.ParseFields (GHC.Maybe.Maybe a)
instance Options.Generic.ParseField a => Options.Generic.ParseFields (Data.Monoid.First a)
instance Options.Generic.ParseField a => Options.Generic.ParseFields (Data.Monoid.Last a)
instance (GHC.Num.Num a, Options.Generic.ParseField a) => Options.Generic.ParseFields (Data.Semigroup.Internal.Sum a)
instance (GHC.Num.Num a, Options.Generic.ParseField a) => Options.Generic.ParseFields (Data.Semigroup.Internal.Product a)
instance Options.Generic.ParseField a => Options.Generic.ParseFields [a]
instance Options.Generic.ParseField a => Options.Generic.ParseFields (GHC.Base.NonEmpty a)
instance (Options.Generic.ParseFields a, GHC.TypeLits.KnownSymbol h) => Options.Generic.ParseFields (a Options.Generic. h)
instance (Options.Generic.ParseFields a, GHC.TypeLits.KnownSymbol h) => Options.Generic.ParseRecord (a Options.Generic. h)
instance (Options.Generic.ParseFields a, GHC.TypeLits.KnownSymbol d) => Options.Generic.ParseFields (a Options.Generic. d)
instance (Options.Generic.ParseFields a, GHC.TypeLits.KnownSymbol h) => Options.Generic.ParseRecord (a Options.Generic. h)
instance (Options.Generic.ParseFields a, GHC.TypeLits.KnownSymbol c) => Options.Generic.ParseFields (a Options.Generic.<#> c)
instance (Options.Generic.ParseFields a, GHC.TypeLits.KnownSymbol h) => Options.Generic.ParseRecord (a Options.Generic.<#> h)
instance Options.Generic.ParseFields a => Options.Generic.ParseRecord (Options.Generic.Only_ a)
instance Options.Generic.ParseFields a => Options.Generic.ParseRecord (Data.Tuple.Only.Only a)
instance (Options.Generic.ParseFields a, Options.Generic.ParseFields b) => Options.Generic.ParseRecord (a, b)
instance (Options.Generic.ParseFields a, Options.Generic.ParseFields b, Options.Generic.ParseFields c) => Options.Generic.ParseRecord (a, b, c)
instance (Options.Generic.ParseFields a, Options.Generic.ParseFields b, Options.Generic.ParseFields c, Options.Generic.ParseFields d) => Options.Generic.ParseRecord (a, b, c, d)
instance (Options.Generic.ParseFields a, Options.Generic.ParseFields b, Options.Generic.ParseFields c, Options.Generic.ParseFields d, Options.Generic.ParseFields e) => Options.Generic.ParseRecord (a, b, c, d, e)
instance (Options.Generic.ParseFields a, Options.Generic.ParseFields b, Options.Generic.ParseFields c, Options.Generic.ParseFields d, Options.Generic.ParseFields e, Options.Generic.ParseFields f) => Options.Generic.ParseRecord (a, b, c, d, e, f)
instance (Options.Generic.ParseFields a, Options.Generic.ParseFields b, Options.Generic.ParseFields c, Options.Generic.ParseFields d, Options.Generic.ParseFields e, Options.Generic.ParseFields f, Options.Generic.ParseFields g) => Options.Generic.ParseRecord (a, b, c, d, e, f, g)
instance (Options.Generic.ParseFields a, Options.Generic.ParseFields b) => Options.Generic.ParseRecord (Data.Either.Either a b)
instance (GHC.Generics.Selector s, Options.Generic.ParseFields a) => Options.Generic.GenericParseRecord (GHC.Generics.M1 GHC.Generics.S s (GHC.Generics.K1 i a))
instance Options.Generic.ParseRecord GHC.Types.Char
instance Options.Generic.ParseRecord GHC.Types.Double
instance Options.Generic.ParseRecord GHC.Types.Float
instance Options.Generic.ParseRecord GHC.Types.Int
instance Options.Generic.ParseRecord GHC.Int.Int8
instance Options.Generic.ParseRecord GHC.Int.Int16
instance Options.Generic.ParseRecord GHC.Int.Int32
instance Options.Generic.ParseRecord GHC.Int.Int64
instance Options.Generic.ParseRecord GHC.Types.Ordering
instance Options.Generic.ParseRecord Data.Void.Void
instance Options.Generic.ParseRecord GHC.Word.Word8
instance Options.Generic.ParseRecord GHC.Word.Word16
instance Options.Generic.ParseRecord GHC.Word.Word32
instance Options.Generic.ParseRecord GHC.Word.Word64
instance Options.Generic.ParseRecord ()
instance Options.Generic.ParseRecord GHC.Natural.Natural
instance Options.Generic.ParseRecord GHC.Types.Bool
instance Options.Generic.ParseRecord GHC.Integer.Type.Integer
instance Options.Generic.ParseRecord Data.Text.Internal.Text
instance Options.Generic.ParseRecord Data.Text.Internal.Lazy.Text
instance Options.Generic.ParseRecord Data.Semigroup.Internal.Any
instance Options.Generic.ParseRecord Data.Semigroup.Internal.All
instance Options.Generic.ParseRecord Filesystem.Path.Internal.FilePath
instance Options.Generic.ParseRecord Data.ByteString.Internal.ByteString
instance Options.Generic.ParseRecord Data.ByteString.Lazy.Internal.ByteString
instance Options.Generic.ParseRecord Data.Time.Calendar.Days.Day
instance Options.Generic.ParseField a => Options.Generic.ParseRecord (GHC.Maybe.Maybe a)
instance Options.Generic.ParseField a => Options.Generic.ParseRecord (Data.Monoid.First a)
instance Options.Generic.ParseField a => Options.Generic.ParseRecord (Data.Monoid.Last a)
instance (GHC.Num.Num a, Options.Generic.ParseField a) => Options.Generic.ParseRecord (Data.Semigroup.Internal.Sum a)
instance (GHC.Num.Num a, Options.Generic.ParseField a) => Options.Generic.ParseRecord (Data.Semigroup.Internal.Product a)
instance Options.Generic.ParseField a => Options.Generic.ParseRecord [a]
instance Options.Generic.ParseField a => Options.Generic.ParseRecord (GHC.Base.NonEmpty a)
instance Options.Generic.GenericParseRecord GHC.Generics.U1
instance Options.Generic.GenericParseRecord f => Options.Generic.GenericParseRecord (GHC.Generics.M1 GHC.Generics.C c f)
instance (Options.Generic.GenericParseRecord (f GHC.Generics.:+: g), Options.Generic.GenericParseRecord (h GHC.Generics.:+: i)) => Options.Generic.GenericParseRecord ((f GHC.Generics.:+: g) GHC.Generics.:+: (h GHC.Generics.:+: i))
instance (GHC.Generics.Constructor c, Options.Generic.GenericParseRecord f, Options.Generic.GenericParseRecord (g GHC.Generics.:+: h)) => Options.Generic.GenericParseRecord (GHC.Generics.M1 GHC.Generics.C c f GHC.Generics.:+: (g GHC.Generics.:+: h))
instance (GHC.Generics.Constructor c, Options.Generic.GenericParseRecord (f GHC.Generics.:+: g), Options.Generic.GenericParseRecord h) => Options.Generic.GenericParseRecord ((f GHC.Generics.:+: g) GHC.Generics.:+: GHC.Generics.M1 GHC.Generics.C c h)
instance (GHC.Generics.Constructor c1, GHC.Generics.Constructor c2, Options.Generic.GenericParseRecord f1, Options.Generic.GenericParseRecord f2) => Options.Generic.GenericParseRecord (GHC.Generics.M1 GHC.Generics.C c1 f1 GHC.Generics.:+: GHC.Generics.M1 GHC.Generics.C c2 f2)
instance (Options.Generic.GenericParseRecord f, Options.Generic.GenericParseRecord g) => Options.Generic.GenericParseRecord (f GHC.Generics.:*: g)
instance Options.Generic.GenericParseRecord GHC.Generics.V1
instance Options.Generic.GenericParseRecord f => Options.Generic.GenericParseRecord (GHC.Generics.M1 GHC.Generics.D c f)
instance (Options.Generic.ParseField a, GHC.TypeLits.KnownSymbol c) => Options.Generic.ParseField (a Options.Generic.<#> c)
instance (Options.Generic.ParseField a, GHC.TypeLits.KnownSymbol d) => Options.Generic.ParseField (a Options.Generic. d)
instance (Options.Generic.ParseField a, GHC.TypeLits.KnownSymbol h) => Options.Generic.ParseField (a Options.Generic. h)
instance Options.Generic.ParseField GHC.Types.Bool
instance Options.Generic.ParseField GHC.Types.Double
instance Options.Generic.ParseField GHC.Types.Float
instance Options.Generic.ParseField GHC.Integer.Type.Integer
instance Options.Generic.ParseField GHC.Types.Ordering
instance Options.Generic.ParseField ()
instance Options.Generic.ParseField Data.Void.Void
instance Options.Generic.ParseField GHC.Types.Int
instance Options.Generic.ParseField GHC.Int.Int8
instance Options.Generic.ParseField GHC.Int.Int16
instance Options.Generic.ParseField GHC.Int.Int32
instance Options.Generic.ParseField GHC.Int.Int64
instance Options.Generic.ParseField GHC.Word.Word8
instance Options.Generic.ParseField GHC.Word.Word16
instance Options.Generic.ParseField GHC.Word.Word32
instance Options.Generic.ParseField GHC.Word.Word64
instance Options.Generic.ParseField GHC.Natural.Natural
instance Options.Generic.ParseField GHC.Base.String
instance Options.Generic.ParseField GHC.Types.Char
instance Options.Generic.ParseField Data.Semigroup.Internal.Any
instance Options.Generic.ParseField Data.Semigroup.Internal.All
instance Options.Generic.ParseField Data.Text.Internal.Text
instance Options.Generic.ParseField Data.ByteString.Internal.ByteString
instance Options.Generic.ParseField Data.Text.Internal.Lazy.Text
instance Options.Generic.ParseField Data.ByteString.Lazy.Internal.ByteString
instance Options.Generic.ParseField Filesystem.Path.Internal.FilePath
instance Options.Generic.ParseField Data.Time.Calendar.Days.Day