Configuration.Utils.CommandLine

This module provides tools for defining command line parsers for configuration types.

Unlike normal command line parsers the parsers for configuration types are expected to yield an update function that takes a value and updates the value with the settings from the command line.

Assuming that

• all configuration types are nested Haskell records or simple types and
• that there are lenses for all record fields

usually the operators .:: and %:: are all that is needed from this module.

The module Configuration.Utils.Monoid provides tools for the case that a simple type is a container with a monoid instance, such as List or HashMap.

The module Configuration.Utils.Maybe explains the usage of optional Maybe values in configuration types.

Documentation

type MParser a = Parser (a -> a)

Type of option parsers that yield a modification function.

(.::) :: (Alternative f, Applicative f) => Lens' a b -> f b -> f (a -> a) infixr 5

An operator for applying a setter to an option parser that yields a value.

Example usage:

data Auth = Auth
    { _user ∷ !String
    , _pwd ∷ !String
    }

user ∷ Functor f ⇒ (String → f String) → Auth → f Auth
user f s = (\u → s { _user = u }) <$> f (_user s)

pwd ∷ Functor f ⇒ (String → f String) → Auth → f Auth
pwd f s = (\p → s { _pwd = p }) <$> f (_pwd s)

-- or with lenses and TemplateHaskell just:
-- $(makeLenses ''Auth)

pAuth ∷ MParser Auth
pAuth = id
   <$< user .:: strOption
       % long "user"
       ⊕ short 'u'
       ⊕ help "user name"
   <*< pwd .:: strOption
       % long "pwd"
       ⊕ help "password for user"

(%::) :: (Alternative f, Applicative f) => Lens' a b -> f (b -> b) -> f (a -> a) infixr 5

An operator for applying a setter to an option parser that yields a modification function.

Example usage:

data HttpURL = HttpURL
    { _auth ∷ !Auth
    , _domain ∷ !String
    }

auth ∷ Functor f ⇒ (Auth → f Auth) → HttpURL → f HttpURL
auth f s = (\u → s { _auth = u }) <$> f (_auth s)

domain ∷ Functor f ⇒ (String → f String) → HttpURL → f HttpURL
domain f s = (\u → s { _domain = u }) <$> f (_domain s)

path ∷ Functor f ⇒ (String → f String) → HttpURL → f HttpURL
path f s = (\u → s { _path = u }) <$> f (_path s)

-- or with lenses and TemplateHaskell just:
-- $(makeLenses ''HttpURL)

pHttpURL ∷ MParser HttpURL
pHttpURL = id
    <$< auth %:: pAuth
    <*< domain .:: strOption
        % long "domain"
        ⊕ short 'd'
        ⊕ help "HTTP domain"

Misc Utils

boolReader :: (Eq a, Show a, FoldCase a, IsString a, IsString e, Monoid e) => a -> Either e Bool

boolOption :: Mod OptionFields Bool -> Parser Bool

The boolOption is an alternative to switch.

Using switch with command line parsers that overwrite settings from a configuration file is problematic: the absence of the switch is interpreted as setting the respective configuration value to False. So there is no way to specify on the command line that the value from the configuration file shall be used. Some command line UIs use two different options for those values, for instance --enable-feature and --disable-feature. This option instead expects a Boolean value. Beside that it behaves like any other option.

boolOption_ :: Mod FlagFields Bool -> Parser Bool

An alternative syntax for boolOption for options with long names.

Instead of taking a boolean argument the presence of the option acts as a switch to set the respective configuration setting to True. If the option is not present the setting is left unchanged.

In addition for long option names a respective unset flag is provided. For instance for a flag --verbose there will also be a flag --no-verbose.

This can still be used with short option names only, but no unset flag would be provided.

enableDisableFlag :: Mod FlagFields Bool -> Parser Bool

An option parser for flags that are enabled via the flag name prefixed with --enable- and disabled via the flag name prefix --disable-. The prefixes are applied to all long option names. Short option names are parsed unchanged and cause the flag to be enabled.

This resembles the style of flags that is used for instances with Cabal.

fileOption :: Mod OptionFields String -> Parser FilePath

An option that expects a file name.

eitherReadP :: Text -> ReadP a -> Text -> Either Text a

Create an either-reader from a ReadP parser.

jsonOption :: FromJSON a => Mod OptionFields a -> Parser a

An option that expects a JSON value as argument.

jsonReader :: FromJSON a => ReadM a

An option reader for a JSON value.

(<$) :: Functor f => a -> f b -> f a infixl 4

Replace all locations in the input with the same value. The default definition is fmap . const, but this may be overridden with a more efficient version.

Using ApplicativeDo: 'a <$ bs' can be understood as the do expression

do bs
   pure a

with an inferred Functor constraint.

class Functor f => Applicative (f :: Type -> Type) where

A functor with application, providing operations to

• embed pure expressions (pure), and
• sequence computations and combine their results (<*> and liftA2).

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

Identity

pure id <*> v = v

Composition

pure (.) <*> u <*> v <*> w = u <*> (v <*> w)

Homomorphism

pure f <*> pure x = pure (f x)

Interchange

u <*> pure y = pure ($ y) <*> u

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

• u *> v = (id <$ u) <*> v

• u <* v = liftA2 const u v

As a consequence of these laws, the Functor instance for f will satisfy

• fmap f x = pure f <*> x

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

• pure = return

• m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

• (*>) = (>>)

(which implies that pure and <*> satisfy the applicative functor laws).

Minimal complete definition

pure, ((<*>) | liftA2)

Methods

pure :: a -> f a

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b infixl 4

Sequential application.

A few functors support an implementation of <*> that is more efficient than the default one.

Using ApplicativeDo: 'fs <*> as' can be understood as the do expression

do f <- fs
   a <- as
   pure (f a)

liftA2 :: (a -> b -> c) -> f a -> f b -> f c

Lift a binary function to actions.

Some functors support an implementation of liftA2 that is more efficient than the default one. In particular, if fmap is an expensive operation, it is likely better to use liftA2 than to fmap over the structure and then use <*>.

This became a typeclass method in 4.10.0.0. Prior to that, it was a function defined in terms of <*> and fmap.

Using ApplicativeDo: 'liftA2 f as bs' can be understood as the do expression

do a <- as
   b <- bs
   pure (f a b)

(*>) :: f a -> f b -> f b infixl 4

Sequence actions, discarding the value of the first argument.

'as *> bs' can be understood as the do expression

do as
   bs

This is a tad complicated for our ApplicativeDo extension which will give it a Monad constraint. For an Applicative constraint we write it of the form

do _ <- as
   b <- bs
   pure b

(<*) :: f a -> f b -> f a infixl 4

Sequence actions, discarding the value of the second argument.

Using ApplicativeDo: 'as <* bs' can be understood as the do expression

do a <- as
   bs
   pure a

Instances

Applicative []

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> [a]

(<*>) :: [a -> b] -> [a] -> [b]

liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c]

(*>) :: [a] -> [b] -> [b]

(<*) :: [a] -> [b] -> [a]

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

(<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

(*>) :: Maybe a -> Maybe b -> Maybe b

(<*) :: Maybe a -> Maybe b -> Maybe a

Applicative IO

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> IO a

(<*>) :: IO (a -> b) -> IO a -> IO b

liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c

(*>) :: IO a -> IO b -> IO b

(<*) :: IO a -> IO b -> IO a

Applicative Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Par1 a

(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b

liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c

(*>) :: Par1 a -> Par1 b -> Par1 b

(<*) :: Par1 a -> Par1 b -> Par1 a

Applicative Q

Defined in Language.Haskell.TH.Syntax

Methods

pure :: a -> Q a

(<*>) :: Q (a -> b) -> Q a -> Q b

liftA2 :: (a -> b -> c) -> Q a -> Q b -> Q c

(*>) :: Q a -> Q b -> Q b

(<*) :: Q a -> Q b -> Q a

Applicative First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Flag

Defined in Distribution.Simple.Flag

Methods

pure :: a -> Flag a

(<*>) :: Flag (a -> b) -> Flag a -> Flag b

liftA2 :: (a -> b -> c) -> Flag a -> Flag b -> Flag c

(*>) :: Flag a -> Flag b -> Flag b

(<*) :: Flag a -> Flag b -> Flag a

Applicative Condition

Defined in Distribution.Types.Condition

Methods

pure :: a -> Condition a

(<*>) :: Condition (a -> b) -> Condition a -> Condition b

liftA2 :: (a -> b -> c) -> Condition a -> Condition b -> Condition c

(*>) :: Condition a -> Condition b -> Condition b

(<*) :: Condition a -> Condition b -> Condition a

Applicative NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

pure :: a -> NonEmpty a

(<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

(*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b

(<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a

Applicative Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

pure :: a -> Identity a

(<*>) :: Identity (a -> b) -> Identity a -> Identity b

liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

(*>) :: Identity a -> Identity b -> Identity b

(<*) :: Identity a -> Identity b -> Identity a

Applicative IResult

Defined in Data.Aeson.Types.Internal

Methods

pure :: a -> IResult a

(<*>) :: IResult (a -> b) -> IResult a -> IResult b

liftA2 :: (a -> b -> c) -> IResult a -> IResult b -> IResult c

(*>) :: IResult a -> IResult b -> IResult b

(<*) :: IResult a -> IResult b -> IResult a

Applicative Result

Defined in Data.Aeson.Types.Internal

Methods

pure :: a -> Result a

(<*>) :: Result (a -> b) -> Result a -> Result b

liftA2 :: (a -> b -> c) -> Result a -> Result b -> Result c

(*>) :: Result a -> Result b -> Result b

(<*) :: Result a -> Result b -> Result a

Applicative Parser

Defined in Data.Aeson.Types.Internal

Methods

pure :: a -> Parser a

(<*>) :: Parser (a -> b) -> Parser a -> Parser b

liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c

(*>) :: Parser a -> Parser b -> Parser b

(<*) :: Parser a -> Parser b -> Parser a

Applicative Complex

Since: base-4.9.0.0

Defined in Data.Complex

Methods

pure :: a -> Complex a

(<*>) :: Complex (a -> b) -> Complex a -> Complex b

liftA2 :: (a -> b -> c) -> Complex a -> Complex b -> Complex c

(*>) :: Complex a -> Complex b -> Complex b

(<*) :: Complex a -> Complex b -> Complex a

Applicative Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Min a

(<*>) :: Min (a -> b) -> Min a -> Min b

liftA2 :: (a -> b -> c) -> Min a -> Min b -> Min c

(*>) :: Min a -> Min b -> Min b

(<*) :: Min a -> Min b -> Min a

Applicative Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Max a

(<*>) :: Max (a -> b) -> Max a -> Max b

liftA2 :: (a -> b -> c) -> Max a -> Max b -> Max c

(*>) :: Max a -> Max b -> Max b

(<*) :: Max a -> Max b -> Max a

Applicative Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

pure :: a -> Option a

(<*>) :: Option (a -> b) -> Option a -> Option b

liftA2 :: (a -> b -> c) -> Option a -> Option b -> Option c

(*>) :: Option a -> Option b -> Option b

(<*) :: Option a -> Option b -> Option a

Applicative ZipList

f <$> ZipList xs1 <*> ... <*> ZipList xsN
    = ZipList (zipWithN f xs1 ... xsN)

where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:

(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> ZipList a

(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b

liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

(*>) :: ZipList a -> ZipList b -> ZipList b

(<*) :: ZipList a -> ZipList b -> ZipList a

Applicative First

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

pure :: a -> First a

(<*>) :: First (a -> b) -> First a -> First b

liftA2 :: (a -> b -> c) -> First a -> First b -> First c

(*>) :: First a -> First b -> First b

(<*) :: First a -> First b -> First a

Applicative Last

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

pure :: a -> Last a

(<*>) :: Last (a -> b) -> Last a -> Last b

liftA2 :: (a -> b -> c) -> Last a -> Last b -> Last c

(*>) :: Last a -> Last b -> Last b

(<*) :: Last a -> Last b -> Last a

Applicative Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Dual a

(<*>) :: Dual (a -> b) -> Dual a -> Dual b

liftA2 :: (a -> b -> c) -> Dual a -> Dual b -> Dual c

(*>) :: Dual a -> Dual b -> Dual b

(<*) :: Dual a -> Dual b -> Dual a

Applicative Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Sum a

(<*>) :: Sum (a -> b) -> Sum a -> Sum b

liftA2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c

(*>) :: Sum a -> Sum b -> Sum b

(<*) :: Sum a -> Sum b -> Sum a

Applicative Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Product a

(<*>) :: Product (a -> b) -> Product a -> Product b

liftA2 :: (a -> b -> c) -> Product a -> Product b -> Product c

(*>) :: Product a -> Product b -> Product b

(<*) :: Product a -> Product b -> Product a

Applicative Down

Since: base-4.11.0.0

Defined in Data.Ord

Methods

pure :: a -> Down a

(<*>) :: Down (a -> b) -> Down a -> Down b

liftA2 :: (a -> b -> c) -> Down a -> Down b -> Down c

(*>) :: Down a -> Down b -> Down b

(<*) :: Down a -> Down b -> Down a

Applicative ReadPrec

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadPrec

Methods

pure :: a -> ReadPrec a

(<*>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b

liftA2 :: (a -> b -> c) -> ReadPrec a -> ReadPrec b -> ReadPrec c

(*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b

(<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a

Applicative ReadP

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> ReadP a

(<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b

liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c

(*>) :: ReadP a -> ReadP b -> ReadP b

(<*) :: ReadP a -> ReadP b -> ReadP a

Applicative Put

Defined in Data.ByteString.Builder.Internal

Methods

pure :: a -> Put a

(<*>) :: Put (a -> b) -> Put a -> Put b

liftA2 :: (a -> b -> c) -> Put a -> Put b -> Put c

(*>) :: Put a -> Put b -> Put b

(<*) :: Put a -> Put b -> Put a

Applicative Tree

Defined in Data.Tree

Methods

pure :: a -> Tree a

(<*>) :: Tree (a -> b) -> Tree a -> Tree b

liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c

(*>) :: Tree a -> Tree b -> Tree b

(<*) :: Tree a -> Tree b -> Tree a

Applicative Seq

Since: containers-0.5.4

Defined in Data.Sequence.Internal

Methods

pure :: a -> Seq a

(<*>) :: Seq (a -> b) -> Seq a -> Seq b

liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c

(*>) :: Seq a -> Seq b -> Seq b

(<*) :: Seq a -> Seq b -> Seq a

Applicative DNonEmpty

Defined in Data.DList.DNonEmpty.Internal

Methods

pure :: a -> DNonEmpty a

(<*>) :: DNonEmpty (a -> b) -> DNonEmpty a -> DNonEmpty b

liftA2 :: (a -> b -> c) -> DNonEmpty a -> DNonEmpty b -> DNonEmpty c

(*>) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty b

(<*) :: DNonEmpty a -> DNonEmpty b -> DNonEmpty a

Applicative DList

Defined in Data.DList.Internal

Methods

pure :: a -> DList a

(<*>) :: DList (a -> b) -> DList a -> DList b

liftA2 :: (a -> b -> c) -> DList a -> DList b -> DList c

(*>) :: DList a -> DList b -> DList b

(<*) :: DList a -> DList b -> DList a

Applicative ReadM

Defined in Options.Applicative.Types

Methods

pure :: a -> ReadM a

(<*>) :: ReadM (a -> b) -> ReadM a -> ReadM b

liftA2 :: (a -> b -> c) -> ReadM a -> ReadM b -> ReadM c

(*>) :: ReadM a -> ReadM b -> ReadM b

(<*) :: ReadM a -> ReadM b -> ReadM a

Applicative Parser

Defined in Options.Applicative.Types

Methods

pure :: a -> Parser a

(<*>) :: Parser (a -> b) -> Parser a -> Parser b

liftA2 :: (a -> b -> c) -> Parser a -> Parser b -> Parser c

(*>) :: Parser a -> Parser b -> Parser b

(<*) :: Parser a -> Parser b -> Parser a

Applicative ParserM

Defined in Options.Applicative.Types

Methods

pure :: a -> ParserM a

(<*>) :: ParserM (a -> b) -> ParserM a -> ParserM b

liftA2 :: (a -> b -> c) -> ParserM a -> ParserM b -> ParserM c

(*>) :: ParserM a -> ParserM b -> ParserM b

(<*) :: ParserM a -> ParserM b -> ParserM a

Applicative ParserResult

Defined in Options.Applicative.Types

Methods

pure :: a -> ParserResult a

(<*>) :: ParserResult (a -> b) -> ParserResult a -> ParserResult b

liftA2 :: (a -> b -> c) -> ParserResult a -> ParserResult b -> ParserResult c

(*>) :: ParserResult a -> ParserResult b -> ParserResult b

(<*) :: ParserResult a -> ParserResult b -> ParserResult a

Applicative Chunk

Defined in Options.Applicative.Help.Chunk

Methods

pure :: a -> Chunk a

(<*>) :: Chunk (a -> b) -> Chunk a -> Chunk b

liftA2 :: (a -> b -> c) -> Chunk a -> Chunk b -> Chunk c

(*>) :: Chunk a -> Chunk b -> Chunk b

(<*) :: Chunk a -> Chunk b -> Chunk a

Applicative SmallArray

Defined in Data.Primitive.SmallArray

Methods

pure :: a -> SmallArray a

(<*>) :: SmallArray (a -> b) -> SmallArray a -> SmallArray b

liftA2 :: (a -> b -> c) -> SmallArray a -> SmallArray b -> SmallArray c

(*>) :: SmallArray a -> SmallArray b -> SmallArray b

(<*) :: SmallArray a -> SmallArray b -> SmallArray a

Applicative Array

Defined in Data.Primitive.Array

Methods

pure :: a -> Array a

(<*>) :: Array (a -> b) -> Array a -> Array b

liftA2 :: (a -> b -> c) -> Array a -> Array b -> Array c

(*>) :: Array a -> Array b -> Array b

(<*) :: Array a -> Array b -> Array a

Applicative Vector

Defined in Data.Vector

Methods

pure :: a -> Vector a

(<*>) :: Vector (a -> b) -> Vector a -> Vector b

liftA2 :: (a -> b -> c) -> Vector a -> Vector b -> Vector c

(*>) :: Vector a -> Vector b -> Vector b

(<*) :: Vector a -> Vector b -> Vector a

Applicative Id

Defined in Data.Vector.Fusion.Util

Methods

pure :: a -> Id a

(<*>) :: Id (a -> b) -> Id a -> Id b

liftA2 :: (a -> b -> c) -> Id a -> Id b -> Id c

(*>) :: Id a -> Id b -> Id b

(<*) :: Id a -> Id b -> Id a

Applicative Box

Defined in Data.Vector.Fusion.Util

Methods

pure :: a -> Box a

(<*>) :: Box (a -> b) -> Box a -> Box b

liftA2 :: (a -> b -> c) -> Box a -> Box b -> Box c

(*>) :: Box a -> Box b -> Box b

(<*) :: Box a -> Box b -> Box a

Applicative P

Since: base-4.5.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> P a

(<*>) :: P (a -> b) -> P a -> P b

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

(*>) :: P a -> P b -> P b

(<*) :: P a -> P b -> P a

Applicative (Either e)

Since: base-3.0

Defined in Data.Either

Methods

pure :: a -> Either e a

(<*>) :: Either e (a -> b) -> Either e a -> Either e b

liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c

(*>) :: Either e a -> Either e b -> Either e b

(<*) :: Either e a -> Either e b -> Either e a

Applicative (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> U1 a

(<*>) :: U1 (a -> b) -> U1 a -> U1 b

liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c

(*>) :: U1 a -> U1 b -> U1 b

(<*) :: U1 a -> U1 b -> U1 a

Monoid a => Applicative ((,) a)

For tuples, the Monoid constraint on a determines how the first values merge. For example, Strings concatenate:

("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a0 -> (a, a0)

(<*>) :: (a, a0 -> b) -> (a, a0) -> (a, b)

liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c)

(*>) :: (a, a0) -> (a, b) -> (a, b)

(<*) :: (a, a0) -> (a, b) -> (a, a0)

Applicative (Proxy :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Proxy

Methods

pure :: a -> Proxy a

(<*>) :: Proxy (a -> b) -> Proxy a -> Proxy b

liftA2 :: (a -> b -> c) -> Proxy a -> Proxy b -> Proxy c

(*>) :: Proxy a -> Proxy b -> Proxy b

(<*) :: Proxy a -> Proxy b -> Proxy a

Applicative (Parser i)

Defined in Data.Attoparsec.Internal.Types

Methods

pure :: a -> Parser i a

(<*>) :: Parser i (a -> b) -> Parser i a -> Parser i b

liftA2 :: (a -> b -> c) -> Parser i a -> Parser i b -> Parser i c

(*>) :: Parser i a -> Parser i b -> Parser i b

(<*) :: Parser i a -> Parser i b -> Parser i a

Monad m => Applicative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> WrappedMonad m a

(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

Arrow a => Applicative (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> ArrowMonad a a0

(<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c

(*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b

(<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0

(Functor m, Monad m) => Applicative (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

pure :: a -> MaybeT m a

(<*>) :: MaybeT m (a -> b) -> MaybeT m a -> MaybeT m b

liftA2 :: (a -> b -> c) -> MaybeT m a -> MaybeT m b -> MaybeT m c

(*>) :: MaybeT m a -> MaybeT m b -> MaybeT m b

(<*) :: MaybeT m a -> MaybeT m b -> MaybeT m a

Monad m => Applicative (ZipSource m)

Defined in Data.Conduit.Internal.Conduit

Methods

pure :: a -> ZipSource m a

(<*>) :: ZipSource m (a -> b) -> ZipSource m a -> ZipSource m b

liftA2 :: (a -> b -> c) -> ZipSource m a -> ZipSource m b -> ZipSource m c

(*>) :: ZipSource m a -> ZipSource m b -> ZipSource m b

(<*) :: ZipSource m a -> ZipSource m b -> ZipSource m a

Applicative m => Applicative (ResourceT m)

Defined in Control.Monad.Trans.Resource.Internal

Methods

pure :: a -> ResourceT m a

(<*>) :: ResourceT m (a -> b) -> ResourceT m a -> ResourceT m b

liftA2 :: (a -> b -> c) -> ResourceT m a -> ResourceT m b -> ResourceT m c

(*>) :: ResourceT m a -> ResourceT m b -> ResourceT m b

(<*) :: ResourceT m a -> ResourceT m b -> ResourceT m a

Applicative m => Applicative (ListT m)

Defined in Control.Monad.Trans.List

Methods

pure :: a -> ListT m a

(<*>) :: ListT m (a -> b) -> ListT m a -> ListT m b

liftA2 :: (a -> b -> c) -> ListT m a -> ListT m b -> ListT m c

(*>) :: ListT m a -> ListT m b -> ListT m b

(<*) :: ListT m a -> ListT m b -> ListT m a

Applicative f => Applicative (WrappedApplicative f)

Defined in Data.Functor.Bind.Class

Methods

pure :: a -> WrappedApplicative f a

(<*>) :: WrappedApplicative f (a -> b) -> WrappedApplicative f a -> WrappedApplicative f b

liftA2 :: (a -> b -> c) -> WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f c

(*>) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f b

(<*) :: WrappedApplicative f a -> WrappedApplicative f b -> WrappedApplicative f a

Apply f => Applicative (MaybeApply f)

Defined in Data.Functor.Bind.Class

Methods

pure :: a -> MaybeApply f a

(<*>) :: MaybeApply f (a -> b) -> MaybeApply f a -> MaybeApply f b

liftA2 :: (a -> b -> c) -> MaybeApply f a -> MaybeApply f b -> MaybeApply f c

(*>) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f b

(<*) :: MaybeApply f a -> MaybeApply f b -> MaybeApply f a

Semigroup a => Applicative (These a)

Defined in Data.Strict.These

Methods

pure :: a0 -> These a a0

(<*>) :: These a (a0 -> b) -> These a a0 -> These a b

liftA2 :: (a0 -> b -> c) -> These a a0 -> These a b -> These a c

(*>) :: These a a0 -> These a b -> These a b

(<*) :: These a a0 -> These a b -> These a a0

Semigroup a => Applicative (These a)

Defined in Data.These

Methods

pure :: a0 -> These a a0

(<*>) :: These a (a0 -> b) -> These a a0 -> These a b

liftA2 :: (a0 -> b -> c) -> These a a0 -> These a b -> These a c

(*>) :: These a a0 -> These a b -> These a b

(<*) :: These a a0 -> These a b -> These a a0

Applicative (SetM s)

Defined in Data.Graph

Methods

pure :: a -> SetM s a

(<*>) :: SetM s (a -> b) -> SetM s a -> SetM s b

liftA2 :: (a -> b -> c) -> SetM s a -> SetM s b -> SetM s c

(*>) :: SetM s a -> SetM s b -> SetM s b

(<*) :: SetM s a -> SetM s b -> SetM s a

Applicative f => Applicative (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Rec1 f a

(<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b

liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c

(*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b

(<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a

(Monoid a, Monoid b) => Applicative ((,,) a b)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, a0)

(<*>) :: (a, b, a0 -> b0) -> (a, b, a0) -> (a, b, b0)

liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c)

(*>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0)

(<*) :: (a, b, a0) -> (a, b, b0) -> (a, b, a0)

Arrow a => Applicative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a0 -> WrappedArrow a b a0

(<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

(*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0

(<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

Applicative m => Applicative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> Kleisli m a a0

(<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b

liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c

(*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b

(<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0

Monoid m => Applicative (Const m :: Type -> Type)

Since: base-2.0.1

Defined in Data.Functor.Const

Methods

pure :: a -> Const m a

(<*>) :: Const m (a -> b) -> Const m a -> Const m b

liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c

(*>) :: Const m a -> Const m b -> Const m b

(<*) :: Const m a -> Const m b -> Const m a

Applicative f => Applicative (Ap f)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

pure :: a -> Ap f a

(<*>) :: Ap f (a -> b) -> Ap f a -> Ap f b

liftA2 :: (a -> b -> c) -> Ap f a -> Ap f b -> Ap f c

(*>) :: Ap f a -> Ap f b -> Ap f b

(<*) :: Ap f a -> Ap f b -> Ap f a

Applicative f => Applicative (Alt f)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

pure :: a -> Alt f a

(<*>) :: Alt f (a -> b) -> Alt f a -> Alt f b

liftA2 :: (a -> b -> c) -> Alt f a -> Alt f b -> Alt f c

(*>) :: Alt f a -> Alt f b -> Alt f b

(<*) :: Alt f a -> Alt f b -> Alt f a

Biapplicative p => Applicative (Join p)

Defined in Data.Bifunctor.Join

Methods

pure :: a -> Join p a

(<*>) :: Join p (a -> b) -> Join p a -> Join p b

liftA2 :: (a -> b -> c) -> Join p a -> Join p b -> Join p c

(*>) :: Join p a -> Join p b -> Join p b

(<*) :: Join p a -> Join p b -> Join p a

Applicative m => Applicative (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

pure :: a -> IdentityT m a

(<*>) :: IdentityT m (a -> b) -> IdentityT m a -> IdentityT m b

liftA2 :: (a -> b -> c) -> IdentityT m a -> IdentityT m b -> IdentityT m c

(*>) :: IdentityT m a -> IdentityT m b -> IdentityT m b

(<*) :: IdentityT m a -> IdentityT m b -> IdentityT m a

(Monoid w, Applicative m) => Applicative (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

pure :: a -> WriterT w m a

(<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

(*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a

(Monoid w, Applicative m) => Applicative (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

pure :: a -> WriterT w m a

(<*>) :: WriterT w m (a -> b) -> WriterT w m a -> WriterT w m b

liftA2 :: (a -> b -> c) -> WriterT w m a -> WriterT w m b -> WriterT w m c

(*>) :: WriterT w m a -> WriterT w m b -> WriterT w m b

(<*) :: WriterT w m a -> WriterT w m b -> WriterT w m a

(Functor m, Monad m) => Applicative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

(Functor m, Monad m) => Applicative (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

pure :: a -> StateT s m a

(<*>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b

liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c

(*>) :: StateT s m a -> StateT s m b -> StateT s m b

(<*) :: StateT s m a -> StateT s m b -> StateT s m a

Applicative m => Applicative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

pure :: a -> ReaderT r m a

(<*>) :: ReaderT r m (a -> b) -> ReaderT r m a -> ReaderT r m b

liftA2 :: (a -> b -> c) -> ReaderT r m a -> ReaderT r m b -> ReaderT r m c

(*>) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m b

(<*) :: ReaderT r m a -> ReaderT r m b -> ReaderT r m a

(Functor m, Monad m) => Applicative (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

pure :: a -> ExceptT e m a

(<*>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b

liftA2 :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c

(*>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b

(<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a

Monad m => Applicative (ZipSink i m)

Defined in Data.Conduit.Internal.Conduit

Methods

pure :: a -> ZipSink i m a

(<*>) :: ZipSink i m (a -> b) -> ZipSink i m a -> ZipSink i m b

liftA2 :: (a -> b -> c) -> ZipSink i m a -> ZipSink i m b -> ZipSink i m c

(*>) :: ZipSink i m a -> ZipSink i m b -> ZipSink i m b

(<*) :: ZipSink i m a -> ZipSink i m b -> ZipSink i m a

(Applicative f, Monad f) => Applicative (WhenMissing f x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)).

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

pure :: a -> WhenMissing f x a

(<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b

liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c

(*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b

(<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a

(Functor m, Monad m) => Applicative (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

pure :: a -> ErrorT e m a

(<*>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b

liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c

(*>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

(<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a

(Profunctor p, Arrow p) => Applicative (Closure p a)

Defined in Data.Profunctor.Closed

Methods

pure :: a0 -> Closure p a a0

(<*>) :: Closure p a (a0 -> b) -> Closure p a a0 -> Closure p a b

liftA2 :: (a0 -> b -> c) -> Closure p a a0 -> Closure p a b -> Closure p a c

(*>) :: Closure p a a0 -> Closure p a b -> Closure p a b

(<*) :: Closure p a a0 -> Closure p a b -> Closure p a a0

(Profunctor p, Arrow p) => Applicative (Tambara p a)

Defined in Data.Profunctor.Strong

Methods

pure :: a0 -> Tambara p a a0

(<*>) :: Tambara p a (a0 -> b) -> Tambara p a a0 -> Tambara p a b

liftA2 :: (a0 -> b -> c) -> Tambara p a a0 -> Tambara p a b -> Tambara p a c

(*>) :: Tambara p a a0 -> Tambara p a b -> Tambara p a b

(<*) :: Tambara p a a0 -> Tambara p a b -> Tambara p a a0

Applicative (Tagged s)

Defined in Data.Tagged

Methods

pure :: a -> Tagged s a

(<*>) :: Tagged s (a -> b) -> Tagged s a -> Tagged s b

liftA2 :: (a -> b -> c) -> Tagged s a -> Tagged s b -> Tagged s c

(*>) :: Tagged s a -> Tagged s b -> Tagged s b

(<*) :: Tagged s a -> Tagged s b -> Tagged s a

Applicative (Mag a b)

Defined in Data.Biapplicative

Methods

pure :: a0 -> Mag a b a0

(<*>) :: Mag a b (a0 -> b0) -> Mag a b a0 -> Mag a b b0

liftA2 :: (a0 -> b0 -> c) -> Mag a b a0 -> Mag a b b0 -> Mag a b c

(*>) :: Mag a b a0 -> Mag a b b0 -> Mag a b b0

(<*) :: Mag a b a0 -> Mag a b b0 -> Mag a b a0

Applicative ((->) r :: Type -> Type)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> r -> a

(<*>) :: (r -> (a -> b)) -> (r -> a) -> r -> b

liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c

(*>) :: (r -> a) -> (r -> b) -> r -> b

(<*) :: (r -> a) -> (r -> b) -> r -> a

Monoid c => Applicative (K1 i c :: Type -> Type)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

pure :: a -> K1 i c a

(<*>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b

liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0

(*>) :: K1 i c a -> K1 i c b -> K1 i c b

(<*) :: K1 i c a -> K1 i c b -> K1 i c a

(Applicative f, Applicative g) => Applicative (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :*: g) a

(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b

liftA2 :: (a -> b -> c) -> (f :*: g) a -> (f :*: g) b -> (f :*: g) c

(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b

(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a

(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, c, a0)

(<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0)

liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0)

(*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0)

(<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0)

(Applicative f, Applicative g) => Applicative (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

pure :: a -> Product f g a

(<*>) :: Product f g (a -> b) -> Product f g a -> Product f g b

liftA2 :: (a -> b -> c) -> Product f g a -> Product f g b -> Product f g c

(*>) :: Product f g a -> Product f g b -> Product f g b

(<*) :: Product f g a -> Product f g b -> Product f g a

Applicative (Cokleisli w a)

Defined in Control.Comonad

Methods

pure :: a0 -> Cokleisli w a a0

(<*>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b

liftA2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c

(*>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b

(<*) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0

Applicative (ConduitT i o m)

Defined in Data.Conduit.Internal.Conduit

Methods

pure :: a -> ConduitT i o m a

(<*>) :: ConduitT i o m (a -> b) -> ConduitT i o m a -> ConduitT i o m b

liftA2 :: (a -> b -> c) -> ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m c

(*>) :: ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m b

(<*) :: ConduitT i o m a -> ConduitT i o m b -> ConduitT i o m a

Monad m => Applicative (ZipConduit i o m)

Defined in Data.Conduit.Internal.Conduit

Methods

pure :: a -> ZipConduit i o m a

(<*>) :: ZipConduit i o m (a -> b) -> ZipConduit i o m a -> ZipConduit i o m b

liftA2 :: (a -> b -> c) -> ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m c

(*>) :: ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m b

(<*) :: ZipConduit i o m a -> ZipConduit i o m b -> ZipConduit i o m a

(Monad f, Applicative f) => Applicative (WhenMatched f x y)

Equivalent to ReaderT Key (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

pure :: a -> WhenMatched f x y a

(<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b

liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c

(*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b

(<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a

(Applicative f, Monad f) => Applicative (WhenMissing f k x)

Equivalent to ReaderT k (ReaderT x (MaybeT f)) .

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMissing f k x a

(<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c

(*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b

(<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a

Applicative (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

pure :: a -> ContT r m a

(<*>) :: ContT r m (a -> b) -> ContT r m a -> ContT r m b

liftA2 :: (a -> b -> c) -> ContT r m a -> ContT r m b -> ContT r m c

(*>) :: ContT r m a -> ContT r m b -> ContT r m b

(<*) :: ContT r m a -> ContT r m b -> ContT r m a

Applicative f => Applicative (Star f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Star f a a0

(<*>) :: Star f a (a0 -> b) -> Star f a a0 -> Star f a b

liftA2 :: (a0 -> b -> c) -> Star f a a0 -> Star f a b -> Star f a c

(*>) :: Star f a a0 -> Star f a b -> Star f a b

(<*) :: Star f a a0 -> Star f a b -> Star f a a0

Applicative (Costar f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Costar f a a0

(<*>) :: Costar f a (a0 -> b) -> Costar f a a0 -> Costar f a b

liftA2 :: (a0 -> b -> c) -> Costar f a a0 -> Costar f a b -> Costar f a c

(*>) :: Costar f a a0 -> Costar f a b -> Costar f a b

(<*) :: Costar f a a0 -> Costar f a b -> Costar f a a0

Applicative f => Applicative (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> M1 i c f a

(<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b

liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0

(*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b

(<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a

(Applicative f, Applicative g) => Applicative (f :.: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> (f :.: g) a

(<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b

liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c

(*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b

(<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a

(Applicative f, Applicative g) => Applicative (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

pure :: a -> Compose f g a

(<*>) :: Compose f g (a -> b) -> Compose f g a -> Compose f g b

liftA2 :: (a -> b -> c) -> Compose f g a -> Compose f g b -> Compose f g c

(*>) :: Compose f g a -> Compose f g b -> Compose f g b

(<*) :: Compose f g a -> Compose f g b -> Compose f g a

(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

pure :: a -> RWST r w s m a

(<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

(Monoid w, Functor m, Monad m) => Applicative (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

pure :: a -> RWST r w s m a

(<*>) :: RWST r w s m (a -> b) -> RWST r w s m a -> RWST r w s m b

liftA2 :: (a -> b -> c) -> RWST r w s m a -> RWST r w s m b -> RWST r w s m c

(*>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b

(<*) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m a

(Monad f, Applicative f) => Applicative (WhenMatched f k x y)

Equivalent to ReaderT k (ReaderT x (ReaderT y (MaybeT f)))

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

pure :: a -> WhenMatched f k x y a

(<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c

(*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b

(<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a

Monad m => Applicative (Pipe l i o u m)

Defined in Data.Conduit.Internal.Pipe

Methods

pure :: a -> Pipe l i o u m a

(<*>) :: Pipe l i o u m (a -> b) -> Pipe l i o u m a -> Pipe l i o u m b

liftA2 :: (a -> b -> c) -> Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m c

(*>) :: Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m b

(<*) :: Pipe l i o u m a -> Pipe l i o u m b -> Pipe l i o u m a

mappend :: Monoid a => a -> a -> a

An associative operation

NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

class Applicative f => Alternative (f :: Type -> Type) where

A monoid on applicative functors.

If defined, some and many should be the least solutions of the equations:

• some v = (:) <$> v <*> many v

• many v = some v <|> pure []

Minimal complete definition

empty, (<|>)

Methods

empty :: f a

The identity of <|>

(<|>) :: f a -> f a -> f a infixl 3

An associative binary operation

some :: f a -> f [a]

One or more.

many :: f a -> f [a]

Zero or more.

Instances

Alternative []

Since: base-2.1

Defined in GHC.Base

Methods

empty :: [a]

(<|>) :: [a] -> [a] -> [a]

some :: [a] -> [[a]]

many :: [a] -> [[a]]

Alternative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

empty :: Maybe a

(<|>) :: Maybe a -> Maybe a -> Maybe a

some :: Maybe a -> Maybe [a]

many :: Maybe a -> Maybe [a]

Alternative IO

Since: base-4.9.0.0

Defined in GHC.Base

Methods

empty :: IO a

(<|>) :: IO a -> IO a -> IO a

some :: IO a -> IO [a]

many :: IO a -> IO [a]

Alternative Condition

Defined in Distribution.Types.Condition

Methods

empty :: Condition a

(<|>) :: Condition a -> Condition a -> Condition a

some :: Condition a -> Condition [a]

many :: Condition a -> Condition [a]

Alternative IResult

Defined in Data.Aeson.Types.Internal

Methods

empty :: IResult a

(<|>) :: IResult a -> IResult a -> IResult a

some :: IResult a -> IResult [a]

many :: IResult a -> IResult [a]

Alternative Result

Defined in Data.Aeson.Types.Internal

Methods

empty :: Result a

(<|>) :: Result a -> Result a -> Result a

some :: Result a -> Result [a]

many :: Result a -> Result [a]

Alternative Parser

Defined in Data.Aeson.Types.Internal

Methods

empty :: Parser a

(<|>) :: Parser a -> Parser a -> Parser a

some :: Parser a -> Parser [a]

many :: Parser a -> Parser [a]

Alternative Option

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

empty :: Option a

(<|>) :: Option a -> Option a -> Option a

some :: Option a -> Option [a]

many :: Option a -> Option [a]

Alternative ZipList

Since: base-4.11.0.0

Defined in Control.Applicative

Methods

empty :: ZipList a

(<|>) :: ZipList a -> ZipList a -> ZipList a

some :: ZipList a -> ZipList [a]

many :: ZipList a -> ZipList [a]

Alternative ReadPrec

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadPrec

Methods

empty :: ReadPrec a

(<|>) :: ReadPrec a -> ReadPrec a -> ReadPrec a

some :: ReadPrec a -> ReadPrec [a]

many :: ReadPrec a -> ReadPrec [a]

Alternative ReadP

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadP

Methods

empty :: ReadP a

(<|>) :: ReadP a -> ReadP a -> ReadP a

some :: ReadP a -> ReadP [a]

many :: ReadP a -> ReadP [a]

Alternative Seq

Since: containers-0.5.4

Defined in Data.Sequence.Internal

Methods

empty :: Seq a

(<|>) :: Seq a -> Seq a -> Seq a

some :: Seq a -> Seq [a]

many :: Seq a -> Seq [a]

Alternative DList

Defined in Data.DList.Internal

Methods

empty :: DList a

(<|>) :: DList a -> DList a -> DList a

some :: DList a -> DList [a]

many :: DList a -> DList [a]

Alternative ReadM

Defined in Options.Applicative.Types

Methods

empty :: ReadM a

(<|>) :: ReadM a -> ReadM a -> ReadM a

some :: ReadM a -> ReadM [a]

many :: ReadM a -> ReadM [a]

Alternative Parser

Defined in Options.Applicative.Types

Methods

empty :: Parser a

(<|>) :: Parser a -> Parser a -> Parser a

some :: Parser a -> Parser [a]

many :: Parser a -> Parser [a]

Alternative Chunk

Defined in Options.Applicative.Help.Chunk

Methods

empty :: Chunk a

(<|>) :: Chunk a -> Chunk a -> Chunk a

some :: Chunk a -> Chunk [a]

many :: Chunk a -> Chunk [a]

Alternative SmallArray

Defined in Data.Primitive.SmallArray

Methods

empty :: SmallArray a

(<|>) :: SmallArray a -> SmallArray a -> SmallArray a

some :: SmallArray a -> SmallArray [a]

many :: SmallArray a -> SmallArray [a]

Alternative Array

Defined in Data.Primitive.Array

Methods

empty :: Array a

(<|>) :: Array a -> Array a -> Array a

some :: Array a -> Array [a]

many :: Array a -> Array [a]

Alternative Vector

Defined in Data.Vector

Methods

empty :: Vector a

(<|>) :: Vector a -> Vector a -> Vector a

some :: Vector a -> Vector [a]

many :: Vector a -> Vector [a]

Alternative P

Since: base-4.5.0.0

Defined in Text.ParserCombinators.ReadP

Methods

empty :: P a

(<|>) :: P a -> P a -> P a

some :: P a -> P [a]

many :: P a -> P [a]

Alternative (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: U1 a

(<|>) :: U1 a -> U1 a -> U1 a

some :: U1 a -> U1 [a]

many :: U1 a -> U1 [a]

Alternative (Proxy :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Proxy

Methods

empty :: Proxy a

(<|>) :: Proxy a -> Proxy a -> Proxy a

some :: Proxy a -> Proxy [a]

many :: Proxy a -> Proxy [a]

Alternative (Parser i)

Defined in Data.Attoparsec.Internal.Types

Methods

empty :: Parser i a

(<|>) :: Parser i a -> Parser i a -> Parser i a

some :: Parser i a -> Parser i [a]

many :: Parser i a -> Parser i [a]

MonadPlus m => Alternative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedMonad m a

(<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

some :: WrappedMonad m a -> WrappedMonad m [a]

many :: WrappedMonad m a -> WrappedMonad m [a]

ArrowPlus a => Alternative (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

empty :: ArrowMonad a a0

(<|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0

some :: ArrowMonad a a0 -> ArrowMonad a [a0]

many :: ArrowMonad a a0 -> ArrowMonad a [a0]

(Functor m, Monad m) => Alternative (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

empty :: MaybeT m a

(<|>) :: MaybeT m a -> MaybeT m a -> MaybeT m a

some :: MaybeT m a -> MaybeT m [a]

many :: MaybeT m a -> MaybeT m [a]

Alternative m => Alternative (ResourceT m)

Since 1.1.5

Defined in Control.Monad.Trans.Resource.Internal

Methods

empty :: ResourceT m a

(<|>) :: ResourceT m a -> ResourceT m a -> ResourceT m a

some :: ResourceT m a -> ResourceT m [a]

many :: ResourceT m a -> ResourceT m [a]

Applicative m => Alternative (ListT m)

Defined in Control.Monad.Trans.List

Methods

empty :: ListT m a

(<|>) :: ListT m a -> ListT m a -> ListT m a

some :: ListT m a -> ListT m [a]

many :: ListT m a -> ListT m [a]

Alternative f => Alternative (WrappedApplicative f)

Defined in Data.Functor.Bind.Class

Methods

empty :: WrappedApplicative f a

(<|>) :: WrappedApplicative f a -> WrappedApplicative f a -> WrappedApplicative f a

some :: WrappedApplicative f a -> WrappedApplicative f [a]

many :: WrappedApplicative f a -> WrappedApplicative f [a]

Alternative f => Alternative (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: Rec1 f a

(<|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a

some :: Rec1 f a -> Rec1 f [a]

many :: Rec1 f a -> Rec1 f [a]

(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedArrow a b a0

(<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0

some :: WrappedArrow a b a0 -> WrappedArrow a b [a0]

many :: WrappedArrow a b a0 -> WrappedArrow a b [a0]

Alternative m => Alternative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

empty :: Kleisli m a a0

(<|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0

some :: Kleisli m a a0 -> Kleisli m a [a0]

many :: Kleisli m a a0 -> Kleisli m a [a0]

Alternative f => Alternative (Ap f)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

empty :: Ap f a

(<|>) :: Ap f a -> Ap f a -> Ap f a

some :: Ap f a -> Ap f [a]

many :: Ap f a -> Ap f [a]

Alternative f => Alternative (Alt f)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

empty :: Alt f a

(<|>) :: Alt f a -> Alt f a -> Alt f a

some :: Alt f a -> Alt f [a]

many :: Alt f a -> Alt f [a]

Alternative m => Alternative (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

empty :: IdentityT m a

(<|>) :: IdentityT m a -> IdentityT m a -> IdentityT m a

some :: IdentityT m a -> IdentityT m [a]

many :: IdentityT m a -> IdentityT m [a]

(Monoid w, Alternative m) => Alternative (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

empty :: WriterT w m a

(<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a

some :: WriterT w m a -> WriterT w m [a]

many :: WriterT w m a -> WriterT w m [a]

(Monoid w, Alternative m) => Alternative (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

empty :: WriterT w m a

(<|>) :: WriterT w m a -> WriterT w m a -> WriterT w m a

some :: WriterT w m a -> WriterT w m [a]

many :: WriterT w m a -> WriterT w m [a]

(Functor m, MonadPlus m) => Alternative (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

empty :: StateT s m a

(<|>) :: StateT s m a -> StateT s m a -> StateT s m a

some :: StateT s m a -> StateT s m [a]

many :: StateT s m a -> StateT s m [a]

(Functor m, MonadPlus m) => Alternative (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

empty :: StateT s m a

(<|>) :: StateT s m a -> StateT s m a -> StateT s m a

some :: StateT s m a -> StateT s m [a]

many :: StateT s m a -> StateT s m [a]

Alternative m => Alternative (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

empty :: ReaderT r m a

(<|>) :: ReaderT r m a -> ReaderT r m a -> ReaderT r m a

some :: ReaderT r m a -> ReaderT r m [a]

many :: ReaderT r m a -> ReaderT r m [a]

(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

empty :: ExceptT e m a

(<|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

some :: ExceptT e m a -> ExceptT e m [a]

many :: ExceptT e m a -> ExceptT e m [a]

(Functor m, Monad m, Error e) => Alternative (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

empty :: ErrorT e m a

(<|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

some :: ErrorT e m a -> ErrorT e m [a]

many :: ErrorT e m a -> ErrorT e m [a]

(Profunctor p, ArrowPlus p) => Alternative (Closure p a)

Defined in Data.Profunctor.Closed

Methods

empty :: Closure p a a0

(<|>) :: Closure p a a0 -> Closure p a a0 -> Closure p a a0

some :: Closure p a a0 -> Closure p a [a0]

many :: Closure p a a0 -> Closure p a [a0]

(Profunctor p, ArrowPlus p) => Alternative (Tambara p a)

Defined in Data.Profunctor.Strong

Methods

empty :: Tambara p a a0

(<|>) :: Tambara p a a0 -> Tambara p a a0 -> Tambara p a a0

some :: Tambara p a a0 -> Tambara p a [a0]

many :: Tambara p a a0 -> Tambara p a [a0]

(Alternative f, Alternative g) => Alternative (f :*: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: (f :*: g) a

(<|>) :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a

some :: (f :*: g) a -> (f :*: g) [a]

many :: (f :*: g) a -> (f :*: g) [a]

(Alternative f, Alternative g) => Alternative (Product f g)

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

empty :: Product f g a

(<|>) :: Product f g a -> Product f g a -> Product f g a

some :: Product f g a -> Product f g [a]

many :: Product f g a -> Product f g [a]

Alternative f => Alternative (Star f a)

Defined in Data.Profunctor.Types

Methods

empty :: Star f a a0

(<|>) :: Star f a a0 -> Star f a a0 -> Star f a a0

some :: Star f a a0 -> Star f a [a0]

many :: Star f a a0 -> Star f a [a0]

Alternative f => Alternative (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: M1 i c f a

(<|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a

some :: M1 i c f a -> M1 i c f [a]

many :: M1 i c f a -> M1 i c f [a]

(Alternative f, Applicative g) => Alternative (f :.: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: (f :.: g) a

(<|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a

some :: (f :.: g) a -> (f :.: g) [a]

many :: (f :.: g) a -> (f :.: g) [a]

(Alternative f, Applicative g) => Alternative (Compose f g)

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

empty :: Compose f g a

(<|>) :: Compose f g a -> Compose f g a -> Compose f g a

some :: Compose f g a -> Compose f g [a]

many :: Compose f g a -> Compose f g [a]

(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

empty :: RWST r w s m a

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

some :: RWST r w s m a -> RWST r w s m [a]

many :: RWST r w s m a -> RWST r w s m [a]

(Monoid w, Functor m, MonadPlus m) => Alternative (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

empty :: RWST r w s m a

(<|>) :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a

some :: RWST r w s m a -> RWST r w s m [a]

many :: RWST r w s m a -> RWST r w s m [a]

(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4

An infix synonym for fmap.

The name of this operator is an allusion to $. Note the similarities between their types:

 ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b

Whereas $ is function application, <$> is function application lifted over a Functor.

Examples

Convert from a Maybe Int to a Maybe String using show:

>>> show <$> Nothing
Nothing
>>> show <$> Just 3
Just "3"

Convert from an Either Int Int to an Either Int String using show:

>>> show <$> Left 17
Left 17
>>> show <$> Right 17
Right "17"

Double each element of a list:

>>> (*2) <$> [1,2,3]
[2,4,6]

Apply even to the second element of a pair:

>>> even <$> (2,2)
(2,True)

optional :: Alternative f => f a -> f (Maybe a)

One or none.

newtype WrappedMonad (m :: Type -> Type) a

Constructors

WrapMonad

Fields

• unwrapMonad :: m a

Instances

Monad m => Monad (WrappedMonad m)

Since: base-4.7.0.0

Defined in Control.Applicative

Methods

(>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b

(>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

return :: a -> WrappedMonad m a

Monad m => Functor (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b

(<$) :: a -> WrappedMonad m b -> WrappedMonad m a

Monad m => Applicative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> WrappedMonad m a

(<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

(*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

MonadPlus m => Alternative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedMonad m a

(<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

some :: WrappedMonad m a -> WrappedMonad m [a]

many :: WrappedMonad m a -> WrappedMonad m [a]

MonadPlus m => Alt (WrappedMonad m)

Defined in Data.Functor.Alt

Methods

(<!>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

some :: Applicative (WrappedMonad m) => WrappedMonad m a -> WrappedMonad m [a]

many :: Applicative (WrappedMonad m) => WrappedMonad m a -> WrappedMonad m [a]

Monad m => Apply (WrappedMonad m)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b

(.>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b

(<.) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a

liftF2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

Monad m => Bind (WrappedMonad m)

Defined in Data.Functor.Bind.Class

Methods

(>>-) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b

join :: WrappedMonad m (WrappedMonad m a) -> WrappedMonad m a

Generic1 (WrappedMonad m :: Type -> Type)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep1 (WrappedMonad m) :: k -> Type

Methods

from1 :: forall (a :: k). WrappedMonad m a -> Rep1 (WrappedMonad m) a

to1 :: forall (a :: k). Rep1 (WrappedMonad m) a -> WrappedMonad m a

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

type Rep1 (WrappedMonad m :: Type -> Type)

Defined in Control.Applicative

type Rep1 (WrappedMonad m :: Type -> Type) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 m)))

type Rep (WrappedMonad m a)

Defined in Control.Applicative

type Rep (WrappedMonad m a) = D1 ('MetaData "WrappedMonad" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapMonad" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapMonad") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (m a))))

newtype WrappedArrow (a :: Type -> Type -> Type) b c

Constructors

WrapArrow

Fields

• unwrapArrow :: a b c

Instances

Generic1 (WrappedArrow a b :: Type -> Type)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep1 (WrappedArrow a b) :: k -> Type

Methods

from1 :: forall (a0 :: k). WrappedArrow a b a0 -> Rep1 (WrappedArrow a b) a0

to1 :: forall (a0 :: k). Rep1 (WrappedArrow a b) a0 -> WrappedArrow a b a0

Arrow a => Functor (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

(<$) :: a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

Arrow a => Applicative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a0 -> WrappedArrow a b a0

(<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

(*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0

(<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedArrow a b a0

(<|>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0

some :: WrappedArrow a b a0 -> WrappedArrow a b [a0]

many :: WrappedArrow a b a0 -> WrappedArrow a b [a0]

ArrowPlus a => Alt (WrappedArrow a b)

Defined in Data.Functor.Alt

Methods

(<!>) :: WrappedArrow a b a0 -> WrappedArrow a b a0 -> WrappedArrow a b a0

some :: Applicative (WrappedArrow a b) => WrappedArrow a b a0 -> WrappedArrow a b [a0]

many :: Applicative (WrappedArrow a b) => WrappedArrow a b a0 -> WrappedArrow a b [a0]

Arrow a => Apply (WrappedArrow a b)

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

(.>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0

(<.) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0

liftF2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

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

type Rep1 (WrappedArrow a b :: Type -> Type)

Defined in Control.Applicative

type Rep1 (WrappedArrow a b :: Type -> Type) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 (a b))))

type Rep (WrappedArrow a b c)

Defined in Control.Applicative

type Rep (WrappedArrow a b c) = D1 ('MetaData "WrappedArrow" "Control.Applicative" "base" 'True) (C1 ('MetaCons "WrapArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "unwrapArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a b c))))

newtype ZipList a

Lists, but with an Applicative functor based on zipping.

Constructors

ZipList

Fields

• getZipList :: [a]

Instances

Functor ZipList

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a -> b) -> ZipList a -> ZipList b

(<$) :: a -> ZipList b -> ZipList a

Applicative ZipList

f <$> ZipList xs1 <*> ... <*> ZipList xsN
    = ZipList (zipWithN f xs1 ... xsN)

where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:

(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> ZipList a

(<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b

liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

(*>) :: ZipList a -> ZipList b -> ZipList b

(<*) :: ZipList a -> ZipList b -> ZipList a

Foldable ZipList

Since: base-4.9.0.0

Defined in Control.Applicative

Methods

fold :: Monoid m => ZipList m -> m

foldMap :: Monoid m => (a -> m) -> ZipList a -> m

foldMap' :: Monoid m => (a -> m) -> ZipList a -> m

foldr :: (a -> b -> b) -> b -> ZipList a -> b

foldr' :: (a -> b -> b) -> b -> ZipList a -> b

foldl :: (b -> a -> b) -> b -> ZipList a -> b

foldl' :: (b -> a -> b) -> b -> ZipList a -> b

foldr1 :: (a -> a -> a) -> ZipList a -> a

foldl1 :: (a -> a -> a) -> ZipList a -> a

toList :: ZipList a -> [a]

null :: ZipList a -> Bool

length :: ZipList a -> Int

elem :: Eq a => a -> ZipList a -> Bool

maximum :: Ord a => ZipList a -> a

minimum :: Ord a => ZipList a -> a

sum :: Num a => ZipList a -> a

product :: Num a => ZipList a -> a

Traversable ZipList

Since: base-4.9.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b)

sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a)

mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b)

sequence :: Monad m => ZipList (m a) -> m (ZipList a)

Alternative ZipList

Since: base-4.11.0.0

Defined in Control.Applicative

Methods

empty :: ZipList a

(<|>) :: ZipList a -> ZipList a -> ZipList a

some :: ZipList a -> ZipList [a]

many :: ZipList a -> ZipList [a]

NFData1 ZipList

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a -> ()) -> ZipList a -> ()

Apply ZipList

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: ZipList (a -> b) -> ZipList a -> ZipList b

(.>) :: ZipList a -> ZipList b -> ZipList b

(<.) :: ZipList a -> ZipList b -> ZipList a

liftF2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

IsList (ZipList a)

Since: base-4.15.0.0

Defined in GHC.Exts

Associated Types

type Item (ZipList a)

Methods

fromList :: [Item (ZipList a)] -> ZipList a

fromListN :: Int -> [Item (ZipList a)] -> ZipList a

toList :: ZipList a -> [Item (ZipList a)]

Eq a => Eq (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Methods

(==) :: ZipList a -> ZipList a -> Bool

(/=) :: ZipList a -> ZipList a -> Bool

Ord a => Ord (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Methods

compare :: ZipList a -> ZipList a -> Ordering

(<) :: ZipList a -> ZipList a -> Bool

(<=) :: ZipList a -> ZipList a -> Bool

(>) :: ZipList a -> ZipList a -> Bool

(>=) :: ZipList a -> ZipList a -> Bool

max :: ZipList a -> ZipList a -> ZipList a

min :: ZipList a -> ZipList a -> ZipList a

Read a => Read (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Methods

readsPrec :: Int -> ReadS (ZipList a)

readList :: ReadS [ZipList a]

readPrec :: ReadPrec (ZipList a)

readListPrec :: ReadPrec [ZipList a]

Show a => Show (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Methods

showsPrec :: Int -> ZipList a -> ShowS

show :: ZipList a -> String

showList :: [ZipList a] -> ShowS

Generic (ZipList a)

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep (ZipList a) :: Type -> Type

Methods

from :: ZipList a -> Rep (ZipList a) x

to :: Rep (ZipList a) x -> ZipList a

NFData a => NFData (ZipList a)

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: ZipList a -> ()

Generic1 ZipList

Since: base-4.7.0.0

Defined in Control.Applicative

Associated Types

type Rep1 ZipList :: k -> Type

Methods

from1 :: forall (a :: k). ZipList a -> Rep1 ZipList a

to1 :: forall (a :: k). Rep1 ZipList a -> ZipList a

type Rep (ZipList a)

Defined in Control.Applicative

type Rep (ZipList a) = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [a])))

type Item (ZipList a)

Defined in GHC.Exts

type Item (ZipList a) = a

type Rep1 ZipList

Defined in Control.Applicative

type Rep1 ZipList = D1 ('MetaData "ZipList" "Control.Applicative" "base" 'True) (C1 ('MetaCons "ZipList" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 [])))

newtype Const a (b :: k)

The Const functor.

Constructors

Const

Fields

• getConst :: a

Instances

Generic1 (Const a :: k -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Associated Types

type Rep1 (Const a) :: k -> Type

Methods

from1 :: forall (a0 :: k0). Const a a0 -> Rep1 (Const a) a0

to1 :: forall (a0 :: k0). Rep1 (Const a) a0 -> Const a a0

Unbox a => Vector Vector (Const a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> m (Vector (Const a b))

basicUnsafeThaw :: PrimMonad m => Vector (Const a b) -> m (Mutable Vector (PrimState m) (Const a b))

basicLength :: Vector (Const a b) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Const a b) -> Vector (Const a b)

basicUnsafeIndexM :: Monad m => Vector (Const a b) -> Int -> m (Const a b)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Const a b) -> Vector (Const a b) -> m ()

elemseq :: Vector (Const a b) -> Const a b -> b0 -> b0

Unbox a => MVector MVector (Const a b)

Defined in Data.Vector.Unboxed.Base

Methods

basicLength :: MVector s (Const a b) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Const a b) -> MVector s (Const a b)

basicOverlaps :: MVector s (Const a b) -> MVector s (Const a b) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Const a b))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Const a b) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Const a b -> m (MVector (PrimState m) (Const a b))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (Const a b)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> Const a b -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Const a b) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Const a b) -> Const a b -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Const a b) -> MVector (PrimState m) (Const a b) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Const a b) -> Int -> m (MVector (PrimState m) (Const a b))

ToJSON2 (Const :: Type -> Type -> Type)

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> Const a b -> Value

liftToJSONList2 :: (a -> Value) -> ([a] -> Value) -> (b -> Value) -> ([b] -> Value) -> [Const a b] -> Value

liftToEncoding2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> Const a b -> Encoding

liftToEncodingList2 :: (a -> Encoding) -> ([a] -> Encoding) -> (b -> Encoding) -> ([b] -> Encoding) -> [Const a b] -> Encoding

FromJSON2 (Const :: Type -> Type -> Type)

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser (Const a b)

liftParseJSONList2 :: (Value -> Parser a) -> (Value -> Parser [a]) -> (Value -> Parser b) -> (Value -> Parser [b]) -> Value -> Parser [Const a b]

Bifunctor (Const :: Type -> Type -> Type)

Since: base-4.8.0.0

Defined in Data.Bifunctor

Methods

bimap :: (a -> b) -> (c -> d) -> Const a c -> Const b d

first :: (a -> b) -> Const a c -> Const b c

second :: (b -> c) -> Const a b -> Const a c

Bifoldable (Const :: Type -> Type -> Type)

Since: base-4.10.0.0

Defined in Data.Bifoldable

Methods

bifold :: Monoid m => Const m m -> m

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Const a b -> m

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Const a b -> c

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Const a b -> c

Eq2 (Const :: Type -> Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const a c -> Const b d -> Bool

Ord2 (Const :: Type -> Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const a c -> Const b d -> Ordering

Read2 (Const :: Type -> Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const a b)

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const a b]

liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Const a b)

liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Const a b]

Show2 (Const :: Type -> Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const a b] -> ShowS

Biapplicative (Const :: Type -> Type -> Type)

Defined in Data.Biapplicative

Methods

bipure :: a -> b -> Const a b

(<<*>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d

biliftA2 :: (a -> b -> c) -> (d -> e -> f) -> Const a d -> Const b e -> Const c f

(*>>) :: Const a b -> Const c d -> Const c d

(<<*) :: Const a b -> Const c d -> Const a b

NFData2 (Const :: Type -> Type -> Type)

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf2 :: (a -> ()) -> (b -> ()) -> Const a b -> ()

Hashable2 (Const :: Type -> Type -> Type)

Defined in Data.Hashable.Class

Methods

liftHashWithSalt2 :: (Int -> a -> Int) -> (Int -> b -> Int) -> Int -> Const a b -> Int

Bifoldable1 (Const :: Type -> Type -> Type)

Defined in Data.Semigroup.Foldable.Class

Methods

bifold1 :: Semigroup m => Const m m -> m

bifoldMap1 :: Semigroup m => (a -> m) -> (b -> m) -> Const a b -> m

Biapply (Const :: Type -> Type -> Type)

Defined in Data.Functor.Bind.Class

Methods

(<<.>>) :: Const (a -> b) (c -> d) -> Const a c -> Const b d

(.>>) :: Const a b -> Const c d -> Const c d

(<<.) :: Const a b -> Const c d -> Const a b

Functor (Const m :: Type -> Type)

Since: base-2.1

Defined in Data.Functor.Const

Methods

fmap :: (a -> b) -> Const m a -> Const m b

(<$) :: a -> Const m b -> Const m a

Monoid m => Applicative (Const m :: Type -> Type)

Since: base-2.0.1

Defined in Data.Functor.Const

Methods

pure :: a -> Const m a

(<*>) :: Const m (a -> b) -> Const m a -> Const m b

liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c

(*>) :: Const m a -> Const m b -> Const m b

(<*) :: Const m a -> Const m b -> Const m a

Foldable (Const m :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Functor.Const

Methods

fold :: Monoid m0 => Const m m0 -> m0

foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0

foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0

foldr :: (a -> b -> b) -> b -> Const m a -> b

foldr' :: (a -> b -> b) -> b -> Const m a -> b

foldl :: (b -> a -> b) -> b -> Const m a -> b

foldl' :: (b -> a -> b) -> b -> Const m a -> b

foldr1 :: (a -> a -> a) -> Const m a -> a

foldl1 :: (a -> a -> a) -> Const m a -> a

toList :: Const m a -> [a]

null :: Const m a -> Bool

length :: Const m a -> Int

elem :: Eq a => a -> Const m a -> Bool

maximum :: Ord a => Const m a -> a

minimum :: Ord a => Const m a -> a

sum :: Num a => Const m a -> a

product :: Num a => Const m a -> a

Traversable (Const m :: Type -> Type)

Since: base-4.7.0.0

Defined in Data.Traversable

Methods

traverse :: Applicative f => (a -> f b) -> Const m a -> f (Const m b)

sequenceA :: Applicative f => Const m (f a) -> f (Const m a)

mapM :: Monad m0 => (a -> m0 b) -> Const m a -> m0 (Const m b)

sequence :: Monad m0 => Const m (m0 a) -> m0 (Const m a)

ToJSON a => ToJSON1 (Const a :: Type -> Type)

Defined in Data.Aeson.Types.ToJSON

Methods

liftToJSON :: (a0 -> Value) -> ([a0] -> Value) -> Const a a0 -> Value

liftToJSONList :: (a0 -> Value) -> ([a0] -> Value) -> [Const a a0] -> Value

liftToEncoding :: (a0 -> Encoding) -> ([a0] -> Encoding) -> Const a a0 -> Encoding

liftToEncodingList :: (a0 -> Encoding) -> ([a0] -> Encoding) -> [Const a a0] -> Encoding

FromJSON a => FromJSON1 (Const a :: Type -> Type)

Defined in Data.Aeson.Types.FromJSON

Methods

liftParseJSON :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser (Const a a0)

liftParseJSONList :: (Value -> Parser a0) -> (Value -> Parser [a0]) -> Value -> Parser [Const a a0]

Contravariant (Const a :: Type -> Type)

Defined in Data.Functor.Contravariant

Methods

contramap :: (a0 -> b) -> Const a b -> Const a a0

(>$) :: b -> Const a b -> Const a a0

Eq a => Eq1 (Const a :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftEq :: (a0 -> b -> Bool) -> Const a a0 -> Const a b -> Bool

Ord a => Ord1 (Const a :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftCompare :: (a0 -> b -> Ordering) -> Const a a0 -> Const a b -> Ordering

Read a => Read1 (Const a :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Const a a0)

liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Const a a0]

liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Const a a0)

liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Const a a0]

Show a => Show1 (Const a :: Type -> Type)

Since: base-4.9.0.0

Defined in Data.Functor.Classes

Methods

liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> Const a a0 -> ShowS

liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [Const a a0] -> ShowS

NFData a => NFData1 (Const a :: Type -> Type)

Since: deepseq-1.4.3.0

Defined in Control.DeepSeq

Methods

liftRnf :: (a0 -> ()) -> Const a a0 -> ()

Hashable a => Hashable1 (Const a :: Type -> Type)

Defined in Data.Hashable.Class

Methods

liftHashWithSalt :: (Int -> a0 -> Int) -> Int -> Const a a0 -> Int

Semigroup m => Apply (Const m :: Type -> Type)

A Const m is not Applicative unless its m is a Monoid, but it is an instance of Apply

Defined in Data.Functor.Bind.Class

Methods

(<.>) :: Const m (a -> b) -> Const m a -> Const m b

(.>) :: Const m a -> Const m b -> Const m b

(<.) :: Const m a -> Const m b -> Const m a

liftF2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c

Bounded a => Bounded (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

minBound :: Const a b

maxBound :: Const a b

Enum a => Enum (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

succ :: Const a b -> Const a b

pred :: Const a b -> Const a b

toEnum :: Int -> Const a b

fromEnum :: Const a b -> Int

enumFrom :: Const a b -> [Const a b]

enumFromThen :: Const a b -> Const a b -> [Const a b]

enumFromTo :: Const a b -> Const a b -> [Const a b]

enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b]

Eq a => Eq (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

(==) :: Const a b -> Const a b -> Bool

(/=) :: Const a b -> Const a b -> Bool

Floating a => Floating (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

pi :: Const a b

exp :: Const a b -> Const a b

log :: Const a b -> Const a b

sqrt :: Const a b -> Const a b

(**) :: Const a b -> Const a b -> Const a b

logBase :: Const a b -> Const a b -> Const a b

sin :: Const a b -> Const a b

cos :: Const a b -> Const a b

tan :: Const a b -> Const a b

asin :: Const a b -> Const a b

acos :: Const a b -> Const a b

atan :: Const a b -> Const a b

sinh :: Const a b -> Const a b

cosh :: Const a b -> Const a b

tanh :: Const a b -> Const a b

asinh :: Const a b -> Const a b

acosh :: Const a b -> Const a b

atanh :: Const a b -> Const a b

log1p :: Const a b -> Const a b

expm1 :: Const a b -> Const a b

log1pexp :: Const a b -> Const a b

log1mexp :: Const a b -> Const a b

Fractional a => Fractional (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

(/) :: Const a b -> Const a b -> Const a b

recip :: Const a b -> Const a b

fromRational :: Rational -> Const a b

Integral a => Integral (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

quot :: Const a b -> Const a b -> Const a b

rem :: Const a b -> Const a b -> Const a b

div :: Const a b -> Const a b -> Const a b

mod :: Const a b -> Const a b -> Const a b

quotRem :: Const a b -> Const a b -> (Const a b, Const a b)

divMod :: Const a b -> Const a b -> (Const a b, Const a b)

toInteger :: Const a b -> Integer

Num a => Num (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

(+) :: Const a b -> Const a b -> Const a b

(-) :: Const a b -> Const a b -> Const a b

(*) :: Const a b -> Const a b -> Const a b

negate :: Const a b -> Const a b

abs :: Const a b -> Const a b

signum :: Const a b -> Const a b

fromInteger :: Integer -> Const a b

Ord a => Ord (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

compare :: Const a b -> Const a b -> Ordering

(<) :: Const a b -> Const a b -> Bool

(<=) :: Const a b -> Const a b -> Bool

(>) :: Const a b -> Const a b -> Bool

(>=) :: Const a b -> Const a b -> Bool

max :: Const a b -> Const a b -> Const a b

min :: Const a b -> Const a b -> Const a b

Read a => Read (Const a b)

This instance would be equivalent to the derived instances of the Const newtype if the getConst field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Const

Methods

readsPrec :: Int -> ReadS (Const a b)

readList :: ReadS [Const a b]

readPrec :: ReadPrec (Const a b)

readListPrec :: ReadPrec [Const a b]

Real a => Real (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

toRational :: Const a b -> Rational

RealFloat a => RealFloat (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

floatRadix :: Const a b -> Integer

floatDigits :: Const a b -> Int

floatRange :: Const a b -> (Int, Int)

decodeFloat :: Const a b -> (Integer, Int)

encodeFloat :: Integer -> Int -> Const a b

exponent :: Const a b -> Int

significand :: Const a b -> Const a b

scaleFloat :: Int -> Const a b -> Const a b

isNaN :: Const a b -> Bool

isInfinite :: Const a b -> Bool

isDenormalized :: Const a b -> Bool

isNegativeZero :: Const a b -> Bool

isIEEE :: Const a b -> Bool

atan2 :: Const a b -> Const a b -> Const a b

RealFrac a => RealFrac (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

properFraction :: Integral b0 => Const a b -> (b0, Const a b)

truncate :: Integral b0 => Const a b -> b0

round :: Integral b0 => Const a b -> b0

ceiling :: Integral b0 => Const a b -> b0

floor :: Integral b0 => Const a b -> b0

Show a => Show (Const a b)

This instance would be equivalent to the derived instances of the Const newtype if the getConst field were removed

Since: base-4.8.0.0

Defined in Data.Functor.Const

Methods

showsPrec :: Int -> Const a b -> ShowS

show :: Const a b -> String

showList :: [Const a b] -> ShowS

Ix a => Ix (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

range :: (Const a b, Const a b) -> [Const a b]

index :: (Const a b, Const a b) -> Const a b -> Int

unsafeIndex :: (Const a b, Const a b) -> Const a b -> Int

inRange :: (Const a b, Const a b) -> Const a b -> Bool

rangeSize :: (Const a b, Const a b) -> Int

unsafeRangeSize :: (Const a b, Const a b) -> Int

IsString a => IsString (Const a b)

Since: base-4.9.0.0

Defined in Data.String

Methods

fromString :: String -> Const a b

Generic (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Associated Types

type Rep (Const a b) :: Type -> Type

Methods

from :: Const a b -> Rep (Const a b) x

to :: Rep (Const a b) x -> Const a b

Semigroup a => Semigroup (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

(<>) :: Const a b -> Const a b -> Const a b

sconcat :: NonEmpty (Const a b) -> Const a b

stimes :: Integral b0 => b0 -> Const a b -> Const a b

Monoid a => Monoid (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

mempty :: Const a b

mappend :: Const a b -> Const a b -> Const a b

mconcat :: [Const a b] -> Const a b

NFData a => NFData (Const a b)

Since: deepseq-1.4.0.0

Defined in Control.DeepSeq

Methods

rnf :: Const a b -> ()

Hashable a => Hashable (Const a b)

Defined in Data.Hashable.Class

Methods

hashWithSalt :: Int -> Const a b -> Int

hash :: Const a b -> Int

ToJSON a => ToJSON (Const a b)

Defined in Data.Aeson.Types.ToJSON

Methods

toJSON :: Const a b -> Value

toEncoding :: Const a b -> Encoding

toJSONList :: [Const a b] -> Value

toEncodingList :: [Const a b] -> Encoding

(ToJSON a, ToJSONKey a) => ToJSONKey (Const a b)

Defined in Data.Aeson.Types.ToJSON

Methods

toJSONKey :: ToJSONKeyFunction (Const a b)

toJSONKeyList :: ToJSONKeyFunction [Const a b]

FromJSON a => FromJSON (Const a b)

Defined in Data.Aeson.Types.FromJSON

Methods

parseJSON :: Value -> Parser (Const a b)

parseJSONList :: Value -> Parser [Const a b]

(FromJSON a, FromJSONKey a) => FromJSONKey (Const a b)

Defined in Data.Aeson.Types.FromJSON

Methods

fromJSONKey :: FromJSONKeyFunction (Const a b)

fromJSONKeyList :: FromJSONKeyFunction [Const a b]

Storable a => Storable (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

sizeOf :: Const a b -> Int

alignment :: Const a b -> Int

peekElemOff :: Ptr (Const a b) -> Int -> IO (Const a b)

pokeElemOff :: Ptr (Const a b) -> Int -> Const a b -> IO ()

peekByteOff :: Ptr b0 -> Int -> IO (Const a b)

pokeByteOff :: Ptr b0 -> Int -> Const a b -> IO ()

peek :: Ptr (Const a b) -> IO (Const a b)

poke :: Ptr (Const a b) -> Const a b -> IO ()

Bits a => Bits (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

(.&.) :: Const a b -> Const a b -> Const a b

(.|.) :: Const a b -> Const a b -> Const a b

xor :: Const a b -> Const a b -> Const a b

complement :: Const a b -> Const a b

shift :: Const a b -> Int -> Const a b

rotate :: Const a b -> Int -> Const a b

zeroBits :: Const a b

bit :: Int -> Const a b

setBit :: Const a b -> Int -> Const a b

clearBit :: Const a b -> Int -> Const a b

complementBit :: Const a b -> Int -> Const a b

testBit :: Const a b -> Int -> Bool

bitSizeMaybe :: Const a b -> Maybe Int

bitSize :: Const a b -> Int

isSigned :: Const a b -> Bool

shiftL :: Const a b -> Int -> Const a b

unsafeShiftL :: Const a b -> Int -> Const a b

shiftR :: Const a b -> Int -> Const a b

unsafeShiftR :: Const a b -> Int -> Const a b

rotateL :: Const a b -> Int -> Const a b

rotateR :: Const a b -> Int -> Const a b

popCount :: Const a b -> Int

FiniteBits a => FiniteBits (Const a b)

Since: base-4.9.0.0

Defined in Data.Functor.Const

Methods

finiteBitSize :: Const a b -> Int

countLeadingZeros :: Const a b -> Int

countTrailingZeros :: Const a b -> Int

Prim a => Prim (Const a b)

Since: primitive-0.6.5.0

Defined in Data.Primitive.Types

Methods

sizeOf# :: Const a b -> Int#

alignment# :: Const a b -> Int#

indexByteArray# :: ByteArray# -> Int# -> Const a b

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (# State# s, Const a b #)

writeByteArray# :: MutableByteArray# s -> Int# -> Const a b -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Const a b -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Const a b

readOffAddr# :: Addr# -> Int# -> State# s -> (# State# s, Const a b #)

writeOffAddr# :: Addr# -> Int# -> Const a b -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Const a b -> State# s -> State# s

Unbox a => Unbox (Const a b)

Defined in Data.Vector.Unboxed.Base

type Rep1 (Const a :: k -> Type)

Defined in Data.Functor.Const

type Rep1 (Const a :: k -> Type) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

newtype MVector s (Const a b)

Defined in Data.Vector.Unboxed.Base

newtype MVector s (Const a b) = MV_Const (MVector s a)

type Rep (Const a b)

Defined in Data.Functor.Const

type Rep (Const a b) = D1 ('MetaData "Const" "Data.Functor.Const" "base" 'True) (C1 ('MetaCons "Const" 'PrefixI 'True) (S1 ('MetaSel ('Just "getConst") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

newtype Vector (Const a b)

Defined in Data.Vector.Unboxed.Base

newtype Vector (Const a b) = V_Const (Vector a)

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d

Lift a ternary function to actions.

Using ApplicativeDo: 'liftA3 f as bs cs' can be understood as the do expression

do a <- as
   b <- bs
   c <- cs
   pure (f a b c)

liftA :: Applicative f => (a -> b) -> f a -> f b

Lift a function to actions. This function may be used as a value for fmap in a Functor instance.

| Using ApplicativeDo: 'liftA f as' can be understood as the do expression

do a <- as
   pure (f a)

with an inferred Functor constraint, weaker than Applicative.

(<**>) :: Applicative f => f a -> f (a -> b) -> f b infixl 4

A variant of <*> with the arguments reversed.

Using ApplicativeDo: 'as <**> fs' can be understood as the do expression

do a <- as
   f <- fs
   pure (f a)

renderFailure :: ParserFailure ParserHelp -> String -> (String, ExitCode)

parserFailure :: ParserPrefs -> ParserInfo a -> ParseError -> [Context] -> ParserFailure ParserHelp

Generate a ParserFailure from a ParseError in a given Context.

This function can be used, for example, to show the help text for a parser:

handleParseResult . Failure $ parserFailure pprefs pinfo ShowHelpText mempty

execParserPure

Arguments

:: ParserPrefs

Global preferences for this parser

-> ParserInfo a

Description of the program to run

-> [String]

Program arguments

-> ParserResult a

The most general way to run a program description in pure code.

getParseResult :: ParserResult a -> Maybe a

Extract the actual result from a ParserResult value.

This function returns Nothing in case of errors. Possible error messages or completion actions are simply discarded.

If you want to display error messages and invoke completion actions appropriately, use handleParseResult instead.

handleParseResult :: ParserResult a -> IO a

Handle ParserResult.

customExecParser :: ParserPrefs -> ParserInfo a -> IO a

Run a program description with custom preferences.

execParser :: ParserInfo a -> IO a

Run a program description.

Parse command line arguments. Display help text and exit if any parse error occurs.

hsubparser :: Mod CommandFields a -> Parser a

Builder for a command parser with a "helper" option attached. Used in the same way as subparser, but includes a "--help|-h" inside the subcommand.

helper :: Parser (a -> a)

A hidden "helper" option which always fails.

A common usage pattern is to apply this applicatively when creating a ParserInfo

opts :: ParserInfo Sample
opts = info (sample <**> helper) mempty

defaultPrefs :: ParserPrefs

Default preferences.

idm :: Monoid m => m

Trivial option modifier.

prefs :: PrefsMod -> ParserPrefs

Create a ParserPrefs given a modifier

helpShowGlobals :: PrefsMod

Show global help information in subparser usage

helpLongEquals :: PrefsMod

Show equals sign, rather than space, in usage and help text for options with long names.

columns :: Int -> PrefsMod

Set the maximum width of the generated help text.

subparserInline :: PrefsMod

Allow full mixing of subcommand and parent arguments by inlining selected subparsers into the parent parser.

NOTE: When this option is used, preferences for the subparser which effect the parser behaviour (such as noIntersperse) are ignored.

noBacktrack :: PrefsMod

Turn off backtracking after subcommand is parsed.

showHelpOnEmpty :: PrefsMod

Show the help text if the user enters only the program name or subcommand.

This will suppress a "Missing:" error and show the full usage instead if a user just types the name of the program.

showHelpOnError :: PrefsMod

Show full help text on any error.

disambiguate :: PrefsMod

Turn on disambiguation.

See https://github.com/pcapriotti/optparse-applicative#disambiguation

multiSuffix :: String -> PrefsMod

Include a suffix to attach to the metavar when multiple values can be entered.

info :: Parser a -> InfoMod a -> ParserInfo a

Create a ParserInfo given a Parser and a modifier.

forwardOptions :: InfoMod a

Intersperse matched options and arguments normally, but allow unmatched options to be treated as positional arguments. This is sometimes useful if one is wrapping a third party cli tool and needs to pass options through, while also providing a handful of their own options. Not recommended in general as typos by the user may not yield a parse error and cause confusion.

noIntersperse :: InfoMod a

Disable parsing of regular options after arguments. After a positional argument is parsed, all remaining options and arguments will be treated as a positional arguments. Not recommended in general as users often expect to be able to freely intersperse regular options and flags within command line options.

failureCode :: Int -> InfoMod a

Specify an exit code if a parse error occurs.

progDescDoc :: Maybe Doc -> InfoMod a

Specify a short program description as a Doc value.

progDesc :: String -> InfoMod a

Specify a short program description.

footerDoc :: Maybe Doc -> InfoMod a

Specify a footer for this parser as a Doc value.

footer :: String -> InfoMod a

Specify a footer for this parser.

headerDoc :: Maybe Doc -> InfoMod a

Specify a header for this parser as a Doc value.

header :: String -> InfoMod a

Specify a header for this parser.

briefDesc :: InfoMod a

Only show a brief description in the help text of this parser.

fullDesc :: InfoMod a

Show a full description in the help text of this parser.

option :: ReadM a -> Mod OptionFields a -> Parser a

Builder for an option using the given reader.

This is a regular option, and should always have either a long or short name specified in the modifiers (or both).

nameParser = option str ( long "name" <> short 'n' )

strOption :: IsString s => Mod OptionFields s -> Parser s

Builder for an option taking a String argument.

infoOption :: String -> Mod OptionFields (a -> a) -> Parser (a -> a)

An option that always fails and displays a message.

abortOption :: ParseError -> Mod OptionFields (a -> a) -> Parser (a -> a)

An option that always fails.

When this option is encountered, the option parser immediately aborts with the given parse error. If you simply want to output a message, use infoOption instead.

switch :: Mod FlagFields Bool -> Parser Bool

Builder for a boolean flag.

Note: Because this parser will never fail, it can not be used with combinators such as some or many, as these combinators continue until a failure occurs. See flag'.

switch = flag False True

flag'

Arguments

:: a

active value

-> Mod FlagFields a

option modifier

-> Parser a

Builder for a flag parser without a default value.

Same as flag, but with no default value. In particular, this flag will never parse successfully by itself.

It still makes sense to use it as part of a composite parser. For example

length <$> many (flag' () (short 't'))

is a parser that counts the number of "-t" arguments on the command line, alternatively

flag' True (long "on") <|> flag' False (long "off")

will require the user to enter '--on' or '--off' on the command line.

flag

Arguments

:: a

default value

-> a

active value

-> Mod FlagFields a

option modifier

-> Parser a

Builder for a flag parser.

A flag that switches from a "default value" to an "active value" when encountered. For a simple boolean value, use switch instead.

Note: Because this parser will never fail, it can not be used with combinators such as some or many, as these combinators continue until a failure occurs. See flag'.

strArgument :: IsString s => Mod ArgumentFields s -> Parser s

Builder for a String argument.

argument :: ReadM a -> Mod ArgumentFields a -> Parser a

Builder for an argument parser.

subparser :: Mod CommandFields a -> Parser a

Builder for a command parser. The command modifier can be used to specify individual commands.

completer :: forall (f :: Type -> Type) a. HasCompleter f => Completer -> Mod f a

Add a completer to an argument.

A completer is a function String -> IO String which, given a partial argument, returns all possible completions for that argument.

action :: forall (f :: Type -> Type) a. HasCompleter f => String -> Mod f a

Add a bash completion action. Common actions include file and directory. See http://www.gnu.org/software/bash/manual/html_node/Programmable-Completion-Builtins.html#Programmable-Completion-Builtins for a complete list.

completeWith :: forall (f :: Type -> Type) a. HasCompleter f => [String] -> Mod f a

Add a list of possible completion values.

commandGroup :: String -> Mod CommandFields a

Add a description to a group of commands.

Advanced feature for separating logical groups of commands on the parse line.

If using the same metavar for each group of commands, it may yield a more attractive usage text combined with hidden for some groups.

command :: String -> ParserInfo a -> Mod CommandFields a

Add a command to a subparser option.

Suggested usage for multiple commands is to add them to a single subparser. e.g.

sample :: Parser Sample
sample = subparser
       ( command "hello"
         (info hello (progDesc "Print greeting"))
      <> command "goodbye"
         (info goodbye (progDesc "Say goodbye"))
       )

style :: forall (f :: Type -> Type) a. (Doc -> Doc) -> Mod f a

Apply a function to the option description in the usage text.

import Options.Applicative.Help
flag' () (short 't' <> style bold)

NOTE: This builder is more flexible than its name and example allude. One of the motivating examples for its addition was to used const to completely replace the usage text of an option.

hidden :: forall (f :: Type -> Type) a. Mod f a

Hide this option from the brief description.

Use internal to hide the option from the help text too.

metavar :: forall (f :: Type -> Type) a. HasMetavar f => String -> Mod f a

Specify a metavariable for the argument.

Metavariables have no effect on the actual parser, and only serve to specify the symbolic name for an argument to be displayed in the help text.

noArgError :: ParseError -> Mod OptionFields a

Specify the error to display when no argument is provided to this option.

helpDoc :: forall (f :: Type -> Type) a. Maybe Doc -> Mod f a

Specify the help text for an option as a Doc value.

help :: forall (f :: Type -> Type) a. String -> Mod f a

Specify the help text for an option.

showDefault :: forall a (f :: Type -> Type). Show a => Mod f a

Show the default value for this option using its Show instance.

showDefaultWith :: forall a (f :: Type -> Type). (a -> String) -> Mod f a

Specify a function to show the default value for an option.

value :: forall (f :: Type -> Type) a. HasValue f => a -> Mod f a

Specify a default value for an option.

Note: Because this modifier means the parser will never fail, do not use it with combinators such as some or many, as these combinators continue until a failure occurs. Careless use will thus result in a hang.

To display the default value, combine with showDefault or showDefaultWith.

long :: forall (f :: Type -> Type) a. HasName f => String -> Mod f a

Specify a long name for an option.

short :: forall (f :: Type -> Type) a. HasName f => Char -> Mod f a

Specify a short name for an option.

disabled :: ReadM a

Null Option reader. All arguments will fail validation.

maybeReader :: (String -> Maybe a) -> ReadM a

Convert a function producing a Maybe into a reader.

eitherReader :: (String -> Either String a) -> ReadM a

Convert a function producing an Either into a reader.

As an example, one can create a ReadM from an attoparsec Parser easily with

import qualified Data.Attoparsec.Text as A
import qualified Data.Text as T
attoparsecReader :: A.Parser a -> ReadM a
attoparsecReader p = eitherReader (A.parseOnly p . T.pack)

str :: IsString s => ReadM s

String Option reader.

Polymorphic over the IsString type class since 0.14.

auto :: Read a => ReadM a

Option reader based on the Read type class.

data InfoMod a

Modifier for ParserInfo.

Instances

Semigroup (InfoMod a)

Defined in Options.Applicative.Builder

Methods

(<>) :: InfoMod a -> InfoMod a -> InfoMod a

sconcat :: NonEmpty (InfoMod a) -> InfoMod a

stimes :: Integral b => b -> InfoMod a -> InfoMod a

Monoid (InfoMod a)

Defined in Options.Applicative.Builder

Methods

mempty :: InfoMod a

mappend :: InfoMod a -> InfoMod a -> InfoMod a

mconcat :: [InfoMod a] -> InfoMod a

data PrefsMod

Instances

Semigroup PrefsMod

Defined in Options.Applicative.Builder

Methods

(<>) :: PrefsMod -> PrefsMod -> PrefsMod

sconcat :: NonEmpty PrefsMod -> PrefsMod

stimes :: Integral b => b -> PrefsMod -> PrefsMod

Monoid PrefsMod

Defined in Options.Applicative.Builder

Methods

mempty :: PrefsMod

mappend :: PrefsMod -> PrefsMod -> PrefsMod

mconcat :: [PrefsMod] -> PrefsMod

bashCompleter :: String -> Completer

Run a compgen completion action.

Common actions include file and directory. See http://www.gnu.org/software/bash/manual/html_node/Programmable-Completion-Builtins.html#Programmable-Completion-Builtins for a complete list.

listCompleter :: [String] -> Completer

Create a Completer from a constant list of strings.

listIOCompleter :: IO [String] -> Completer

Create a Completer from an IO action

internal :: forall (f :: Type -> Type) a. Mod f a

Hide this option completely from the help text

Use hidden if the option should remain visible in the full description.

data OptionFields a

Instances

HasName OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

name :: OptName -> OptionFields a -> OptionFields a

HasCompleter OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

modCompleter :: (Completer -> Completer) -> OptionFields a -> OptionFields a

HasValue OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

hasValueDummy :: OptionFields a -> ()

HasMetavar OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

hasMetavarDummy :: OptionFields a -> ()

data FlagFields a

Instances

HasName FlagFields

Defined in Options.Applicative.Builder.Internal

Methods

name :: OptName -> FlagFields a -> FlagFields a

data CommandFields a

Instances

HasMetavar CommandFields

Defined in Options.Applicative.Builder.Internal

Methods

hasMetavarDummy :: CommandFields a -> ()

data ArgumentFields a

Instances

HasCompleter ArgumentFields

Defined in Options.Applicative.Builder.Internal

Methods

modCompleter :: (Completer -> Completer) -> ArgumentFields a -> ArgumentFields a

HasValue ArgumentFields

Defined in Options.Applicative.Builder.Internal

Methods

hasValueDummy :: ArgumentFields a -> ()

HasMetavar ArgumentFields

Defined in Options.Applicative.Builder.Internal

Methods

hasMetavarDummy :: ArgumentFields a -> ()

class HasName (f :: Type -> Type)

Minimal complete definition

name

Instances

HasName OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

name :: OptName -> OptionFields a -> OptionFields a

HasName FlagFields

Defined in Options.Applicative.Builder.Internal

Methods

name :: OptName -> FlagFields a -> FlagFields a

class HasCompleter (f :: Type -> Type)

Minimal complete definition

modCompleter

Instances

HasCompleter OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

modCompleter :: (Completer -> Completer) -> OptionFields a -> OptionFields a

HasCompleter ArgumentFields

Defined in Options.Applicative.Builder.Internal

Methods

modCompleter :: (Completer -> Completer) -> ArgumentFields a -> ArgumentFields a

class HasValue (f :: Type -> Type)

Minimal complete definition

hasValueDummy

Instances

HasValue OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

hasValueDummy :: OptionFields a -> ()

HasValue ArgumentFields

Defined in Options.Applicative.Builder.Internal

Methods

hasValueDummy :: ArgumentFields a -> ()

class HasMetavar (f :: Type -> Type)

Minimal complete definition

hasMetavarDummy

Instances

HasMetavar OptionFields

Defined in Options.Applicative.Builder.Internal

Methods

hasMetavarDummy :: OptionFields a -> ()

HasMetavar CommandFields

Defined in Options.Applicative.Builder.Internal

Methods

hasMetavarDummy :: CommandFields a -> ()

HasMetavar ArgumentFields

Defined in Options.Applicative.Builder.Internal

Methods

hasMetavarDummy :: ArgumentFields a -> ()

data Mod (f :: Type -> Type) a

An option modifier.

Option modifiers are values that represent a modification of the properties of an option.

The type parameter a is the return type of the option, while f is a record containing its properties (e.g. OptionFields for regular options, FlagFields for flags, etc...).

An option modifier consists of 3 elements:

• A field modifier, of the form f a -> f a. These are essentially (compositions of) setters for some of the properties supported by f.
• An optional default value and function to display it.
• A property modifier, of the form OptProperties -> OptProperties. This is just like the field modifier, but for properties applicable to any option.

Modifiers are instances of Monoid, and can be composed as such.

One rarely needs to deal with modifiers directly, as most of the times it is sufficient to pass them to builders (such as strOption or flag) to create options (see Builder).

Instances

Semigroup (Mod f a)

Since: optparse-applicative-0.13.0.0

Defined in Options.Applicative.Builder.Internal

Methods

(<>) :: Mod f a -> Mod f a -> Mod f a

sconcat :: NonEmpty (Mod f a) -> Mod f a

stimes :: Integral b => b -> Mod f a -> Mod f a

Monoid (Mod f a)

Defined in Options.Applicative.Builder.Internal

Methods

mempty :: Mod f a

mappend :: Mod f a -> Mod f a -> Mod f a

mconcat :: [Mod f a] -> Mod f a

overFailure :: (ParserHelp -> ParserHelp) -> ParserResult a -> ParserResult a

mkCompleter :: (String -> IO [String]) -> Completer

Smart constructor for a Completer

readerError :: String -> ReadM a

Abort option reader by exiting with an error message.

readerAbort :: ParseError -> ReadM a

Abort option reader by exiting with a ParseError.

data ParseError

Constructors

ErrorMsg String

InfoMsg String

ShowHelpText (Maybe String)

UnknownError

MissingError IsCmdStart SomeParser

ExpectsArgError String

UnexpectedError String SomeParser

Instances

Semigroup ParseError

Defined in Options.Applicative.Types

Methods

(<>) :: ParseError -> ParseError -> ParseError

sconcat :: NonEmpty ParseError -> ParseError

stimes :: Integral b => b -> ParseError -> ParseError

Monoid ParseError

Defined in Options.Applicative.Types

Methods

mempty :: ParseError

mappend :: ParseError -> ParseError -> ParseError

mconcat :: [ParseError] -> ParseError

data ParserInfo a

A full description for a runnable Parser for a program.

Constructors

ParserInfo

Fields

• infoParser :: Parser a

  the option parser for the program

• infoFullDesc :: Bool

  whether the help text should contain full documentation

• infoProgDesc :: Chunk Doc

  brief parser description

• infoHeader :: Chunk Doc

  header of the full parser description

• infoFooter :: Chunk Doc

  footer of the full parser description

• infoFailureCode :: Int

  exit code for a parser failure

• infoPolicy :: ArgPolicy

  allow regular options and flags to occur after arguments (default: InterspersePolicy)

Instances

Functor ParserInfo

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ParserInfo a -> ParserInfo b

(<$) :: a -> ParserInfo b -> ParserInfo a

data ParserPrefs

Global preferences for a top-level Parser.

Constructors

ParserPrefs

Fields

• prefMultiSuffix :: String

  metavar suffix for multiple options

• prefDisambiguate :: Bool

  automatically disambiguate abbreviations (default: False)

• prefShowHelpOnError :: Bool

  always show help text on parse errors (default: False)

• prefShowHelpOnEmpty :: Bool

  show the help text for a command or subcommand if it fails with no input (default: False)

• prefBacktrack :: Backtracking

  backtrack to parent parser when a subcommand fails (default: Backtrack)

• prefColumns :: Int

  number of columns in the terminal, used to format the help page (default: 80)

• prefHelpLongEquals :: Bool

  when displaying long names in usage and help, use an '=' sign for long names, rather than a single space (default: False)

• prefHelpShowGlobal :: Bool

  when displaying subparsers' usage help, show parent options under a "global options" section (default: True)

Instances

Eq ParserPrefs

Defined in Options.Applicative.Types

Methods

(==) :: ParserPrefs -> ParserPrefs -> Bool

(/=) :: ParserPrefs -> ParserPrefs -> Bool

Show ParserPrefs

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> ParserPrefs -> ShowS

show :: ParserPrefs -> String

showList :: [ParserPrefs] -> ShowS

data ReadM a

A newtype over 'ReaderT String Except', used by option readers.

Instances

Monad ReadM

Defined in Options.Applicative.Types

Methods

(>>=) :: ReadM a -> (a -> ReadM b) -> ReadM b

(>>) :: ReadM a -> ReadM b -> ReadM b

return :: a -> ReadM a

Functor ReadM

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ReadM a -> ReadM b

(<$) :: a -> ReadM b -> ReadM a

MonadFail ReadM

Defined in Options.Applicative.Types

Methods

fail :: String -> ReadM a

Applicative ReadM

Defined in Options.Applicative.Types

Methods

pure :: a -> ReadM a

(<*>) :: ReadM (a -> b) -> ReadM a -> ReadM b

liftA2 :: (a -> b -> c) -> ReadM a -> ReadM b -> ReadM c

(*>) :: ReadM a -> ReadM b -> ReadM b

(<*) :: ReadM a -> ReadM b -> ReadM a

MonadPlus ReadM

Defined in Options.Applicative.Types

Methods

mzero :: ReadM a

mplus :: ReadM a -> ReadM a -> ReadM a

Alternative ReadM

Defined in Options.Applicative.Types

Methods

empty :: ReadM a

(<|>) :: ReadM a -> ReadM a -> ReadM a

some :: ReadM a -> ReadM [a]

many :: ReadM a -> ReadM [a]

data Completer

A shell complete function.

Instances

Semigroup Completer

Defined in Options.Applicative.Types

Methods

(<>) :: Completer -> Completer -> Completer

sconcat :: NonEmpty Completer -> Completer

stimes :: Integral b => b -> Completer -> Completer

Monoid Completer

Defined in Options.Applicative.Types

Methods

mempty :: Completer

mappend :: Completer -> Completer -> Completer

mconcat :: [Completer] -> Completer

newtype CompletionResult

Constructors

CompletionResult

Fields

• execCompletion :: String -> IO String

Instances

Show CompletionResult

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> CompletionResult -> ShowS

show :: CompletionResult -> String

showList :: [CompletionResult] -> ShowS

newtype ParserFailure h

Constructors

ParserFailure

Fields

• execFailure :: String -> (h, ExitCode, Int)

Instances

Functor ParserFailure

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ParserFailure a -> ParserFailure b

(<$) :: a -> ParserFailure b -> ParserFailure a

Show h => Show (ParserFailure h)

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> ParserFailure h -> ShowS

show :: ParserFailure h -> String

showList :: [ParserFailure h] -> ShowS

data ParserResult a

Result of execParserPure.

Constructors

Failure (ParserFailure ParserHelp)

CompletionInvoked CompletionResult

Instances

Monad ParserResult

Defined in Options.Applicative.Types

Methods

(>>=) :: ParserResult a -> (a -> ParserResult b) -> ParserResult b

(>>) :: ParserResult a -> ParserResult b -> ParserResult b

return :: a -> ParserResult a

Functor ParserResult

Defined in Options.Applicative.Types

Methods

fmap :: (a -> b) -> ParserResult a -> ParserResult b

(<$) :: a -> ParserResult b -> ParserResult a

Applicative ParserResult

Defined in Options.Applicative.Types

Methods

pure :: a -> ParserResult a

(<*>) :: ParserResult (a -> b) -> ParserResult a -> ParserResult b

liftA2 :: (a -> b -> c) -> ParserResult a -> ParserResult b -> ParserResult c

(*>) :: ParserResult a -> ParserResult b -> ParserResult b

(<*) :: ParserResult a -> ParserResult b -> ParserResult a

Show a => Show (ParserResult a)

Defined in Options.Applicative.Types

Methods

showsPrec :: Int -> ParserResult a -> ShowS

show :: ParserResult a -> String

showList :: [ParserResult a] -> ShowS

data ParserHelp

Constructors

ParserHelp

Fields

• helpError :: Chunk Doc
• helpSuggestions :: Chunk Doc
• helpHeader :: Chunk Doc
• helpUsage :: Chunk Doc
• helpBody :: Chunk Doc
• helpGlobals :: Chunk Doc
• helpFooter :: Chunk Doc

Instances

Show ParserHelp

Defined in Options.Applicative.Help.Types

Methods

showsPrec :: Int -> ParserHelp -> ShowS

show :: ParserHelp -> String

showList :: [ParserHelp] -> ShowS

Semigroup ParserHelp

Defined in Options.Applicative.Help.Types

Methods

(<>) :: ParserHelp -> ParserHelp -> ParserHelp

sconcat :: NonEmpty ParserHelp -> ParserHelp

stimes :: Integral b => b -> ParserHelp -> ParserHelp

Monoid ParserHelp

Defined in Options.Applicative.Help.Types

Methods

mempty :: ParserHelp

mappend :: ParserHelp -> ParserHelp -> ParserHelp

mconcat :: [ParserHelp] -> ParserHelp