| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Options.Generic
Contents
Description
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 listsdata 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)Synopsis
- getRecord :: (MonadIO io, ParseRecord a) => Text -> io a
- getRecordWith :: (MonadIO io, ParseRecord a) => InfoMod a -> PrefsMod -> io a
- getWithHelp :: (MonadIO io, ParseRecord a) => Text -> io (a, io ())
- getRecordPure :: ParseRecord a => [Text] -> Maybe a
- getRecordPureWith :: ParseRecord a => [Text] -> InfoMod a -> PrefsMod -> Maybe a
- unwrapRecord :: (Functor io, MonadIO io, ParseRecord (f Wrapped), Unwrappable f) => Text -> io (f Unwrapped)
- unwrapWithHelp :: (MonadIO io, ParseRecord (f Wrapped), Unwrappable f) => Text -> io (f Unwrapped, io ())
- unwrapRecordPure :: (ParseRecord (f Wrapped), Unwrappable f) => [Text] -> Maybe (f Unwrapped)
- unwrap :: forall f. Unwrappable f => f Wrapped -> f Unwrapped
- class ParseRecord a where
- parseRecord :: Parser a
- class ParseRecord a => ParseFields a where
- class ParseField a where
- newtype Only a = Only {
- fromOnly :: a
- getOnly :: Only a -> a
- readIntegralBounded :: forall a. (Integral a, Bounded a, Typeable a, ParseField a) => ReadM a
- data Modifiers = Modifiers {
- fieldNameModifier :: String -> String
- constructorNameModifier :: String -> String
- shortNameModifier :: String -> Maybe Char
- parseRecordWithModifiers :: (Generic a, GenericParseRecord (Rep a)) => Modifiers -> Parser a
- defaultModifiers :: Modifiers
- lispCaseModifiers :: Modifiers
- firstLetter :: String -> Maybe Char
- class GenericParseRecord f where
- genericParseRecord :: Modifiers -> Parser (f p)
- newtype (field :: *) <?> (help :: Symbol) = Helpful {
- unHelpful :: field
- newtype (field :: *) <!> (value :: Symbol) = DefValue {
- unDefValue :: field
- newtype (field :: *) <#> (value :: Symbol) = ShortName {
- unShortName :: field
- type family wrap ::: wrapped
- data Wrapped
- data Unwrapped
- type Unwrappable f = (Generic (f Wrapped), Generic (f Unwrapped), GenericUnwrappable (Rep (f Wrapped)) (Rep (f Unwrapped)))
- class Generic a
- data Text
- newtype All = All {}
- newtype Any = Any {}
- newtype First a = First {}
- newtype Last a = Last {}
- newtype Sum a = Sum {
- getSum :: a
- newtype Product a = Product {
- getProduct :: a
Parsers
Arguments
| :: (MonadIO io, ParseRecord a) | |
| => Text | Program description |
| -> io a |
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.
Arguments
| :: (MonadIO io, ParseRecord a) | |
| => InfoMod a |
|
| -> PrefsMod |
|
| -> 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.
Arguments
| :: (MonadIO io, ParseRecord a) | |
| => Text | Program description |
| -> io (a, io ()) | (options, io action to print help message) |
Marshal any value that implements ParseRecord from the commmand line alongside an io action that prints the help message.
Arguments
| :: ParseRecord a | |
| => [Text] | Command-line arguments |
| -> Maybe a |
Pure version of getRecord
If you need to modify the parser's ParserInfo or ParserPrefs, use getRecordPureWith.
>>>:set -XOverloadedStrings>>>getRecordPure ["1"] :: Maybe IntJust 1>>>getRecordPure ["1", "2"] :: Maybe [Int]Just [1,2]>>>getRecordPure ["Foo"] :: Maybe IntNothing
Arguments
| :: ParseRecord a | |
| => [Text] | Command-line arguments |
| -> InfoMod a |
|
| -> PrefsMod |
|
| -> 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 IntJust 1>>>getRecordPureWith ["1", "2"] mempty mempty :: Maybe [Int]Just [1,2]>>>getRecordPureWith ["Foo"] mempty mempty :: Maybe IntNothing
unwrapRecord :: (Functor io, MonadIO io, ParseRecord (f Wrapped), Unwrappable f) => Text -> io (f Unwrapped) Source #
Marshal any value that implements ParseRecord from the command line and unwrap its fields
Arguments
| :: (MonadIO io, ParseRecord (f Wrapped), Unwrappable f) | |
| => Text | Program description |
| -> io (f Unwrapped, io ()) | (options, io action to print help message) |
Marshal any value that implements ParseRecord from the command line and unwrap its fields alongside an io action to print the help message
Arguments
| :: (ParseRecord (f Wrapped), Unwrappable f) | |
| => [Text] | Command-line arguments |
| -> Maybe (f Unwrapped) |
Pure version of unwrapRecord
unwrap :: forall f. Unwrappable f => f Wrapped -> f Unwrapped Source #
Unwrap the fields of a constructor
class ParseRecord a where Source #
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
Minimal complete definition
Nothing
Methods
parseRecord :: Parser a Source #
default parseRecord :: (Generic a, GenericParseRecord (Rep a)) => Parser a Source #
Instances
class ParseRecord a => ParseFields a where Source #
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
Minimal complete definition
Nothing
Methods
Instances
class ParseField a where Source #
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
Minimal complete definition
Nothing
Methods
Arguments
| :: Maybe Text | Help message |
| -> Maybe Text | Field label |
| -> Maybe Char | Short name |
| -> Maybe String | Default value |
| -> Parser a |
default parseField :: Read a => Maybe Text -> Maybe Text -> Maybe Char -> Maybe String -> Parser a Source #
Arguments
| :: Maybe Text | Help message |
| -> Maybe Text | Field label |
| -> Maybe Char | Short name |
| -> Maybe String | Default value |
| -> 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
Instances
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) -> {- ... -}Instances
| Functor Only | |
| Eq a => Eq (Only a) | |
| Data a => Data (Only a) | |
Defined in Data.Tuple.Only Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Only a -> c (Only a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Only a) # toConstr :: Only a -> Constr # dataTypeOf :: Only a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Only a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Only a)) # gmapT :: (forall b. Data b => b -> b) -> Only a -> Only a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Only a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Only a -> r # gmapQ :: (forall d. Data d => d -> u) -> Only a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Only a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Only a -> m (Only a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Only a -> m (Only a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Only a -> m (Only a) # | |
| Ord a => Ord (Only a) | |
| Read a => Read (Only a) | |
| Show a => Show (Only a) | |
| Generic (Only a) | |
| NFData a => NFData (Only a) | |
Defined in Data.Tuple.Only | |
| ParseFields a => ParseRecord (Only a) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (Only a) Source # | |
| type Rep (Only a) | |
Defined in Data.Tuple.Only | |
getOnly :: Only a -> a Source #
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
readIntegralBounded :: forall a. (Integral a, Bounded a, Typeable a, ParseField a) => ReadM a Source #
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
Constructors
| Modifiers | |
Fields
| |
parseRecordWithModifiers :: (Generic a, GenericParseRecord (Rep a)) => Modifiers -> Parser a Source #
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 myModifiersThis 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
defaultModifiers :: Modifiers Source #
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 myModifierslispCaseModifiers :: Modifiers Source #
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
firstLetter :: String -> Maybe Char Source #
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
class GenericParseRecord f where Source #
Methods
genericParseRecord :: Modifiers -> Parser (f p) Source #
Instances
Help
newtype (field :: *) <?> (help :: Symbol) Source #
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)Instances
| Show field => Show (field <?> help) Source # | |
| Generic (field <?> help) Source # | |
| (ParseFields a, KnownSymbol h) => ParseRecord (a <?> h) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (a <?> h) Source # | |
| (ParseFields a, KnownSymbol h) => ParseFields (a <?> h) Source # | |
| (ParseField a, KnownSymbol h) => ParseField (a <?> h) Source # | |
Defined in Options.Generic | |
| type Rep (field <?> help) Source # | |
Defined in Options.Generic | |
newtype (field :: *) <!> (value :: Symbol) Source #
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)Constructors
| DefValue | |
Fields
| |
Instances
| Show field => Show (field <!> value) Source # | |
| Generic (field <!> value) Source # | |
| (ParseFields a, KnownSymbol h) => ParseRecord (a <!> h) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (a <!> h) Source # | |
| (ParseFields a, KnownSymbol d) => ParseFields (a <!> d) Source # | |
| (ParseField a, KnownSymbol d) => ParseField (a <!> d) Source # | |
Defined in Options.Generic | |
| type Rep (field <!> value) Source # | |
Defined in Options.Generic | |
newtype (field :: *) <#> (value :: Symbol) Source #
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)Constructors
| ShortName | |
Fields
| |
Instances
| Show field => Show (field <#> value) Source # | |
| Generic (field <#> value) Source # | |
| (ParseFields a, KnownSymbol h) => ParseRecord (a <#> h) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (a <#> h) Source # | |
| (ParseFields a, KnownSymbol c) => ParseFields (a <#> c) Source # | |
| (ParseField a, KnownSymbol c) => ParseField (a <#> c) Source # | |
Defined in Options.Generic | |
| type Rep (field <#> value) Source # | |
Defined in Options.Generic | |
Flag to keep fields wrapped
Flag to unwrap fields annotated using (<?>)
type Unwrappable f = (Generic (f Wrapped), Generic (f Unwrapped), GenericUnwrappable (Rep (f Wrapped)) (Rep (f Unwrapped))) Source #
Constraint for types whose fields can be unwrapped
Re-exports
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≡idto.from≡id
Instances
| Generic Bool | Since: base-4.6.0.0 |
| Generic Ordering | Since: base-4.6.0.0 |
| Generic () | Since: base-4.6.0.0 |
| Generic Void | Since: base-4.8.0.0 |
| Generic Version | Since: base-4.9.0.0 |
| Generic ExitCode | |
| Generic All | Since: base-4.7.0.0 |
| Generic Any | Since: base-4.7.0.0 |
| Generic Fixity | Since: base-4.7.0.0 |
| Generic Associativity | Since: base-4.7.0.0 |
Defined in GHC.Generics Associated Types type Rep Associativity :: Type -> Type # | |
| Generic SourceUnpackedness | Since: base-4.9.0.0 |
Defined in GHC.Generics Associated Types type Rep SourceUnpackedness :: Type -> Type # Methods from :: SourceUnpackedness -> Rep SourceUnpackedness x # to :: Rep SourceUnpackedness x -> SourceUnpackedness # | |
| Generic SourceStrictness | Since: base-4.9.0.0 |
Defined in GHC.Generics Associated Types type Rep SourceStrictness :: Type -> Type # Methods from :: SourceStrictness -> Rep SourceStrictness x # to :: Rep SourceStrictness x -> SourceStrictness # | |
| Generic DecidedStrictness | Since: base-4.9.0.0 |
Defined in GHC.Generics Associated Types type Rep DecidedStrictness :: Type -> Type # Methods from :: DecidedStrictness -> Rep DecidedStrictness x # to :: Rep DecidedStrictness x -> DecidedStrictness # | |
| Generic [a] | Since: base-4.6.0.0 |
| Generic (Maybe a) | Since: base-4.6.0.0 |
| Generic (Par1 p) | Since: base-4.7.0.0 |
| Generic (Only a) | |
| Generic (Complex a) | Since: base-4.9.0.0 |
| Generic (Min a) | Since: base-4.9.0.0 |
| Generic (Max a) | Since: base-4.9.0.0 |
| Generic (First a) | Since: base-4.9.0.0 |
| Generic (Last a) | Since: base-4.9.0.0 |
| Generic (WrappedMonoid m) | Since: base-4.9.0.0 |
Defined in Data.Semigroup Associated Types type Rep (WrappedMonoid m) :: Type -> Type # Methods from :: WrappedMonoid m -> Rep (WrappedMonoid m) x # to :: Rep (WrappedMonoid m) x -> WrappedMonoid m # | |
| Generic (Option a) | Since: base-4.9.0.0 |
| Generic (ZipList a) | Since: base-4.7.0.0 |
| Generic (Identity a) | Since: base-4.8.0.0 |
| Generic (First a) | Since: base-4.7.0.0 |
| Generic (Last a) | Since: base-4.7.0.0 |
| Generic (Dual a) | Since: base-4.7.0.0 |
| Generic (Endo a) | Since: base-4.7.0.0 |
| Generic (Sum a) | Since: base-4.7.0.0 |
| Generic (Product a) | Since: base-4.7.0.0 |
| Generic (Down a) | Since: base-4.12.0.0 |
| Generic (NonEmpty a) | Since: base-4.6.0.0 |
| Generic (Tree a) | Since: containers-0.5.8 |
| Generic (FingerTree a) | Since: containers-0.6.1 |
Defined in Data.Sequence.Internal Associated Types type Rep (FingerTree a) :: Type -> Type # | |
| Generic (Digit a) | Since: containers-0.6.1 |
| Generic (Node a) | Since: containers-0.6.1 |
| Generic (Elem a) | Since: containers-0.6.1 |
| Generic (ViewL a) | Since: containers-0.5.8 |
| Generic (ViewR a) | Since: containers-0.5.8 |
| Generic (Either a b) | Since: base-4.6.0.0 |
| Generic (V1 p) | Since: base-4.9.0.0 |
| Generic (U1 p) | Since: base-4.7.0.0 |
| Generic (a, b) | Since: base-4.6.0.0 |
| Generic (Arg a b) | Since: base-4.9.0.0 |
| Generic (WrappedMonad m a) | Since: base-4.7.0.0 |
Defined in Control.Applicative Associated Types type Rep (WrappedMonad m a) :: Type -> Type # Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x # to :: Rep (WrappedMonad m a) x -> WrappedMonad m a # | |
| Generic (Proxy t) | Since: base-4.6.0.0 |
| Generic (field <#> value) Source # | |
| Generic (field <!> value) Source # | |
| Generic (field <?> help) Source # | |
| Generic (Rec1 f p) | Since: base-4.7.0.0 |
| Generic (URec (Ptr ()) p) | Since: base-4.9.0.0 |
| Generic (URec Char p) | Since: base-4.9.0.0 |
| Generic (URec Double p) | Since: base-4.9.0.0 |
| Generic (URec Float p) | |
| Generic (URec Int p) | Since: base-4.9.0.0 |
| Generic (URec Word p) | Since: base-4.9.0.0 |
| Generic (a, b, c) | Since: base-4.6.0.0 |
| Generic (WrappedArrow a b c) | Since: base-4.7.0.0 |
Defined in Control.Applicative Associated Types type Rep (WrappedArrow a b c) :: Type -> Type # Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x # to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c # | |
| Generic (Kleisli m a b) | Since: base-4.14.0.0 |
| Generic (Const a b) | Since: base-4.9.0.0 |
| Generic (Ap f a) | Since: base-4.12.0.0 |
| Generic (Alt f a) | Since: base-4.8.0.0 |
| Generic (K1 i c p) | Since: base-4.7.0.0 |
| Generic ((f :+: g) p) | Since: base-4.7.0.0 |
| Generic ((f :*: g) p) | Since: base-4.7.0.0 |
| Generic (a, b, c, d) | Since: base-4.6.0.0 |
| Generic (Product f g a) | Since: base-4.9.0.0 |
| Generic (Sum f g a) | Since: base-4.9.0.0 |
| Generic (M1 i c f p) | Since: base-4.7.0.0 |
| Generic ((f :.: g) p) | Since: base-4.7.0.0 |
| Generic (a, b, c, d, e) | Since: base-4.6.0.0 |
| Generic (Compose f g a) | Since: base-4.9.0.0 |
| Generic (a, b, c, d, e, f) | Since: base-4.6.0.0 |
| Generic (a, b, c, d, e, f, g) | Since: base-4.6.0.0 |
A space efficient, packed, unboxed Unicode text type.
Instances
| ParseRecord Text Source # | |
Defined in Options.Generic Methods parseRecord :: Parser Text Source # | |
| ParseFields Text Source # | |
| ParseField Text Source # | |
| type Item 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
Instances
| Bounded All | Since: base-2.1 |
| Eq All | Since: base-2.1 |
| Ord All | Since: base-2.1 |
| Read All | Since: base-2.1 |
| Show All | Since: base-2.1 |
| Generic All | Since: base-4.7.0.0 |
| Semigroup All | Since: base-4.9.0.0 |
| Monoid All | Since: base-2.1 |
| ParseRecord All Source # | |
Defined in Options.Generic Methods parseRecord :: Parser All Source # | |
| ParseFields All Source # | |
| ParseField All Source # | |
| type Rep All | |
Defined in Data.Semigroup.Internal | |
Boolean monoid under disjunction (||).
>>>getAny (Any True <> mempty <> Any False)True
>>>getAny (mconcat (map (\x -> Any (even x)) [2,4,6,7,8]))True
Instances
| Bounded Any | Since: base-2.1 |
| Eq Any | Since: base-2.1 |
| Ord Any | Since: base-2.1 |
| Read Any | Since: base-2.1 |
| Show Any | Since: base-2.1 |
| Generic Any | Since: base-4.7.0.0 |
| Semigroup Any | Since: base-4.9.0.0 |
| Monoid Any | Since: base-2.1 |
| ParseRecord Any Source # | |
Defined in Options.Generic Methods parseRecord :: Parser Any Source # | |
| ParseFields Any Source # | |
| ParseField Any Source # | |
| type Rep Any | |
Defined in Data.Semigroup.Internal | |
Maybe monoid returning the leftmost non-Nothing value.
First aAlt Maybe a
>>>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.
Instances
| Monad First | Since: base-4.8.0.0 |
| Functor First | Since: base-4.8.0.0 |
| Applicative First | Since: base-4.8.0.0 |
| Foldable First | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m # foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m # foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b # foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b # foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # minimum :: Ord a => First a -> a # | |
| Traversable First | Since: base-4.8.0.0 |
| Eq a => Eq (First a) | Since: base-2.1 |
| Ord a => Ord (First a) | Since: base-2.1 |
| Read a => Read (First a) | Since: base-2.1 |
| Show a => Show (First a) | Since: base-2.1 |
| Generic (First a) | Since: base-4.7.0.0 |
| Semigroup (First a) | Since: base-4.9.0.0 |
| Monoid (First a) | Since: base-2.1 |
| ParseField a => ParseRecord (First a) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (First a) Source # | |
| ParseField a => ParseFields (First a) Source # | |
| Generic1 First | Since: base-4.7.0.0 |
| type Rep (First a) | |
Defined in Data.Monoid | |
| type Rep1 First | |
Defined in Data.Monoid | |
Maybe monoid returning the rightmost non-Nothing value.
Last aDual (First a)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.
Instances
| Monad Last | Since: base-4.8.0.0 |
| Functor Last | Since: base-4.8.0.0 |
| Applicative Last | Since: base-4.8.0.0 |
| Foldable Last | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m # foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m # foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b # foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b # foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
| Traversable Last | Since: base-4.8.0.0 |
| Eq a => Eq (Last a) | Since: base-2.1 |
| Ord a => Ord (Last a) | Since: base-2.1 |
| Read a => Read (Last a) | Since: base-2.1 |
| Show a => Show (Last a) | Since: base-2.1 |
| Generic (Last a) | Since: base-4.7.0.0 |
| Semigroup (Last a) | Since: base-4.9.0.0 |
| Monoid (Last a) | Since: base-2.1 |
| ParseField a => ParseRecord (Last a) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (Last a) Source # | |
| ParseField a => ParseFields (Last a) Source # | |
| Generic1 Last | Since: base-4.7.0.0 |
| type Rep (Last a) | |
Defined in Data.Monoid | |
| type Rep1 Last | |
Defined in Data.Monoid | |
Monoid under addition.
>>>getSum (Sum 1 <> Sum 2 <> mempty)3
Instances
| Monad Sum | Since: base-4.8.0.0 |
| Functor Sum | Since: base-4.8.0.0 |
| Applicative Sum | Since: base-4.8.0.0 |
| Foldable Sum | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m # foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m # foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b # foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b # foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
| Traversable Sum | Since: base-4.8.0.0 |
| Bounded a => Bounded (Sum a) | Since: base-2.1 |
| Eq a => Eq (Sum a) | Since: base-2.1 |
| Num a => Num (Sum a) | Since: base-4.7.0.0 |
| Ord a => Ord (Sum a) | Since: base-2.1 |
| Read a => Read (Sum a) | Since: base-2.1 |
| Show a => Show (Sum a) | Since: base-2.1 |
| Generic (Sum a) | Since: base-4.7.0.0 |
| Num a => Semigroup (Sum a) | Since: base-4.9.0.0 |
| Num a => Monoid (Sum a) | Since: base-2.1 |
| (Num a, ParseField a) => ParseRecord (Sum a) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (Sum a) Source # | |
| (Num a, ParseField a) => ParseFields (Sum a) Source # | |
| Generic1 Sum | Since: base-4.7.0.0 |
| type Rep (Sum a) | |
Defined in Data.Semigroup.Internal | |
| type Rep1 Sum | |
Defined in Data.Semigroup.Internal | |
Monoid under multiplication.
>>>getProduct (Product 3 <> Product 4 <> mempty)12
Constructors
| Product | |
Fields
| |
Instances
| Monad Product | Since: base-4.8.0.0 |
| Functor Product | Since: base-4.8.0.0 |
| Applicative Product | Since: base-4.8.0.0 |
| Foldable Product | Since: base-4.8.0.0 |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m # foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m # foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b # foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b # foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
| Traversable Product | Since: base-4.8.0.0 |
| Bounded a => Bounded (Product a) | Since: base-2.1 |
| Eq a => Eq (Product a) | Since: base-2.1 |
| Num a => Num (Product a) | Since: base-4.7.0.0 |
Defined in Data.Semigroup.Internal | |
| Ord a => Ord (Product a) | Since: base-2.1 |
| Read a => Read (Product a) | Since: base-2.1 |
| Show a => Show (Product a) | Since: base-2.1 |
| Generic (Product a) | Since: base-4.7.0.0 |
| Num a => Semigroup (Product a) | Since: base-4.9.0.0 |
| Num a => Monoid (Product a) | Since: base-2.1 |
| (Num a, ParseField a) => ParseRecord (Product a) Source # | |
Defined in Options.Generic Methods parseRecord :: Parser (Product a) Source # | |
| (Num a, ParseField a) => ParseFields (Product a) Source # | |
| Generic1 Product | Since: base-4.7.0.0 |
| type Rep (Product a) | |
Defined in Data.Semigroup.Internal | |
| type Rep1 Product | |
Defined in Data.Semigroup.Internal | |