OptEnvConf.Parser

Parser API

setting :: HasCallStack => [Builder a] -> Parser a

settings are the building blocks of Parsers.

setting lets you put together different builders to define what to parse.

Here are some common examples:

• Argument

  setting
     [ help "Document your argument"
     , reader str -- The argument is a string
     , argument
     ] :: Parser String
  

• Switch

  setting
     [ help "Document your switch"
     , switch True -- The value of the switch when activated
     , long foo -- "--foo"
     , short f -- "-f"
     , value False -- The default value of the switch
     ] :: Parser Bool
  

• Option

  setting
     [ help "Document your option"
     , reader str -- The argument is a string
     , long foo -- "--foo"
     , short f -- "-f"
     , option
     ] :: Parser String
  

• Environment Variable

  setting
     [ help "Document your environment variable"
     , reader str -- The argument is a string
     , env FOO_BAR
     ] :: Parser String
  

• Configuration Value

  setting
     [ help "Document your configuration value"
     , conf "foo-bar"
     ] :: Parser String
  

• Some combination

  setting
     [ help "Document your configuration value"
     , conf "foo-bar"
     ] :: Parser String
  

  Note that parsing is always tried in this order when using a combined setting:

  1. Argument
  2. Switch
  3. Option
  4. Environment variable
  5. Configuration value

  (Hence the name of the package.)

filePathSetting :: HasCallStack => [Builder FilePath] -> Parser (Path Abs File)

A setting for Path Abs File.

This takes care of setting the reader to str, setting the metavar to FILE_PATH, autocompletion, and parsing the FilePath into a Path Abs File.

directoryPathSetting :: HasCallStack => [Builder FilePath] -> Parser (Path Abs Dir)

A setting for Path Abs dir.

This takes care of setting the reader to str, setting the metavar to DIRECTORY_PATH, autocompletion, and parsing the FilePath into a Path Abs Dir.

strOption :: HasCallStack => IsString string => [Builder string] -> Parser string

A setting with option, a reader set to str, and the metavar set to STR.

Note that you can override the metavar with another metavar in the given list of builders.

This function may help with easier migration from optparse-applicative.

strArgument :: HasCallStack => IsString string => [Builder string] -> Parser string

A setting with argument, a reader set to str, and the metavar set to STR.

Note that you can override the metavar with another metavar in the given list of builders.

This function may help with easier migration from optparse-applicative.

choice :: HasCallStack => [Parser a] -> Parser a

Try a list of parsers in order

mapIO :: HasCallStack => (a -> IO b) -> Parser a -> Parser b

Apply a computation to the result of a parser

This is intended for use-cases like resolving a file to an absolute path. It is morally ok for read-only IO actions but you will have a bad time if the action is not read-only.

runIO :: HasCallStack => IO a -> Parser a

Run an IO action without parsing anything

This action may be run more than once, so prefer to do IO outside of the parser.

checkEither :: HasCallStack => (a -> Either String b) -> Parser a -> Parser b

Like checkMapEither but without changing the type

checkMaybe :: HasCallStack => (a -> Maybe a) -> Parser a -> Parser a

Like checkMapMaybe but without changing the type

checkMapEither :: HasCallStack => (a -> Either String b) -> Parser a -> Parser b

Check a Parser after the fact, purely.

checkMapIO :: HasCallStack => (a -> IO (Either String b)) -> Parser a -> Parser b

Check a Parser after the fact, allowing IO.

checkMapMaybe :: HasCallStack => (a -> Maybe b) -> Parser a -> Parser b

Like checkMapEither but without a helpful error message.

Prefer checkMapEither.

checkMapEitherForgivable :: HasCallStack => (a -> Either String b) -> Parser a -> Parser b

Like checkMapEither, but allow trying the other side of any alternative if the result is Nothing.

checkMapIOForgivable :: HasCallStack => (a -> IO (Either String b)) -> Parser a -> Parser b

Like checkMapIO, but allow trying the other side of any alternative if the result is Nothing. TODO add a SRCLoc here

checkMapMaybeForgivable :: HasCallStack => (a -> Maybe b) -> Parser a -> Parser b

Like checkMapMaybe, but allow trying the other side of any alternative if the result is Nothing.

allOrNothing :: HasCallStack => Parser a -> Parser a

Parse either all or none of the parser below.

If you don't use this function, and only some of the settings below are defined, this parser will fail and the next alternative will be tried. If you do use this function, this parser will error unforgivably if at least one, but not all, of the settings below are defined.

If each setting has a corresponding forgivable error, consider this forgivable. Consider all other forgivable errors unforgivable

For example, the following will parser will fail intsead of succeed when given the arguments below:

( choice
    [ allOrNothing $
        (,)
          <$> setting [option, long "foo", reader auto, help "This one will exist", metavar "CHAR"]
          <*> setting [option, long "bar", reader auto, help "This one will not exist", metavar "CHAR"],
      pure ('a', 'b')
    ]
)

["--foo", "'a'"]

commands :: HasCallStack => [Command a] -> Parser a

Declare multiple commands

Use command to define a Command.

command

Arguments

:: HasCallStack

=> String

Name

-> String

Documentation

-> Parser a

Parser

-> Command a

Declare a single command with a name, documentation and parser

subArgs :: String -> Parser a -> Parser a

Prefix all longs and shorts with a given Value.

subArgs_ :: String -> Parser a -> Parser a

Helper function for calling subArgs with toArgCase and a - appended.

subArgs_ s = subArgs (toArgCase s <> "-")

subEnv :: String -> Parser a -> Parser a

Prefix all envs with a given Value.

subEnv_ :: String -> Parser a -> Parser a

Helper function for calling subEnv with toEnvCase and a '_' appended.

subEnv_ s = subEnv (toEnvCase s <> "_")

subConfig :: String -> Parser a -> Parser a

Prefix all confs with a given Value.

subConfig_ :: String -> Parser a -> Parser a

Helper function for calling subConfig with toConfigCase.

subConfig_ s = subConfig (toConfigCase s)

subAll :: String -> Parser a -> Parser a

Helper function for calling subArgs_, subEnv_ and subConfig_ with the same prefix.

subAll = subArgs_ prefix . subEnv_ prefix . subConfig_ prefix

subSettings :: HasCallStack => HasParser a => String -> Parser a

Use the settingsParser of a given type, but prefixed with a subAll and allOrNothing.

subSettings prefix = allOrNothing $ subAll prefix settingsParser

someNonEmpty :: Parser a -> Parser (NonEmpty a)

Like some but with a more accurate type

withConfig :: HasCallStack => Parser (Maybe Object) -> Parser a -> Parser a

Load a configuration value and use it for the given parser

withYamlConfig :: HasCallStack => Parser (Maybe (Path Abs File)) -> Parser a -> Parser a

Load a YAML config file and use it for the given parser

withFirstYamlConfig :: HasCallStack => Parser [Path Abs File] -> Parser a -> Parser a

Load the Yaml config in the first of the filepaths that points to something that exists.

withCombinedYamlConfigs :: Parser [Path Abs File] -> Parser a -> Parser a

Combine all Yaml config files that exist into a single combined config object.

withCombinedYamlConfigs' :: HasCallStack => (Object -> Object -> Object) -> Parser [Path Abs File] -> Parser a -> Parser a

combineConfigObjects :: Object -> Object -> Object

xdgYamlConfigFile :: HasCallStack => FilePath -> Parser (Path Abs File)

Load config.yaml from the given XDG configuration subdirectory

withLocalYamlConfig :: HasCallStack => Parser a -> Parser a

Load a config file that is reconfigurable with an option and environment variable but config.yaml in the local working directory by default.

withConfigurableYamlConfig :: HasCallStack => Parser (Path Abs File) -> Parser a -> Parser a

Use the given Parser for deciding which configuration file to load, but only if configuredConfigFile fails to define it first.

withoutConfig :: HasCallStack => Parser a -> Parser a

Don't load any configuration, but still shut up lint errors about conf being used without defining any way to load configuration.

This may be useful if you use a library's Parser that uses conf but do not want to parse any configuration.

configuredConfigFile :: HasCallStack => Parser (Path Abs File)

A standard parser for defining which configuration file to load.

This has no default value so you will have to combine it somehow.

enableDisableSwitch

Arguments

:: HasCallStack

=> [Builder Bool]

Builders

-> Parser Bool

Define a setting for a Value with a given default value.

If you pass in long values, it will have --enable-foobar and --disable-foobar switches. If you pass in env values, it will read those environment variables too. If you pass in conf values, it will read those configuration values too. If you pass in a value value, it will use that as the default value.

yesNoSwitch

Arguments

:: HasCallStack

=> [Builder Bool]

Builders

-> Parser Bool

Define a setting for a Value with a given default value.

If you pass in long values, it will have --foobar and --no-foobar switches. If you pass in env values, it will read those environment variables too. If you pass in conf values, it will read those configuration values too. If you pass in a value value, it will use that as the default value.

makeDoubleSwitch

Arguments

:: HasCallStack

=> String

Prefix for True longs

-> String

Prefix for False longs

-> String

Prefix for the documented longs

-> [Builder Bool]

Builders

-> Parser Bool

readSecretTextFile :: Path Abs File -> IO Text

Read a text file but strip whitespace so it can be edited with an editor that messes with line endings.

Parser implementation

data Parser a where

A Parser structure

A Parser a value represents each of these all at once:

• A way to run it to parse an a
• A way to document it in various ways
• A way to run it to perform shell completion

The basic building block of a Parser is a setting. settings represent individual settings that you can then compose into larger parsers.

Much of the way you compose parsers happens via its type class instances. In particular:

• <$> from Functor to map over Parsers
• <*> from Applicative to "and" Parsers
• <|> from Alternative to "or" Parsers
• optional from Alternative to optionally run a parser
• many and some from Alternative to run the same parser multiple times.

You can run a parser with runParser, or give your type an instance of HasParser and run the parser with runSettingsParser.

Constructors

ParserPure :: !a -> Parser a

ParserAp :: !(Parser (a -> b)) -> !(Parser a) -> Parser b

ParserSelect :: !(Parser (Either a b)) -> !(Parser (a -> b)) -> Parser b

ParserEmpty :: !(Maybe SrcLoc) -> Parser a

ParserAlt :: !(Parser a) -> !(Parser a) -> Parser a

ParserMany :: !(Parser a) -> Parser [a]

ParserSome :: !(Parser a) -> Parser (NonEmpty a)

ParserAllOrNothing :: !(Maybe SrcLoc) -> !(Parser a) -> Parser a

ParserCheck

Fields

• :: !(Maybe SrcLoc)
• -> !Bool

  Forgivable

• -> !(a -> IO (Either String b))
• -> !(Parser a)
• -> Parser b

ParserCommands :: !(Maybe SrcLoc) -> ![Command a] -> Parser a

ParserWithConfig :: !(Maybe SrcLoc) -> !(Parser (Maybe Object)) -> !(Parser a) -> Parser a

Load a configuration value and use it for the continuing parser

ParserSetting :: !(Maybe SrcLoc) -> !(Setting a) -> Parser a

General settings

Instances

Alternative Parser

Defined in OptEnvConf.Parser

Methods

empty :: Parser a

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

some :: Parser a -> Parser [a]

many :: Parser a -> Parser [a]

Applicative Parser

Defined in OptEnvConf.Parser

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

Functor Parser

Defined in OptEnvConf.Parser

Methods

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

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

Selective Parser

Defined in OptEnvConf.Parser

Methods

select :: Parser (Either a b) -> Parser (a -> b) -> Parser b

class HasParser a where

A class of types that have a canonical settings parser.

There are no laws. The closest rule to a law is that a user of an instance should not be surprised by its behaviour.

Methods

settingsParser :: Parser a

data Command a

Constructors

Command

Fields

• commandSrcLoc :: !(Maybe SrcLoc)
• commandArg :: !String
• commandHelp :: !Help
• commandParser :: !(Parser a)

Instances

Functor Command

Defined in OptEnvConf.Parser

Methods

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

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

type Metavar = String

type Help = String

showParserABit :: Parser a -> String

parserEraseSrcLocs :: Parser a -> Parser a

Erase all source locations in a parser.

This may be useful when golden-testing the shown parser.

parserMapSetting :: (forall a. Setting a -> Setting a) -> Parser s -> Parser s

Map all Setting in a Parser.

parserTraverseSetting :: forall f s. Applicative f => (forall a. Setting a -> f (Setting a)) -> Parser s -> f (Parser s)

Traverse all Settings in a Parser.

commandTraverseSetting :: forall f s. Applicative f => (forall a. Setting a -> f (Setting a)) -> Command s -> f (Command s)

All or nothing implementation

parserSettingsSet :: Parser a -> Set SrcLocHash

newtype SrcLocHash

Constructors

SrcLocHash Int

Instances

Eq SrcLocHash

Defined in OptEnvConf.Parser

Methods

(==) :: SrcLocHash -> SrcLocHash -> Bool

(/=) :: SrcLocHash -> SrcLocHash -> Bool

Ord SrcLocHash

Defined in OptEnvConf.Parser

Methods

compare :: SrcLocHash -> SrcLocHash -> Ordering

(<) :: SrcLocHash -> SrcLocHash -> Bool

(<=) :: SrcLocHash -> SrcLocHash -> Bool

(>) :: SrcLocHash -> SrcLocHash -> Bool

(>=) :: SrcLocHash -> SrcLocHash -> Bool

max :: SrcLocHash -> SrcLocHash -> SrcLocHash

min :: SrcLocHash -> SrcLocHash -> SrcLocHash

hashSrcLoc :: SrcLoc -> SrcLocHash

Re-exports

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

A type f is a Functor if it provides a function fmap which, given any types a and b lets you apply any function from (a -> b) to turn an f a into an f b, preserving the structure of f. Furthermore f needs to adhere to the following:

Identity

fmap id == id

Composition

fmap (f . g) == fmap f . fmap g

Note, that the second law follows from the free theorem of the type fmap and the first law, so you need only check that the former condition holds. See https://www.schoolofhaskell.com/user/edwardk/snippets/fmap or https://github.com/quchen/articles/blob/master/second_functor_law.md for an explanation.

Minimal complete definition

fmap

Methods

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

fmap is used to apply a function of type (a -> b) to a value of type f a, where f is a functor, to produce a value of type f b. Note that for any type constructor with more than one parameter (e.g., Either), only the last type parameter can be modified with fmap (e.g., b in `Either a b`).

Some type constructors with two parameters or more have a Bifunctor instance that allows both the last and the penultimate parameters to be mapped over.

Examples

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

>>> fmap show Nothing
Nothing
>>> fmap show (Just 3)
Just "3"

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

>>> fmap show (Left 17)
Left 17
>>> fmap show (Right 17)
Right "17"

Double each element of a list:

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

Apply even to the second element of a pair:

>>> fmap even (2,2)
(2,True)

It may seem surprising that the function is only applied to the last element of the tuple compared to the list example above which applies it to every element in the list. To understand, remember that tuples are type constructors with multiple type parameters: a tuple of 3 elements (a,b,c) can also be written (,,) a b c and its Functor instance is defined for Functor ((,,) a b) (i.e., only the third parameter is free to be mapped over with fmap).

It explains why fmap can be used with tuples containing values of different types as in the following example:

>>> fmap even ("hello", 1.0, 4)
("hello",1.0,True)

(<$) :: 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.

Examples

Perform a computation with Maybe and replace the result with a constant value if it is Just:

>>> 'a' <$ Just 2
Just 'a'
>>> 'a' <$ Nothing
Nothing

Instances

Functor KeyMap

Defined in Data.Aeson.KeyMap

Methods

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

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

Functor FromJSONKeyFunction

Only law abiding up to interpretation

Defined in Data.Aeson.Types.FromJSON

Methods

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

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

Functor IResult

Defined in Data.Aeson.Types.Internal

Methods

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

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

Functor Parser

Defined in Data.Aeson.Types.Internal

Methods

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

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

Functor Result

Defined in Data.Aeson.Types.Internal

Methods

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

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

Functor Bounds

Defined in Autodocodec.Codec

Methods

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

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

Functor Result

Defined in Autodocodec.Codec

Methods

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

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

Functor ZipList

Since: base-2.1

Defined in Control.Applicative

Methods

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

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

Functor Handler

Since: base-4.6.0.0

Defined in Control.Exception

Methods

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

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

Functor Complex

Since: base-4.9.0.0

Defined in Data.Complex

Methods

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

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

Functor Identity

Since: base-4.8.0.0

Defined in Data.Functor.Identity

Methods

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

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

Functor First

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

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

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

Functor Last

Since: base-4.8.0.0

Defined in Data.Monoid

Methods

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

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

Functor First

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

Functor Last

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

Functor Max

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

Functor Min

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

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

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

Functor Dual

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

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

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

Functor Product

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

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

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

Functor Sum

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

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

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

Functor NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

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

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

Functor Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor P

Since: base-4.8.0.0

Defined in Text.ParserCombinators.ReadP

Methods

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

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

Functor ReadP

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

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

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

Functor Flush

Defined in Data.Conduit.Internal.Conduit

Methods

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

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

Functor IntMap

Defined in Data.IntMap.Internal

Methods

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

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

Functor Digit

Defined in Data.Sequence.Internal

Methods

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

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

Functor Elem

Defined in Data.Sequence.Internal

Methods

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

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

Functor FingerTree

Defined in Data.Sequence.Internal

Methods

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

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

Functor Node

Defined in Data.Sequence.Internal

Methods

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

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

Functor Seq

Defined in Data.Sequence.Internal

Methods

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

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

Functor ViewL

Defined in Data.Sequence.Internal

Methods

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

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

Functor ViewR

Defined in Data.Sequence.Internal

Methods

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

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

Functor Tree

Defined in Data.Tree

Methods

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

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

Functor DNonEmpty

Defined in Data.DList.DNonEmpty.Internal

Methods

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

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

Functor DList

Defined in Data.DList.Internal

Methods

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

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

Functor IO

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor AnyDocs

Defined in OptEnvConf.Doc

Methods

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

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

Functor CommandDoc

Defined in OptEnvConf.Doc

Methods

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

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

Functor Command

Defined in OptEnvConf.Parser

Methods

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

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

Functor Parser

Defined in OptEnvConf.Parser

Methods

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

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

Functor Reader

Defined in OptEnvConf.Reader

Methods

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

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

Functor AnnotDetails

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

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

Functor Doc

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

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

Functor Span

Defined in Text.PrettyPrint.Annotated.HughesPJ

Methods

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

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

Functor Array

Defined in Data.Primitive.Array

Methods

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

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

Functor SmallArray

Defined in Data.Primitive.SmallArray

Methods

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

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

Functor Maybe

Defined in Data.Strict.Maybe

Methods

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

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

Functor Q

Defined in Language.Haskell.TH.Syntax

Methods

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

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

Functor TyVarBndr

Defined in Language.Haskell.TH.Syntax

Methods

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

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

Functor Vector

Defined in Data.Vector

Methods

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

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

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor Solo

Since: base-4.15

Defined in GHC.Base

Methods

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

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

Functor List

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor (Tagged2 s)

Defined in Data.Aeson.Types.Generic

Methods

fmap :: (a -> b) -> Tagged2 s a -> Tagged2 s b

(<$) :: a -> Tagged2 s b -> Tagged2 s a

Functor (IResult i)

Defined in Data.Attoparsec.Internal.Types

Methods

fmap :: (a -> b) -> IResult i a -> IResult i b

(<$) :: a -> IResult i b -> IResult i a

Functor (Parser i)

Defined in Data.Attoparsec.Internal.Types

Methods

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

(<$) :: a -> Parser i b -> Parser i 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

Arrow a => Functor (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

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

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

Functor (Either a)

Since: base-3.0

Defined in Data.Either

Methods

fmap :: (a0 -> b) -> Either a a0 -> Either a b

(<$) :: a0 -> Either a b -> Either a a0

Functor (Arg a)

Since: base-4.9.0.0

Defined in Data.Semigroup

Methods

fmap :: (a0 -> b) -> Arg a a0 -> Arg a b

(<$) :: a0 -> Arg a b -> Arg a a0

Functor (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor (V1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Monad m => Functor (ZipSource m)

Defined in Data.Conduit.Internal.Conduit

Methods

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

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

Functor (Map k)

Defined in Data.Map.Internal

Methods

fmap :: (a -> b) -> Map k a -> Map k b

(<$) :: a -> Map k b -> Map k a

Monad m => Functor (Handler m)

Defined in Control.Monad.Catch

Methods

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

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

Functor (Validation e)

Defined in OptEnvConf.Validation

Methods

fmap :: (a -> b) -> Validation e a -> Validation e b

(<$) :: a -> Validation e b -> Validation e a

Functor m => Functor (ResourceT m)

Defined in Control.Monad.Trans.Resource.Internal

Methods

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

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

Functor (Over m)

Defined in Control.Selective

Methods

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

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

Functor f => Functor (SelectA f)

Defined in Control.Selective

Methods

fmap :: (a -> b) -> SelectA f a -> SelectA f b

(<$) :: a -> SelectA f b -> SelectA f a

Functor f => Functor (SelectM f)

Defined in Control.Selective

Methods

fmap :: (a -> b) -> SelectM f a -> SelectM f b

(<$) :: a -> SelectM f b -> SelectM f a

Functor (Under m)

Defined in Control.Selective

Methods

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

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

Functor (Validation e)

Defined in Control.Selective

Methods

fmap :: (a -> b) -> Validation e a -> Validation e b

(<$) :: a -> Validation e b -> Validation e a

Functor (Either a)

Defined in Data.Strict.Either

Methods

fmap :: (a0 -> b) -> Either a a0 -> Either a b

(<$) :: a0 -> Either a b -> Either a a0

Functor (These a)

Defined in Data.Strict.These

Methods

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

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

Functor (Pair e)

Defined in Data.Strict.Tuple

Methods

fmap :: (a -> b) -> Pair e a -> Pair e b

(<$) :: a -> Pair e b -> Pair e a

Functor (These a)

Defined in Data.These

Methods

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

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

Functor f => Functor (Lift f)

Defined in Control.Applicative.Lift

Methods

fmap :: (a -> b) -> Lift f a -> Lift f b

(<$) :: a -> Lift f b -> Lift f a

Functor m => Functor (MaybeT m)

Defined in Control.Monad.Trans.Maybe

Methods

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

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

Functor (HashMap k)

Defined in Data.HashMap.Internal

Methods

fmap :: (a -> b) -> HashMap k a -> HashMap k b

(<$) :: a -> HashMap k b -> HashMap k a

Functor ((,) a)

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor (Codec context input)

Defined in Autodocodec.Codec

Methods

fmap :: (a -> b) -> Codec context input a -> Codec context input b

(<$) :: a -> Codec context input b -> Codec context input a

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

Functor m => Functor (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

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

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

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

Functor f => Functor (Ap f)

Since: base-4.12.0.0

Defined in Data.Monoid

Methods

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

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

Functor f => Functor (Alt f)

Since: base-4.8.0.0

Defined in Data.Semigroup.Internal

Methods

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

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

(Generic1 f, Functor (Rep1 f)) => Functor (Generically1 f)

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> Generically1 f a -> Generically1 f b

(<$) :: a -> Generically1 f b -> Generically1 f a

Functor f => Functor (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor (URec (Ptr ()) :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Functor (URec Char :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Functor (URec Double :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Functor (URec Float :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Functor (URec Int :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Functor (URec Word :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Monad m => Functor (ZipSink i m)

Defined in Data.Conduit.Internal.Conduit

Methods

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

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

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

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

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

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

Functor m => Functor (ValidationT e m)

Defined in OptEnvConf.Validation

Methods

fmap :: (a -> b) -> ValidationT e m a -> ValidationT e m b

(<$) :: a -> ValidationT e m b -> ValidationT e m a

Functor f => Functor (ComposeEither f e)

Defined in Control.Selective

Methods

fmap :: (a -> b) -> ComposeEither f e a -> ComposeEither f e b

(<$) :: a -> ComposeEither f e b -> ComposeEither f e a

(Functor f, Functor g) => Functor (ComposeTraversable f g)

Defined in Control.Selective

Methods

fmap :: (a -> b) -> ComposeTraversable f g a -> ComposeTraversable f g b

(<$) :: a -> ComposeTraversable f g b -> ComposeTraversable f g a

Functor (Tagged s)

Defined in Data.Tagged

Methods

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

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

(Functor f, Functor g) => Functor (These1 f g)

Defined in Data.Functor.These

Methods

fmap :: (a -> b) -> These1 f g a -> These1 f g b

(<$) :: a -> These1 f g b -> These1 f g a

Functor f => Functor (Backwards f)

Derived instance.

Defined in Control.Applicative.Backwards

Methods

fmap :: (a -> b) -> Backwards f a -> Backwards f b

(<$) :: a -> Backwards f b -> Backwards f a

Functor m => Functor (AccumT w m)

Defined in Control.Monad.Trans.Accum

Methods

fmap :: (a -> b) -> AccumT w m a -> AccumT w m b

(<$) :: a -> AccumT w m b -> AccumT w m a

Functor m => Functor (ExceptT e m)

Defined in Control.Monad.Trans.Except

Methods

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

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

Functor m => Functor (IdentityT m)

Defined in Control.Monad.Trans.Identity

Methods

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

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

Functor m => Functor (ReaderT r m)

Defined in Control.Monad.Trans.Reader

Methods

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

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

Functor m => Functor (SelectT r m)

Defined in Control.Monad.Trans.Select

Methods

fmap :: (a -> b) -> SelectT r m a -> SelectT r m b

(<$) :: a -> SelectT r m b -> SelectT r m a

Functor m => Functor (StateT s m)

Defined in Control.Monad.Trans.State.Lazy

Methods

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

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

Functor m => Functor (StateT s m)

Defined in Control.Monad.Trans.State.Strict

Methods

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

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

Functor m => Functor (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

Methods

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

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

Functor m => Functor (WriterT w m)

Defined in Control.Monad.Trans.Writer.Lazy

Methods

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

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

Functor m => Functor (WriterT w m)

Defined in Control.Monad.Trans.Writer.Strict

Methods

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

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

Functor (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

fmap :: (a0 -> b) -> Constant a a0 -> Constant a b

(<$) :: a0 -> Constant a b -> Constant a a0

Functor f => Functor (Reverse f)

Derived instance.

Defined in Data.Functor.Reverse

Methods

fmap :: (a -> b) -> Reverse f a -> Reverse f b

(<$) :: a -> Reverse f b -> Reverse f a

Functor ((,,) a b)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

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

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

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

Since: base-4.9.0.0

Defined in Data.Functor.Product

Methods

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

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

(Functor f, Functor g) => Functor (Sum f g)

Since: base-4.9.0.0

Defined in Data.Functor.Sum

Methods

fmap :: (a -> b) -> Sum f g a -> Sum f g b

(<$) :: a -> Sum f g b -> Sum f g a

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

(Functor f, Functor g) => Functor (f :+: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b

(<$) :: a -> (f :+: g) b -> (f :+: g) a

Functor (K1 i c :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor (ConduitT i o m)

Defined in Data.Conduit.Internal.Conduit

Methods

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

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

Functor (ZipConduit i o m)

Defined in Data.Conduit.Internal.Conduit

Methods

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

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

Functor f => Functor (WhenMatched f x y)

Since: containers-0.5.9

Defined in Data.IntMap.Internal

Methods

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

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

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

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

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

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

Functor (ContT r m)

Defined in Control.Monad.Trans.Cont

Methods

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

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

Functor ((,,,) a b c)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

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

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

Functor ((->) r)

Since: base-2.1

Defined in GHC.Base

Methods

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

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

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

Since: base-4.9.0.0

Defined in Data.Functor.Compose

Methods

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

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

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor f => Functor (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor f => Functor (WhenMatched f k x y)

Since: containers-0.5.9

Defined in Data.Map.Internal

Methods

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

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

Functor m => Functor (RWST r w s m)

Defined in Control.Monad.Trans.RWS.CPS

Methods

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

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

Functor m => Functor (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Lazy

Methods

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

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

Functor m => Functor (RWST r w s m)

Defined in Control.Monad.Trans.RWS.Strict

Methods

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

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

Functor ((,,,,) a b c d)

Since: base-4.18.0.0

Defined in GHC.Base

Methods

fmap :: (a0 -> b0) -> (a, b, c, d, a0) -> (a, b, c, d, b0)

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

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

Defined in Data.Conduit.Internal.Pipe

Methods

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

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

Functor ((,,,,,) a b c d e)

Since: base-4.18.0.0

Defined in GHC.Base

Methods

fmap :: (a0 -> b0) -> (a, b, c, d, e, a0) -> (a, b, c, d, e, b0)

(<$) :: a0 -> (a, b, c, d, e, b0) -> (a, b, c, d, e, a0)

Functor ((,,,,,,) a b c d e f)

Since: base-4.18.0.0

Defined in GHC.Base

Methods

fmap :: (a0 -> b0) -> (a, b, c, d, e, f, a0) -> (a, b, c, d, e, f, b0)

(<$) :: a0 -> (a, b, c, d, e, f, b0) -> (a, b, c, d, e, f, a0)

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.

Example

Used in combination with (<$>), (<*>) can be used to build a record.

>>> data MyState = MyState {arg1 :: Foo, arg2 :: Bar, arg3 :: Baz}

>>> produceFoo :: Applicative f => f Foo

>>> produceBar :: Applicative f => f Bar
>>> produceBaz :: Applicative f => f Baz

>>> mkState :: Applicative f => f MyState
>>> mkState = MyState <$> produceFoo <*> produceBar <*> produceBaz

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.

Example

>>> liftA2 (,) (Just 3) (Just 5)
Just (3,5)

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

Sequence actions, discarding the value of the first argument.

Examples

If used in conjunction with the Applicative instance for Maybe, you can chain Maybe computations, with a possible "early return" in case of Nothing.

>>> Just 2 *> Just 3
Just 3

>>> Nothing *> Just 3
Nothing

Of course a more interesting use case would be to have effectful computations instead of just returning pure values.

>>> import Data.Char
>>> import Text.ParserCombinators.ReadP
>>> let p = string "my name is " *> munch1 isAlpha <* eof
>>> readP_to_S p "my name is Simon"
[("Simon","")]

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

Sequence actions, discarding the value of the second argument.

Instances

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 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 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 Result

Defined in Autodocodec.Codec

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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Parser

Defined in OptEnvConf.Parser

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 Reader

Defined in OptEnvConf.Reader

Methods

pure :: a -> Reader a

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

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

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

(<*) :: Reader a -> Reader b -> Reader 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 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 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 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 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 Solo

Since: base-4.15

Defined in GHC.Base

Methods

pure :: a -> Solo a

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

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

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

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

Applicative List

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 (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

Applicative (ObjectCodec input)

Defined in Autodocodec.Codec

Methods

pure :: a -> ObjectCodec input a

(<*>) :: ObjectCodec input (a -> b) -> ObjectCodec input a -> ObjectCodec input b

liftA2 :: (a -> b -> c) -> ObjectCodec input a -> ObjectCodec input b -> ObjectCodec input c

(*>) :: ObjectCodec input a -> ObjectCodec input b -> ObjectCodec input b

(<*) :: ObjectCodec input a -> ObjectCodec input b -> ObjectCodec input 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

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

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 (Validation e)

Defined in OptEnvConf.Validation

Methods

pure :: a -> Validation e a

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

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

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

(<*) :: Validation e a -> Validation e b -> Validation e 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

Monoid m => Applicative (Over m)

Defined in Control.Selective

Methods

pure :: a -> Over m a

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

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

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

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

Applicative f => Applicative (SelectA f)

Defined in Control.Selective

Methods

pure :: a -> SelectA f a

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

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

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

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

Applicative f => Applicative (SelectM f)

Defined in Control.Selective

Methods

pure :: a -> SelectM f a

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

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

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

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

Monoid m => Applicative (Under m)

Defined in Control.Selective

Methods

pure :: a -> Under m a

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

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

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

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

Semigroup e => Applicative (Validation e)

Defined in Control.Selective

Methods

pure :: a -> Validation e a

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

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

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

(<*) :: Validation e a -> Validation e b -> Validation e 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 f => Applicative (Lift f)

A combination is Pure only if both parts are.

Defined in Control.Applicative.Lift

Methods

pure :: a -> Lift f a

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

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

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

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

(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

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)

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

(Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f)

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

pure :: a -> Generically1 f a

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

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

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

(<*) :: Generically1 f a -> Generically1 f b -> Generically1 f 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

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

Applicative m => Applicative (ValidationT e m)

Defined in OptEnvConf.Validation

Methods

pure :: a -> ValidationT e m a

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

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

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

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

Selective f => Applicative (ComposeEither f e)

Defined in Control.Selective

Methods

pure :: a -> ComposeEither f e a

(<*>) :: ComposeEither f e (a -> b) -> ComposeEither f e a -> ComposeEither f e b

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

(*>) :: ComposeEither f e a -> ComposeEither f e b -> ComposeEither f e b

(<*) :: ComposeEither f e a -> ComposeEither f e b -> ComposeEither f e a

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

Defined in Control.Selective

Methods

pure :: a -> ComposeTraversable f g a

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

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

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

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

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 f => Applicative (Backwards f)

Apply f-actions in the reverse order.

Defined in Control.Applicative.Backwards

Methods

pure :: a -> Backwards f a

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

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

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

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

(Monoid w, Functor m, Monad m) => Applicative (AccumT w m)

Defined in Control.Monad.Trans.Accum

Methods

pure :: a -> AccumT w m a

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

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

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

(<*) :: AccumT w m a -> AccumT w m b -> AccumT w 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

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

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 (SelectT r m)

Defined in Control.Monad.Trans.Select

Methods

pure :: a -> SelectT r m a

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

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

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

(<*) :: SelectT r m a -> SelectT r m b -> SelectT r 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

(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 (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

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

(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 a => Applicative (Constant a :: Type -> Type)

Defined in Data.Functor.Constant

Methods

pure :: a0 -> Constant a a0

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

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

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

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

Applicative f => Applicative (Reverse f)

Derived instance.

Defined in Data.Functor.Reverse

Methods

pure :: a -> Reverse f a

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

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

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

(<*) :: Reverse f a -> Reverse f b -> Reverse 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)

(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 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 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 (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

(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 ((->) r)

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

(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

(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 (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

(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

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

Defined in Control.Monad.Trans.RWS.CPS

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

(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

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

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 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 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 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 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 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 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 IO

Takes the first non-throwing IO action's result. empty throws an exception.

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 Parser

Defined in OptEnvConf.Parser

Methods

empty :: Parser a

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

some :: Parser a -> Parser [a]

many :: Parser a -> Parser [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 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 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 Maybe

Picks the leftmost Just value, or, alternatively, Nothing.

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 List

Combines lists by concatenation, starting from the empty list.

Since: base-2.1

Defined in GHC.Base

Methods

empty :: [a]

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

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

many :: [a] -> [[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]

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 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]

Alternative f => Alternative (Lift f)

A combination is Pure only either part is.

Defined in Control.Applicative.Lift

Methods

empty :: Lift f a

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

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

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

(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]

(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]

(Generic1 f, Alternative (Rep1 f)) => Alternative (Generically1 f)

Since: base-4.17.0.0

Defined in GHC.Generics

Methods

empty :: Generically1 f a

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

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

many :: Generically1 f a -> Generically1 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]

(Selective f, Monoid e) => Alternative (ComposeEither f e)

Defined in Control.Selective

Methods

empty :: ComposeEither f e a

(<|>) :: ComposeEither f e a -> ComposeEither f e a -> ComposeEither f e a

some :: ComposeEither f e a -> ComposeEither f e [a]

many :: ComposeEither f e a -> ComposeEither f e [a]

Alternative f => Alternative (Backwards f)

Try alternatives in the same order as f.

Defined in Control.Applicative.Backwards

Methods

empty :: Backwards f a

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

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

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

(Monoid w, Functor m, MonadPlus m) => Alternative (AccumT w m)

Defined in Control.Monad.Trans.Accum

Methods

empty :: AccumT w m a

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

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

many :: AccumT w m a -> AccumT w 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]

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]

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, MonadPlus m) => Alternative (SelectT r m)

Defined in Control.Monad.Trans.Select

Methods

empty :: SelectT r m a

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

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

many :: SelectT r m a -> SelectT r 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]

(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 (WriterT w m)

Defined in Control.Monad.Trans.Writer.CPS

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]

(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]

Alternative f => Alternative (Reverse f)

Derived instance.

Defined in Data.Functor.Reverse

Methods

empty :: Reverse f a

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

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

many :: Reverse f a -> Reverse f [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 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]

(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 => 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]

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

Defined in Control.Monad.Trans.RWS.CPS

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]

(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]

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

Selective applicative functors. You can think of select as a selective function application: when given a value of type Left a, you must apply the given function, but when given a Right b, you may skip the function and associated effects, and simply return the b.

Note that it is not a requirement for selective functors to skip unnecessary effects. It may be counterintuitive, but this makes them more useful. Why? Typically, when executing a selective computation, you would want to skip the effects (saving work); but on the other hand, if your goal is to statically analyse a given selective computation and extract the set of all possible effects (without actually executing them), then you do not want to skip any effects, because that defeats the purpose of static analysis.

The type signature of select is reminiscent of both <*> and >>=, and indeed a selective functor is in some sense a composition of an applicative functor and the Either monad.

Laws:

• Identity:

x <*? pure id = either id id <$> x

• Distributivity; note that y and z have the same type f (a -> b):

pure x <*? (y *> z) = (pure x <*? y) *> (pure x <*? z)

• Associativity:

x <*? (y <*? z) = (f <$> x) <*? (g <$> y) <*? (h <$> z)
  where
    f x = Right <$> x
    g y = a -> bimap (,a) ($a) y
    h z = uncurry z

• Monadic select (for selective functors that are also monads):

select = selectM

There are also a few useful theorems:

• Apply a pure function to the result:

f <$> select x y = select (fmap f <$> x) (fmap f <$> y)

• Apply a pure function to the Left case of the first argument:

select (first f <$> x) y = select x ((. f) <$> y)

• Apply a pure function to the second argument:

select x (f <$> y) = select (first (flip f) <$> x) ((&) <$> y)

• Generalised identity:

x <*? pure y = either y id <$> x

• A selective functor is rigid if it satisfies <*> = apS. The following interchange law holds for rigid selective functors:

x *> (y <*? z) = (x *> y) <*? z

If f is also a Monad, we require that select = selectM, from which one can prove <*> = apS.

Methods

select :: f (Either a b) -> f (a -> b) -> f b

Instances

Selective ZipList

Defined in Control.Selective

Methods

select :: ZipList (Either a b) -> ZipList (a -> b) -> ZipList b

Selective Identity

Defined in Control.Selective

Methods

select :: Identity (Either a b) -> Identity (a -> b) -> Identity b

Selective NonEmpty

Defined in Control.Selective

Methods

select :: NonEmpty (Either a b) -> NonEmpty (a -> b) -> NonEmpty b

Selective STM

Defined in Control.Selective

Methods

select :: STM (Either a b) -> STM (a -> b) -> STM b

Selective IO

Defined in Control.Selective

Methods

select :: IO (Either a b) -> IO (a -> b) -> IO b

Selective Parser

Defined in OptEnvConf.Parser

Methods

select :: Parser (Either a b) -> Parser (a -> b) -> Parser b

Selective Maybe

Defined in Control.Selective

Methods

select :: Maybe (Either a b) -> Maybe (a -> b) -> Maybe b

Selective List

Defined in Control.Selective

Methods

select :: [Either a b] -> [a -> b] -> [b]

ArrowChoice a => Selective (ArrowMonad a)

Defined in Control.Selective

Methods

select :: ArrowMonad a (Either a0 b) -> ArrowMonad a (a0 -> b) -> ArrowMonad a b

Selective (Either e)

Defined in Control.Selective

Methods

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

Selective (Proxy :: Type -> Type)

Defined in Control.Selective

Methods

select :: Proxy (Either a b) -> Proxy (a -> b) -> Proxy b

Selective (ST s)

Defined in Control.Selective

Methods

select :: ST s (Either a b) -> ST s (a -> b) -> ST s b

Selective (Validation e)

Defined in OptEnvConf.Validation

Methods

select :: Validation e (Either a b) -> Validation e (a -> b) -> Validation e b

Monoid m => Selective (Over m)

Defined in Control.Selective

Methods

select :: Over m (Either a b) -> Over m (a -> b) -> Over m b

Applicative f => Selective (SelectA f)

Defined in Control.Selective

Methods

select :: SelectA f (Either a b) -> SelectA f (a -> b) -> SelectA f b

Monad f => Selective (SelectM f)

Defined in Control.Selective

Methods

select :: SelectM f (Either a b) -> SelectM f (a -> b) -> SelectM f b

Monoid m => Selective (Under m)

Defined in Control.Selective

Methods

select :: Under m (Either a b) -> Under m (a -> b) -> Under m b

Semigroup e => Selective (Validation e)

Defined in Control.Selective

Methods

select :: Validation e (Either a b) -> Validation e (a -> b) -> Validation e b

Selective f => Selective (Lift f)

Defined in Control.Selective

Methods

select :: Lift f (Either a b) -> Lift f (a -> b) -> Lift f b

Monad m => Selective (MaybeT m)

Defined in Control.Selective

Methods

select :: MaybeT m (Either a b) -> MaybeT m (a -> b) -> MaybeT m b

Monoid a => Selective ((,) a)

Defined in Control.Selective

Methods

select :: (a, Either a0 b) -> (a, a0 -> b) -> (a, b)

Selective m => Selective (ValidationT e m)

Defined in OptEnvConf.Validation

Methods

select :: ValidationT e m (Either a b) -> ValidationT e m (a -> b) -> ValidationT e m b

Selective f => Selective (ComposeEither f e)

Defined in Control.Selective

Methods

select :: ComposeEither f e (Either a b) -> ComposeEither f e (a -> b) -> ComposeEither f e b

(Selective f, Applicative g, Traversable g) => Selective (ComposeTraversable f g)

Defined in Control.Selective

Methods

select :: ComposeTraversable f g (Either a b) -> ComposeTraversable f g (a -> b) -> ComposeTraversable f g b

Selective f => Selective (IdentityT f)

Defined in Control.Selective

Methods

select :: IdentityT f (Either a b) -> IdentityT f (a -> b) -> IdentityT f b

Selective f => Selective (ReaderT env f)

Defined in Control.Selective

Methods

select :: ReaderT env f (Either a b) -> ReaderT env f (a -> b) -> ReaderT env f b

Monad m => Selective (StateT s m)

Defined in Control.Selective

Methods

select :: StateT s m (Either a b) -> StateT s m (a -> b) -> StateT s m b

Monad m => Selective (StateT s m)

Defined in Control.Selective

Methods

select :: StateT s m (Either a b) -> StateT s m (a -> b) -> StateT s m b

(Monoid w, Selective f) => Selective (WriterT w f)

Defined in Control.Selective

Methods

select :: WriterT w f (Either a b) -> WriterT w f (a -> b) -> WriterT w f b

(Monoid w, Selective f) => Selective (WriterT w f)

Defined in Control.Selective

Methods

select :: WriterT w f (Either a b) -> WriterT w f (a -> b) -> WriterT w f b

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

Defined in Control.Selective

Methods

select :: Product f g (Either a b) -> Product f g (a -> b) -> Product f g b

Selective (ContT r m)

Defined in Control.Selective

Methods

select :: ContT r m (Either a b) -> ContT r m (a -> b) -> ContT r m b

Selective ((->) a)

Defined in Control.Selective

Methods

select :: (a -> Either a0 b) -> (a -> (a0 -> b)) -> a -> b

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

Defined in Control.Selective

Methods

select :: Compose f g (Either a b) -> Compose f g (a -> b) -> Compose f g b

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

Defined in Control.Selective

Methods

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

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

Defined in Control.Selective

Methods

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