Applicative +Control

class Functor f => Applicative f
base Control.Applicative
A functor with application. Instances should satisfy the following laws: * 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 * ignore left value u *> v = pure (const id) <*> u <*> v * ignore right value u <* v = pure const <*> u <*> v The Functor instance should satisfy > fmap f x = pure f <*> x If f is also a Monad, define pure = return and (<*>) = ap. Minimal complete definition: pure and <*>.
module Control.Applicative
base Control.Applicative
This module describes a structure intermediate between a functor and a monad: it provides pure expressions and sequencing, but no binding. (Technically, a strong lax monoidal functor.) For more details, see Applicative Programming with Effects, by Conor McBride and Ross Paterson, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html. This interface was introduced for parsers by Niklas Röjemo, because it admits more sharing than the monadic interface. The names here are mostly based on recent parsing work by Doaitse Swierstra. This class is also useful with instances of the Data.Traversable.Traversable class.
package applicative-extras
package
Some instances for applicative functors and type-level composition. Forkable on github. Version 0.1.8
package applicative-numbers
package
Any applicative functor can be given numeric instances in a boilerplate way. The applicative-numbers package provides an include file that makes it a snap to define these instances. See Data.Numeric.Function for an example. Project wiki page: http://haskell.org/haskellwiki/applicative-numbers Copyright 2009-2013 Conal Elliott; BSD3 license. Instances of Num classes for applicative functors.  To be #include'd after defining APPLICATIVE as the applicative functor name and CONSTRAINTS as a list of constraints, which must carry its own trailing comma if non-empty. The APPLICATIVE symbol gets #undef'd at the end of the include file, so that multiple includes are convenient. For instance, @ #define INSTANCE_Ord #define INSTANCE_Enum #define APPLICATIVE Vec2 #include &quot;ApplicativeNumeric-inc.hs&quot; #define APPLICATIVE Vec3 #include &quot;ApplicativeNumeric-inc.hs&quot; #define APPLICATIVE Vec4 #include &quot;ApplicativeNumeric-inc.hs&quot; @ You'll also have to import pure and liftA2 from Control.Applicative and specify the FlexibleContexts language extension (due to an implementation hack). Some instances are generated only if a corresponding CPP symbol is defined: INSTANCE_Eq, INSTANCE_Ord, INSTANCE_Show, INSTANCE_Enum Version 0.1.2
package applicative-quoters
package
Quasiquoters taken from Matt Morrow's haskell-src-meta to implement Conor McBride's idiom brackets, and a do-notation that only requires Applicative (and is correspondingly less powerful). applicative-quoters currently has no maintainer: if it is broken and you want it to be fixed, then fix it! Version 0.1.0.8
package InfixApplicative
package
liftA2 for infix operators. Version 1.1
package optparse-applicative
package
Here is a simple example of an applicative option parser: @ data Sample = Sample &#x20; &#x7b; hello :: String &#x20; , quiet :: Bool &#x7d; sample :: Parser Sample sample = Sample &#x20; <$> strOption &#x20;     ( long &quot;hello&quot; &#x20; <> metavar &quot;TARGET&quot; &#x20;    <> help &quot;Target for the greeting&quot; ) &#x20; <*> switch &#x20;     ( long &quot;quiet&quot; &#x20;    <> help &quot;Whether to be quiet&quot; ) @ The parser is built using applicative style starting from a set of basic combinators. In this example, hello is defined as an option with a String argument, while quiet is a boolean flag (called switch). A parser can be used like this: @ greet :: Sample -> IO () greet (Sample h False) = putStrLn $ &quot;Hello, &quot; ++ h greet _ = return () main :: IO () main = execParser opts >>= greet &#x20; where &#x20;   opts = info (helper <*> sample) &#x20; ( fullDesc &#x20;    <> progDesc &quot;Print a greeting for TARGET&quot; &#x20;    <> header &quot;hello - a test for optparse-applicative&quot; ) @ The greet function is the entry point of the program, while opts is a complete description of the program, used when generating a help text. The helper combinator takes any parser, and adds a help option to it (which always fails). The hello option in this example is mandatory (since it doesn't have a default value), so running the program without any argument will display a help text: > hello - a test for optparse-applicative > Usage: hello --hello TARGET [--quiet] > Print a greeting for TARGET > Available options: > -h,--help                Show this help text > --hello TARGET           Target for the greeting > --quiet                  Whether to be quiet containing a short usage summary, and a detailed list of options with descriptions. Version 0.7.0.2
package regex-applicative
package
regex-applicative is a Haskell library for parsing using regular expressions. Parsers can be built using Applicative interface. Version 0.3.0.2