Control.Applicative

base-4.9.0.0: Basic libraries

Copyright | Conor McBride and Ross Paterson 2005
License | BSD-style (see the LICENSE file in the distribution)
Maintainer | libraries@haskell.org
Stability | experimental
Portability | portable
Safe Haskell | Trustworthy
Language | Haskell2010

Control.Applicative

Contents

- Applicative functors
- Alternatives
- Instances
- Utility functions

Description

This module describes a structure intermediate between a functor and a monad (technically, a strong lax monoidal functor). Compared with monads, this interface lacks the full power of the binding operation `>>=`, but

- it has more instances.
- it is sufficient for many uses, e.g. context-free parsing, or the `Traversable` class.
- instances can perform analysis of computations before they are executed, and thus produce shared optimizations.

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 parsing work by Doaitse Swierstra.

For more details, see Applicative Programming with Effects, by Conor McBride and Ross Paterson.

Synopsis

- class Functor f => Applicative f where
- class Applicative f => Alternative f where
- newtype Const a b = Const {
  - getConst :: a
  }
- newtype WrappedMonad m a = WrapMonad {
  - unwrapMonad :: m a
  }
- newtype WrappedArrow a b c = WrapArrow {
  - unwrapArrow :: a b c
  }
- newtype ZipList a = ZipList {
  - getZipList :: [a]
  }
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- (<$) :: Functor f => a -> f b -> f a
- (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- liftA :: Applicative f => (a -> b) -> f a -> f b
- liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
- liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- optional :: Alternative f => f a -> f (Maybe a)

# Applicative functors

class Functor f => Applicative f where Source

A functor with application, providing operations to

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

A minimal complete definition must include implementations of these functions satisfying 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

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

-     u *> v = pure (const id) <*> u <*> v

-     u <* v = pure const <*> u <*> v

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

-     fmap f x = pure f <*> x

If `f` is also a `Monad`, it should satisfy

-     pure = return

-     (<*>) = ap

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

Minimal complete definition

pure, (<*>)

Methods

pure :: a -> f a Source

Lift a value.

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

Sequential application.

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

Sequence actions, discarding the value of the first argument.

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

Sequence actions, discarding the value of the second argument.

Instances

Applicative [] |
Methods pure :: a -> [a] Source (<*>) :: [a -> b] -> [a] -> [b] Source (*>) :: [a] -> [b] -> [b] Source (<*) :: [a] -> [b] -> [a] Source
Applicative Maybe |
Methods pure :: a -> Maybe a Source (<*>) :: Maybe (a -> b) -> Maybe a -> Maybe b Source (*>) :: Maybe a -> Maybe b -> Maybe b Source (<*) :: Maybe a -> Maybe b -> Maybe a Source
Applicative IO |
Methods pure :: a -> IO a Source (<*>) :: IO (a -> b) -> IO a -> IO b Source (*>) :: IO a -> IO b -> IO b Source (<*) :: IO a -> IO b -> IO a Source
Applicative ReadP |
Methods pure :: a -> ReadP a Source (<*>) :: ReadP (a -> b) -> ReadP a -> ReadP b Source (*>) :: ReadP a -> ReadP b -> ReadP b Source (<*) :: ReadP a -> ReadP b -> ReadP a Source
Applicative ReadPrec |
Methods pure :: a -> ReadPrec a Source (<*>) :: ReadPrec (a -> b) -> ReadPrec a -> ReadPrec b Source (*>) :: ReadPrec a -> ReadPrec b -> ReadPrec b Source (<*) :: ReadPrec a -> ReadPrec b -> ReadPrec a Source
Applicative Last |
Methods pure :: a -> Last a Source (<*>) :: Last (a -> b) -> Last a -> Last b Source (*>) :: Last a -> Last b -> Last b Source (<*) :: Last a -> Last b -> Last a Source
Applicative First |
Methods pure :: a -> First a Source (<*>) :: First (a -> b) -> First a -> First b Source (*>) :: First a -> First b -> First b Source (<*) :: First a -> First b -> First a Source
Applicative Product |
Methods pure :: a -> Product a Source (<*>) :: Product (a -> b) -> Product a -> Product b Source (*>) :: Product a -> Product b -> Product b Source (<*) :: Product a -> Product b -> Product a Source
Applicative Sum |
Methods pure :: a -> Sum a Source (<*>) :: Sum (a -> b) -> Sum a -> Sum b Source (*>) :: Sum a -> Sum b -> Sum b Source (<*) :: Sum a -> Sum b -> Sum a Source
Applicative Dual |
Methods pure :: a -> Dual a Source (<*>) :: Dual (a -> b) -> Dual a -> Dual b Source (*>) :: Dual a -> Dual b -> Dual b Source (<*) :: Dual a -> Dual b -> Dual a Source
Applicative STM |
Methods pure :: a -> STM a Source (<*>) :: STM (a -> b) -> STM a -> STM b Source (*>) :: STM a -> STM b -> STM b Source (<*) :: STM a -> STM b -> STM a Source
Applicative ZipList |
Methods pure :: a -> ZipList a Source (<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source (*>) :: ZipList a -> ZipList b -> ZipList b Source (<*) :: ZipList a -> ZipList b -> ZipList a Source
Applicative Complex |
Methods pure :: a -> Complex a Source (<*>) :: Complex (a -> b) -> Complex a -> Complex b Source (*>) :: Complex a -> Complex b -> Complex b Source (<*) :: Complex a -> Complex b -> Complex a Source
Applicative NonEmpty |
Methods pure :: a -> NonEmpty a Source (<*>) :: NonEmpty (a -> b) -> NonEmpty a -> NonEmpty b Source (*>) :: NonEmpty a -> NonEmpty b -> NonEmpty b Source (<*) :: NonEmpty a -> NonEmpty b -> NonEmpty a Source
Applicative Option |
Methods pure :: a -> Option a Source (<*>) :: Option (a -> b) -> Option a -> Option b Source (*>) :: Option a -> Option b -> Option b Source (<*) :: Option a -> Option b -> Option a Source
Applicative Last |
Methods pure :: a -> Last a Source (<*>) :: Last (a -> b) -> Last a -> Last b Source (*>) :: Last a -> Last b -> Last b Source (<*) :: Last a -> Last b -> Last a Source
Applicative First |
Methods pure :: a -> First a Source (<*>) :: First (a -> b) -> First a -> First b Source (*>) :: First a -> First b -> First b Source (<*) :: First a -> First b -> First a Source
Applicative Max |
Methods pure :: a -> Max a Source (<*>) :: Max (a -> b) -> Max a -> Max b Source (*>) :: Max a -> Max b -> Max b Source (<*) :: Max a -> Max b -> Max a Source
Applicative Min |
Methods pure :: a -> Min a Source (<*>) :: Min (a -> b) -> Min a -> Min b Source (*>) :: Min a -> Min b -> Min b Source (<*) :: Min a -> Min b -> Min a Source
Applicative Identity |
Methods pure :: a -> Identity a Source (<*>) :: Identity (a -> b) -> Identity a -> Identity b Source (*>) :: Identity a -> Identity b -> Identity b Source (<*) :: Identity a -> Identity b -> Identity a Source
Applicative ((->) a) |
Methods pure :: a -> a -> a Source (<*>) :: (a -> a -> b) -> (a -> a) -> a -> b Source (*>) :: (a -> a) -> (a -> b) -> a -> b Source (<*) :: (a -> a) -> (a -> b) -> a -> a Source
Applicative (Either e) |
Methods pure :: a -> Either e a Source (<*>) :: Either e (a -> b) -> Either e a -> Either e b Source (*>) :: Either e a -> Either e b -> Either e b Source (<*) :: Either e a -> Either e b -> Either e a Source
Monoid a => Applicative ((,) a) |
Methods pure :: a -> (a, a) Source (<*>) :: (a, a -> b) -> (a, a) -> (a, b) Source (*>) :: (a, a) -> (a, b) -> (a, b) Source (<*) :: (a, a) -> (a, b) -> (a, a) Source
Applicative (ST s) |
Methods pure :: a -> ST s a Source (<*>) :: ST s (a -> b) -> ST s a -> ST s b Source (*>) :: ST s a -> ST s b -> ST s b Source (<*) :: ST s a -> ST s b -> ST s a Source
Applicative (Proxy (TYPE Lifted)) |
Methods pure :: a -> Proxy (TYPE Lifted) a Source (<*>) :: Proxy (TYPE Lifted) (a -> b) -> Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b Source (*>) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) b Source (<*) :: Proxy (TYPE Lifted) a -> Proxy (TYPE Lifted) b -> Proxy (TYPE Lifted) a Source
Arrow a => Applicative (ArrowMonad a) |
Methods pure :: a -> ArrowMonad a a Source (<*>) :: ArrowMonad a (a -> b) -> ArrowMonad a a -> ArrowMonad a b Source (*>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b Source (<*) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a a Source
Monad m => Applicative (WrappedMonad m) |
Methods pure :: a -> WrappedMonad m a Source (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source
Applicative (ST s) |
Methods pure :: a -> ST s a Source (<*>) :: ST s (a -> b) -> ST s a -> ST s b Source (*>) :: ST s a -> ST s b -> ST s b Source (<*) :: ST s a -> ST s b -> ST s a Source
Applicative f => Applicative (Alt (TYPE Lifted) f) |
Methods pure :: a -> Alt (TYPE Lifted) f a Source (<*>) :: Alt (TYPE Lifted) f (a -> b) -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f b Source (*>) :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f b -> Alt (TYPE Lifted) f b Source (<*) :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f b -> Alt (TYPE Lifted) f a Source
Monoid m => Applicative (Const (TYPE Lifted) m) |
Methods pure :: a -> Const (TYPE Lifted) m a Source (<*>) :: Const (TYPE Lifted) m (a -> b) -> Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b Source (*>) :: Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b -> Const (TYPE Lifted) m b Source (<*) :: Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b -> Const (TYPE Lifted) m a Source
Arrow a => Applicative (WrappedArrow a b) |
Methods pure :: a -> WrappedArrow a b a Source (<*>) :: WrappedArrow a b (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b Source (*>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b Source (<*) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b a Source
(Applicative f, Applicative g) => Applicative (Product (TYPE Lifted) f g) |
Methods pure :: a -> Product (TYPE Lifted) f g a Source (<*>) :: Product (TYPE Lifted) f g (a -> b) -> Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g b Source (*>) :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g b -> Product (TYPE Lifted) f g b Source (<*) :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g b -> Product (TYPE Lifted) f g a Source
(Applicative f, Applicative g) => Applicative (Compose (TYPE Lifted) (TYPE Lifted) f g) |
Methods pure :: a -> Compose (TYPE Lifted) (TYPE Lifted) f g a Source (<*>) :: Compose (TYPE Lifted) (TYPE Lifted) f g (a -> b) -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g b Source (*>) :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g b -> Compose (TYPE Lifted) (TYPE Lifted) f g b Source (<*) :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g b -> Compose (TYPE Lifted) (TYPE Lifted) f g a Source

# Alternatives

class Applicative f => Alternative f where Source

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 Source

The identity of `<|>`

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

An associative binary operation

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

One or more.

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

Zero or more.

Instances

Alternative [] |
Methods empty :: [a] Source (<|>) :: [a] -> [a] -> [a] Source some :: [a] -> [[a]] Source many :: [a] -> [[a]] Source
Alternative Maybe |
Methods empty :: Maybe a Source (<|>) :: Maybe a -> Maybe a -> Maybe a Source some :: Maybe a -> Maybe [a] Source many :: Maybe a -> Maybe [a] Source
Alternative IO |
Methods empty :: IO a Source (<|>) :: IO a -> IO a -> IO a Source some :: IO a -> IO [a] Source many :: IO a -> IO [a] Source
Alternative ReadP |
Methods empty :: ReadP a Source (<|>) :: ReadP a -> ReadP a -> ReadP a Source some :: ReadP a -> ReadP [a] Source many :: ReadP a -> ReadP [a] Source
Alternative ReadPrec |
Methods empty :: ReadPrec a Source (<|>) :: ReadPrec a -> ReadPrec a -> ReadPrec a Source some :: ReadPrec a -> ReadPrec [a] Source many :: ReadPrec a -> ReadPrec [a] Source
Alternative STM |
Methods empty :: STM a Source (<|>) :: STM a -> STM a -> STM a Source some :: STM a -> STM [a] Source many :: STM a -> STM [a] Source
Alternative Option |
Methods empty :: Option a Source (<|>) :: Option a -> Option a -> Option a Source some :: Option a -> Option [a] Source many :: Option a -> Option [a] Source
ArrowPlus a => Alternative (ArrowMonad a) |
Methods empty :: ArrowMonad a a Source (<|>) :: ArrowMonad a a -> ArrowMonad a a -> ArrowMonad a a Source some :: ArrowMonad a a -> ArrowMonad a [a] Source many :: ArrowMonad a a -> ArrowMonad a [a] Source
MonadPlus m => Alternative (WrappedMonad m) |
Methods empty :: WrappedMonad m a Source (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source some :: WrappedMonad m a -> WrappedMonad m [a] Source many :: WrappedMonad m a -> WrappedMonad m [a] Source
Alternative f => Alternative (Alt (TYPE Lifted) f) |
Methods empty :: Alt (TYPE Lifted) f a Source (<|>) :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f a Source some :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f [a] Source many :: Alt (TYPE Lifted) f a -> Alt (TYPE Lifted) f [a] Source
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) |
Methods empty :: WrappedArrow a b a Source (<|>) :: WrappedArrow a b a -> WrappedArrow a b a -> WrappedArrow a b a Source some :: WrappedArrow a b a -> WrappedArrow a b [a] Source many :: WrappedArrow a b a -> WrappedArrow a b [a] Source
(Alternative f, Alternative g) => Alternative (Product (TYPE Lifted) f g) |
Methods empty :: Product (TYPE Lifted) f g a Source (<|>) :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g a Source some :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g [a] Source many :: Product (TYPE Lifted) f g a -> Product (TYPE Lifted) f g [a] Source
(Alternative f, Applicative g) => Alternative (Compose (TYPE Lifted) (TYPE Lifted) f g) |
Methods empty :: Compose (TYPE Lifted) (TYPE Lifted) f g a Source (<|>) :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g a Source some :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g [a] Source many :: Compose (TYPE Lifted) (TYPE Lifted) f g a -> Compose (TYPE Lifted) (TYPE Lifted) f g [a] Source

# Instances

newtype Const a b Source

The `Const` functor.

Constructors

Const |
Fields getConst :: a

Instances

Bifunctor (Const (TYPE Lifted)) |
Methods bimap :: (a -> b) -> (c -> d) -> Const (TYPE Lifted) a c -> Const (TYPE Lifted) b d Source first :: (a -> b) -> Const (TYPE Lifted) a c -> Const (TYPE Lifted) b c Source second :: (b -> c) -> Const (TYPE Lifted) a b -> Const (TYPE Lifted) a c Source
Show2 (Const (TYPE Lifted)) |
Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const (TYPE Lifted) a b -> ShowS Source liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const (TYPE Lifted) a b] -> ShowS Source
Read2 (Const (TYPE Lifted)) |
Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const (TYPE Lifted) a b) Source liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const (TYPE Lifted) a b] Source
Ord2 (Const (TYPE Lifted)) |
Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const (TYPE Lifted) a c -> Const (TYPE Lifted) b d -> Ordering Source
Eq2 (Const (TYPE Lifted)) |
Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const (TYPE Lifted) a c -> Const (TYPE Lifted) b d -> Bool Source
Functor (Const (TYPE Lifted) m) |
Methods fmap :: (a -> b) -> Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b Source (<$) :: a -> Const (TYPE Lifted) m b -> Const (TYPE Lifted) m a Source
Monoid m => Applicative (Const (TYPE Lifted) m) |
Methods pure :: a -> Const (TYPE Lifted) m a Source (<*>) :: Const (TYPE Lifted) m (a -> b) -> Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b Source (*>) :: Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b -> Const (TYPE Lifted) m b Source (<*) :: Const (TYPE Lifted) m a -> Const (TYPE Lifted) m b -> Const (TYPE Lifted) m a Source
Foldable (Const (TYPE Lifted) m) |
Methods fold :: Monoid m => Const (TYPE Lifted) m m -> m Source foldMap :: Monoid m => (a -> m) -> Const (TYPE Lifted) m a -> m Source foldr :: (a -> b -> b) -> b -> Const (TYPE Lifted) m a -> b Source foldr' :: (a -> b -> b) -> b -> Const (TYPE Lifted) m a -> b Source foldl :: (b -> a -> b) -> b -> Const (TYPE Lifted) m a -> b Source foldl' :: (b -> a -> b) -> b -> Const (TYPE Lifted) m a -> b Source foldr1 :: (a -> a -> a) -> Const (TYPE Lifted) m a -> a Source foldl1 :: (a -> a -> a) -> Const (TYPE Lifted) m a -> a Source toList :: Const (TYPE Lifted) m a -> [a] Source null :: Const (TYPE Lifted) m a -> Bool Source length :: Const (TYPE Lifted) m a -> Int Source elem :: Eq a => a -> Const (TYPE Lifted) m a -> Bool Source maximum :: Ord a => Const (TYPE Lifted) m a -> a Source minimum :: Ord a => Const (TYPE Lifted) m a -> a Source sum :: Num a => Const (TYPE Lifted) m a -> a Source product :: Num a => Const (TYPE Lifted) m a -> a Source
Traversable (Const (TYPE Lifted) m) |
Methods traverse :: Applicative f => (a -> f b) -> Const (TYPE Lifted) m a -> f (Const (TYPE Lifted) m b) Source sequenceA :: Applicative f => Const (TYPE Lifted) m (f a) -> f (Const (TYPE Lifted) m a) Source mapM :: Monad m => (a -> m b) -> Const (TYPE Lifted) m a -> m (Const (TYPE Lifted) m b) Source sequence :: Monad m => Const (TYPE Lifted) m (m a) -> m (Const (TYPE Lifted) m a) Source
Generic1 (Const (TYPE Lifted) a) |
Associated Types type Rep1 (Const (TYPE Lifted) a :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: Const (TYPE Lifted) a a -> Rep1 (Const (TYPE Lifted) a) a Source to1 :: Rep1 (Const (TYPE Lifted) a) a -> Const (TYPE Lifted) a a Source
Show a => Show1 (Const (TYPE Lifted) a) |
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Const (TYPE Lifted) a a -> ShowS Source liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Const (TYPE Lifted) a a] -> ShowS Source
Read a => Read1 (Const (TYPE Lifted) a) |
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Const (TYPE Lifted) a a) Source liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Const (TYPE Lifted) a a] Source
Ord a => Ord1 (Const (TYPE Lifted) a) |
Methods liftCompare :: (a -> b -> Ordering) -> Const (TYPE Lifted) a a -> Const (TYPE Lifted) a b -> Ordering Source
Eq a => Eq1 (Const (TYPE Lifted) a) |
Methods liftEq :: (a -> b -> Bool) -> Const (TYPE Lifted) a a -> Const (TYPE Lifted) a b -> Bool Source
Bounded a => Bounded (Const k a b) |
Methods minBound :: Const k a b Source maxBound :: Const k a b Source
Enum a => Enum (Const k a b) |
Methods succ :: Const k a b -> Const k a b Source pred :: Const k a b -> Const k a b Source toEnum :: Int -> Const k a b Source fromEnum :: Const k a b -> Int Source enumFrom :: Const k a b -> [Const k a b] Source enumFromThen :: Const k a b -> Const k a b -> [Const k a b] Source enumFromTo :: Const k a b -> Const k a b -> [Const k a b] Source enumFromThenTo :: Const k a b -> Const k a b -> Const k a b -> [Const k a b] Source
Eq a => Eq (Const k a b) |
Methods (==) :: Const k a b -> Const k a b -> Bool Source (/=) :: Const k a b -> Const k a b -> Bool Source
Ord a => Ord (Const k a b) |
Methods compare :: Const k a b -> Const k a b -> Ordering Source (<) :: Const k a b -> Const k a b -> Bool Source (<=) :: Const k a b -> Const k a b -> Bool Source (>) :: Const k a b -> Const k a b -> Bool Source (>=) :: Const k a b -> Const k a b -> Bool Source max :: Const k a b -> Const k a b -> Const k a b Source min :: Const k a b -> Const k a b -> Const k a b Source
Read a => Read (Const k a b) | This instance would be equivalent to the derived instances of the `Const` newtype if the `runConst` field were removed
Methods readsPrec :: Int -> ReadS (Const k a b) Source readList :: ReadS [Const k a b] Source readPrec :: ReadPrec (Const k a b) Source readListPrec :: ReadPrec [Const k a b] Source
Show a => Show (Const k a b) | This instance would be equivalent to the derived instances of the `Const` newtype if the `runConst` field were removed
Methods showsPrec :: Int -> Const k a b -> ShowS Source show :: Const k a b -> String Source showList :: [Const k a b] -> ShowS Source
Ix a => Ix (Const k a b) |
Methods range :: (Const k a b, Const k a b) -> [Const k a b] Source index :: (Const k a b, Const k a b) -> Const k a b -> Int Source unsafeIndex :: (Const k a b, Const k a b) -> Const k a b -> Int inRange :: (Const k a b, Const k a b) -> Const k a b -> Bool Source rangeSize :: (Const k a b, Const k a b) -> Int Source unsafeRangeSize :: (Const k a b, Const k a b) -> Int
Generic (Const k a b) |
Associated Types type Rep (Const k a b) :: * -> * Source Methods from :: Const k a b -> Rep (Const k a b) x Source to :: Rep (Const k a b) x -> Const k a b Source
Semigroup a => Semigroup (Const k a b) |
Methods (<>) :: Const k a b -> Const k a b -> Const k a b Source sconcat :: NonEmpty (Const k a b) -> Const k a b Source stimes :: Integral b => b -> Const k a b -> Const k a b Source
Monoid a => Monoid (Const k a b) |
Methods mempty :: Const k a b Source mappend :: Const k a b -> Const k a b -> Const k a b Source mconcat :: [Const k a b] -> Const k a b Source
Storable a => Storable (Const k a b) |
Methods sizeOf :: Const k a b -> Int Source alignment :: Const k a b -> Int Source peekElemOff :: Ptr (Const k a b) -> Int -> IO (Const k a b) Source pokeElemOff :: Ptr (Const k a b) -> Int -> Const k a b -> IO () Source peekByteOff :: Ptr b -> Int -> IO (Const k a b) Source pokeByteOff :: Ptr b -> Int -> Const k a b -> IO () Source peek :: Ptr (Const k a b) -> IO (Const k a b) Source poke :: Ptr (Const k a b) -> Const k a b -> IO () Source
type Rep1 (Const k a) = D1 (MetaData "Const" "Data.Functor.Const" "base" True) (C1 (MetaCons "Const" PrefixI True) (S1 (MetaSel (Just Symbol "getConst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) |
type Rep (Const k a b) = D1 (MetaData "Const" "Data.Functor.Const" "base" True) (C1 (MetaCons "Const" PrefixI True) (S1 (MetaSel (Just Symbol "getConst") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a))) |

newtype WrappedMonad m a Source

Constructors

WrapMonad |
Fields unwrapMonad :: m a

Instances

Monad m => Monad (WrappedMonad m) |
Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b Source (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source return :: a -> WrappedMonad m a Source fail :: String -> WrappedMonad m a Source
Monad m => Functor (WrappedMonad m) |
Methods fmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source (<$) :: a -> WrappedMonad m b -> WrappedMonad m a Source
Monad m => Applicative (WrappedMonad m) |
Methods pure :: a -> WrappedMonad m a Source (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b Source (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a Source
Generic1 (WrappedMonad m) |
Associated Types type Rep1 (WrappedMonad m :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a Source to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a Source
MonadPlus m => Alternative (WrappedMonad m) |
Methods empty :: WrappedMonad m a Source (<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a Source some :: WrappedMonad m a -> WrappedMonad m [a] Source many :: WrappedMonad m a -> WrappedMonad m [a] Source
Generic (WrappedMonad m a) |
Associated Types type Rep (WrappedMonad m a) :: * -> * Source Methods from :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source
type Rep1 (WrappedMonad m) = D1 (MetaData "WrappedMonad" "Control.Applicative" "base" True) (C1 (MetaCons "WrapMonad" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapMonad") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 m))) |
type Rep (WrappedMonad m a) = D1 (MetaData "WrappedMonad" "Control.Applicative" "base" True) (C1 (MetaCons "WrapMonad" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapMonad") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (m a)))) |

newtype WrappedArrow a b c Source

Constructors

WrapArrow |
Fields unwrapArrow :: a b c

Instances

Arrow a => Functor (WrappedArrow a b) |
Methods fmap :: (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b Source (<$) :: a -> WrappedArrow a b b -> WrappedArrow a b a Source
Arrow a => Applicative (WrappedArrow a b) |
Methods pure :: a -> WrappedArrow a b a Source (<*>) :: WrappedArrow a b (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b Source (*>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b Source (<*) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b a Source
Generic1 (WrappedArrow a b) |
Associated Types type Rep1 (WrappedArrow a b :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: WrappedArrow a b a -> Rep1 (WrappedArrow a b) a Source to1 :: Rep1 (WrappedArrow a b) a -> WrappedArrow a b a Source
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) |
Methods empty :: WrappedArrow a b a Source (<|>) :: WrappedArrow a b a -> WrappedArrow a b a -> WrappedArrow a b a Source some :: WrappedArrow a b a -> WrappedArrow a b [a] Source many :: WrappedArrow a b a -> WrappedArrow a b [a] Source
Generic (WrappedArrow a b c) |
Associated Types type Rep (WrappedArrow a b c) :: * -> * Source Methods from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x Source to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c Source
type Rep1 (WrappedArrow a b) = D1 (MetaData "WrappedArrow" "Control.Applicative" "base" True) (C1 (MetaCons "WrapArrow" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 (a b)))) |
type Rep (WrappedArrow a b c) = D1 (MetaData "WrappedArrow" "Control.Applicative" "base" True) (C1 (MetaCons "WrapArrow" PrefixI True) (S1 (MetaSel (Just Symbol "unwrapArrow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (a b c)))) |

newtype ZipList a Source

Lists, but with an `Applicative` functor based on zipping, so that

    f <$> ZipList xs1 <*> ... <*> ZipList xsn = ZipList (zipWithn f xs1 ... xsn)

Constructors

ZipList |
Fields getZipList :: [a]

Instances

Functor ZipList |
Methods fmap :: (a -> b) -> ZipList a -> ZipList b Source (<$) :: a -> ZipList b -> ZipList a Source
Applicative ZipList |
Methods pure :: a -> ZipList a Source (<*>) :: ZipList (a -> b) -> ZipList a -> ZipList b Source (*>) :: ZipList a -> ZipList b -> ZipList b Source (<*) :: ZipList a -> ZipList b -> ZipList a Source
Foldable ZipList |
Methods fold :: Monoid m => ZipList m -> m Source foldMap :: Monoid m => (a -> m) -> ZipList a -> m Source foldr :: (a -> b -> b) -> b -> ZipList a -> b Source foldr' :: (a -> b -> b) -> b -> ZipList a -> b Source foldl :: (b -> a -> b) -> b -> ZipList a -> b Source foldl' :: (b -> a -> b) -> b -> ZipList a -> b Source foldr1 :: (a -> a -> a) -> ZipList a -> a Source foldl1 :: (a -> a -> a) -> ZipList a -> a Source toList :: ZipList a -> [a] Source null :: ZipList a -> Bool Source length :: ZipList a -> Int Source elem :: Eq a => a -> ZipList a -> Bool Source maximum :: Ord a => ZipList a -> a Source minimum :: Ord a => ZipList a -> a Source sum :: Num a => ZipList a -> a Source product :: Num a => ZipList a -> a Source
Traversable ZipList |
Methods traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b) Source sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a) Source mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b) Source sequence :: Monad m => ZipList (m a) -> m (ZipList a) Source
Generic1 ZipList |
Associated Types type Rep1 (ZipList :: * -> TYPE Lifted) :: * -> * Source Methods from1 :: ZipList a -> Rep1 ZipList a Source to1 :: Rep1 ZipList a -> ZipList a Source
Eq a => Eq (ZipList a) |
Methods (==) :: ZipList a -> ZipList a -> Bool Source (/=) :: ZipList a -> ZipList a -> Bool Source
Ord a => Ord (ZipList a) |
Methods compare :: ZipList a -> ZipList a -> Ordering Source (<) :: ZipList a -> ZipList a -> Bool Source (<=) :: ZipList a -> ZipList a -> Bool Source (>) :: ZipList a -> ZipList a -> Bool Source (>=) :: ZipList a -> ZipList a -> Bool Source max :: ZipList a -> ZipList a -> ZipList a Source min :: ZipList a -> ZipList a -> ZipList a Source
Read a => Read (ZipList a) |
Methods readsPrec :: Int -> ReadS (ZipList a) Source readList :: ReadS [ZipList a] Source readPrec :: ReadPrec (ZipList a) Source readListPrec :: ReadPrec [ZipList a] Source
Show a => Show (ZipList a) |
Methods showsPrec :: Int -> ZipList a -> ShowS Source show :: ZipList a -> String Source showList :: [ZipList a] -> ShowS Source
Generic (ZipList a) |
Associated Types type Rep (ZipList a) :: * -> * Source Methods from :: ZipList a -> Rep (ZipList a) x Source to :: Rep (ZipList a) x -> ZipList a Source
type Rep1 ZipList = D1 (MetaData "ZipList" "Control.Applicative" "base" True) (C1 (MetaCons "ZipList" PrefixI True) (S1 (MetaSel (Just Symbol "getZipList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec1 []))) |
type Rep (ZipList a) = D1 (MetaData "ZipList" "Control.Applicative" "base" True) (C1 (MetaCons "ZipList" PrefixI True) (S1 (MetaSel (Just Symbol "getZipList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 [a]))) |

# Utility functions

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

An infix synonym for `fmap`.

#### Examples

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

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

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

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

Double each element of a list:

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

Apply `even` to the second element of a pair:

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

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

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.

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

A variant of `<*>` with the arguments reversed.

liftA :: Applicative f => (a -> b) -> f a -> f b Source

Lift a function to actions. This function may be used as a value for `fmap` in a `Functor` instance.

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c Source

Lift a binary function to actions.

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d Source

Lift a ternary function to actions.

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

One or none.