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 <*>.

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.

Some instances for applicative functors and type-level composition. Forkable on github.
Version 0.1.8

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 "ApplicativeNumeric-inc.hs"
#define APPLICATIVE Vec3 #include "ApplicativeNumeric-inc.hs"
#define APPLICATIVE Vec4 #include "ApplicativeNumeric-inc.hs" @
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

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

liftA2 for infix operators.
Version 1.1

Here is a simple example of an applicative option parser:
@ data Sample = Sample   { hello :: String   , quiet :: Bool }
sample :: Parser Sample sample = Sample   <$> strOption   ( long "hello"   <> metavar "TARGET"   <> help "Target for the greeting" )   <*> switch   ( long "quiet"   <> help "Whether to be quiet" ) @
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 $ "Hello, " ++ h greet _ = return ()
main :: IO () main = execParser opts >>= greet   where   opts = info (helper <*> sample)   ( fullDesc   <> progDesc "Print a greeting for TARGET"   <> header "hello - a test for optparse-applicative" ) @
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

regex-applicative is a Haskell library for parsing using regular expressions. Parsers can be built using Applicative interface.
Version 0.3.0.2