base-4.9.1.0: Basic libraries

Control.Applicative

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

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 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  Source # Methodspure :: a -> [a] Source #(<*>) :: [a -> b] -> [a] -> [b] Source #(*>) :: [a] -> [b] -> [b] Source #(<*) :: [a] -> [b] -> [a] Source # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: a -> U1 a Source #(<*>) :: U1 (a -> b) -> U1 a -> U1 b Source #(*>) :: U1 a -> U1 b -> U1 b Source #(<*) :: U1 a -> U1 b -> U1 a Source # Source # Methodspure :: a -> Par1 a Source #(<*>) :: Par1 (a -> b) -> Par1 a -> Par1 b Source #(*>) :: Par1 a -> Par1 b -> Par1 b Source #(<*) :: Par1 a -> Par1 b -> Par1 a Source # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: 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) Source # Methodspure :: 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 # Source # Methodspure :: 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 # Applicative f => Applicative (Rec1 f) Source # Methodspure :: a -> Rec1 f a Source #(<*>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b Source #(*>) :: Rec1 f a -> Rec1 f b -> Rec1 f b Source #(<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a Source # Monoid a => Applicative ((,) a) Source # Methodspure :: 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 # Source # Methodspure :: 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 # Source # Methodspure :: a -> Proxy * a Source #(<*>) :: Proxy * (a -> b) -> Proxy * a -> Proxy * b Source #(*>) :: Proxy * a -> Proxy * b -> Proxy * b Source #(<*) :: Proxy * a -> Proxy * b -> Proxy * a Source # Arrow a => Applicative (ArrowMonad a) Source # Methodspure :: 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) Source # Methodspure :: 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 # Source # Methodspure :: 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 g) => Applicative ((:*:) f g) Source # Methodspure :: a -> (f :*: g) a Source #(<*>) :: (f :*: g) (a -> b) -> (f :*: g) a -> (f :*: g) b Source #(*>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b Source #(<*) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) a Source # (Applicative f, Applicative g) => Applicative ((:.:) f g) Source # Methodspure :: a -> (f :.: g) a Source #(<*>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b Source #(*>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b Source #(<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a Source # Applicative f => Applicative (Alt * f) Source # Methodspure :: a -> Alt * f a Source #(<*>) :: Alt * f (a -> b) -> Alt * f a -> Alt * f b Source #(*>) :: Alt * f a -> Alt * f b -> Alt * f b Source #(<*) :: Alt * f a -> Alt * f b -> Alt * f a Source # Monoid m => Applicative (Const * m) Source # Methodspure :: a -> Const * m a Source #(<*>) :: Const * m (a -> b) -> Const * m a -> Const * m b Source #(*>) :: Const * m a -> Const * m b -> Const * m b Source #(<*) :: Const * m a -> Const * m b -> Const * m a Source # Arrow a => Applicative (WrappedArrow a b) Source # Methodspure :: 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 (M1 i c f) Source # Methodspure :: a -> M1 i c f a Source #(<*>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b Source #(*>) :: M1 i c f a -> M1 i c f b -> M1 i c f b Source #(<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a Source # (Applicative f, Applicative g) => Applicative (Product * f g) Source # Methodspure :: a -> Product * f g a Source #(<*>) :: Product * f g (a -> b) -> Product * f g a -> Product * f g b Source #(*>) :: Product * f g a -> Product * f g b -> Product * f g b Source #(<*) :: Product * f g a -> Product * f g b -> Product * f g a Source # (Applicative f, Applicative g) => Applicative (Compose * * f g) Source # Methodspure :: a -> Compose * * f g a Source #(<*>) :: Compose * * f g (a -> b) -> Compose * * f g a -> Compose * * f g b Source #(*>) :: Compose * * f g a -> Compose * * f g b -> Compose * * f g b Source #(<*) :: Compose * * f g a -> Compose * * f g b -> Compose * * 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

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

Instances

newtype Const a b Source #

The Const functor.

Constructors

 Const FieldsgetConst :: a

Instances

 Source # Methodsbimap :: (a -> b) -> (c -> d) -> Const * a c -> Const * b d Source #first :: (a -> b) -> Const * a c -> Const * b c Source #second :: (b -> c) -> Const * a b -> Const * a c Source # Source # MethodsliftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const * a b -> ShowS Source #liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const * a b] -> ShowS Source # Source # MethodsliftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const * a b) Source #liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const * a b] Source # Source # MethodsliftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const * a c -> Const * b d -> Ordering Source # Source # MethodsliftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const * a c -> Const * b d -> Bool Source # Source # Methodsfmap :: (a -> b) -> Const * m a -> Const * m b Source #(<) :: a -> Const * m b -> Const * m a Source # Monoid m => Applicative (Const * m) Source # Methodspure :: a -> Const * m a Source #(<*>) :: Const * m (a -> b) -> Const * m a -> Const * m b Source #(*>) :: Const * m a -> Const * m b -> Const * m b Source #(<*) :: Const * m a -> Const * m b -> Const * m a Source # Source # Methodsfold :: Monoid m => Const * m m -> m Source #foldMap :: Monoid m => (a -> m) -> Const * m a -> m Source #foldr :: (a -> b -> b) -> b -> Const * m a -> b Source #foldr' :: (a -> b -> b) -> b -> Const * m a -> b Source #foldl :: (b -> a -> b) -> b -> Const * m a -> b Source #foldl' :: (b -> a -> b) -> b -> Const * m a -> b Source #foldr1 :: (a -> a -> a) -> Const * m a -> a Source #foldl1 :: (a -> a -> a) -> Const * m a -> a Source #toList :: Const * m a -> [a] Source #null :: Const * m a -> Bool Source #length :: Const * m a -> Int Source #elem :: Eq a => a -> Const * m a -> Bool Source #maximum :: Ord a => Const * m a -> a Source #minimum :: Ord a => Const * m a -> a Source #sum :: Num a => Const * m a -> a Source #product :: Num a => Const * m a -> a Source # Source # Methodstraverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b) Source #sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a) Source #mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b) Source #sequence :: Monad m => Const * m (m a) -> m (Const * m a) Source # Source # Associated Typestype Rep1 (Const * a :: * -> *) :: * -> * Source # Methodsfrom1 :: Const * a a -> Rep1 (Const * a) a Source #to1 :: Rep1 (Const * a) a -> Const * a a Source # Show a => Show1 (Const * a) Source # MethodsliftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Const * a a -> ShowS Source #liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Const * a a] -> ShowS Source # Read a => Read1 (Const * a) Source # MethodsliftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Const * a a) Source #liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Const * a a] Source # Ord a => Ord1 (Const * a) Source # MethodsliftCompare :: (a -> b -> Ordering) -> Const * a a -> Const * a b -> Ordering Source # Eq a => Eq1 (Const * a) Source # MethodsliftEq :: (a -> b -> Bool) -> Const * a a -> Const * a b -> Bool Source # Bounded a => Bounded (Const k a b) Source # MethodsminBound :: Const k a b Source #maxBound :: Const k a b Source # Enum a => Enum (Const k a b) Source # Methodssucc :: 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) Source # Methods(==) :: Const k a b -> Const k a b -> Bool #(/=) :: Const k a b -> Const k a b -> Bool # Floating a => Floating (Const k a b) Source # Methodspi :: Const k a b Source #exp :: Const k a b -> Const k a b Source #log :: Const k a b -> Const k a b Source #sqrt :: Const k a b -> Const k a b Source #(**) :: Const k a b -> Const k a b -> Const k a b Source #logBase :: Const k a b -> Const k a b -> Const k a b Source #sin :: Const k a b -> Const k a b Source #cos :: Const k a b -> Const k a b Source #tan :: Const k a b -> Const k a b Source #asin :: Const k a b -> Const k a b Source #acos :: Const k a b -> Const k a b Source #atan :: Const k a b -> Const k a b Source #sinh :: Const k a b -> Const k a b Source #cosh :: Const k a b -> Const k a b Source #tanh :: Const k a b -> Const k a b Source #asinh :: Const k a b -> Const k a b Source #acosh :: Const k a b -> Const k a b Source #atanh :: Const k a b -> Const k a b Source #log1p :: Const k a b -> Const k a b Source #expm1 :: Const k a b -> Const k a b Source #log1pexp :: Const k a b -> Const k a b Source #log1mexp :: Const k a b -> Const k a b Source # Fractional a => Fractional (Const k a b) Source # Methods(/) :: Const k a b -> Const k a b -> Const k a b Source #recip :: Const k a b -> Const k a b Source #fromRational :: Rational -> Const k a b Source # Integral a => Integral (Const k a b) Source # Methodsquot :: Const k a b -> Const k a b -> Const k a b Source #rem :: Const k a b -> Const k a b -> Const k a b Source #div :: Const k a b -> Const k a b -> Const k a b Source #mod :: Const k a b -> Const k a b -> Const k a b Source #quotRem :: Const k a b -> Const k a b -> (Const k a b, Const k a b) Source #divMod :: Const k a b -> Const k a b -> (Const k a b, Const k a b) Source #toInteger :: Const k a b -> Integer Source # Num a => Num (Const k a b) Source # Methods(+) :: Const k a b -> Const k a b -> Const k a b Source #(-) :: Const k a b -> Const k a b -> Const k a b Source #(*) :: Const k a b -> Const k a b -> Const k a b Source #negate :: Const k a b -> Const k a b Source #abs :: Const k a b -> Const k a b Source #signum :: Const k a b -> Const k a b Source #fromInteger :: Integer -> Const k a b Source # Ord a => Ord (Const k a b) Source # Methodscompare :: Const k a b -> Const k a b -> Ordering #(<) :: Const k a b -> Const k a b -> Bool #(<=) :: Const k a b -> Const k a b -> Bool #(>) :: Const k a b -> Const k a b -> Bool #(>=) :: Const k a b -> Const k a b -> Bool #max :: Const k a b -> Const k a b -> Const k a b #min :: Const k a b -> Const k a b -> Const k a b # Read a => Read (Const k a b) Source # This instance would be equivalent to the derived instances of the Const newtype if the runConst field were removed MethodsreadsPrec :: 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 # Real a => Real (Const k a b) Source # MethodstoRational :: Const k a b -> Rational Source # RealFloat a => RealFloat (Const k a b) Source # MethodsfloatRadix :: Const k a b -> Integer Source #floatDigits :: Const k a b -> Int Source #floatRange :: Const k a b -> (Int, Int) Source #decodeFloat :: Const k a b -> (Integer, Int) Source #encodeFloat :: Integer -> Int -> Const k a b Source #exponent :: Const k a b -> Int Source #significand :: Const k a b -> Const k a b Source #scaleFloat :: Int -> Const k a b -> Const k a b Source #isNaN :: Const k a b -> Bool Source #isInfinite :: Const k a b -> Bool Source #isDenormalized :: Const k a b -> Bool Source #isNegativeZero :: Const k a b -> Bool Source #isIEEE :: Const k a b -> Bool Source #atan2 :: Const k a b -> Const k a b -> Const k a b Source # RealFrac a => RealFrac (Const k a b) Source # MethodsproperFraction :: Integral b => Const k a b -> (b, Const k a b) Source #truncate :: Integral b => Const k a b -> b Source #round :: Integral b => Const k a b -> b Source #ceiling :: Integral b => Const k a b -> b Source #floor :: Integral b => Const k a b -> b Source # Show a => Show (Const k a b) Source # This instance would be equivalent to the derived instances of the Const newtype if the runConst field were removed MethodsshowsPrec :: 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) Source # Methodsrange :: (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 -> IntinRange :: (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 IsString a => IsString (Const * a b) Source # Methods Generic (Const k a b) Source # Associated Typestype Rep (Const k a b) :: * -> * Source # Methodsfrom :: 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) Source # 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) Source # Methodsmempty :: 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 # FiniteBits a => FiniteBits (Const k a b) Source # MethodsfiniteBitSize :: Const k a b -> Int Source #countLeadingZeros :: Const k a b -> Int Source #countTrailingZeros :: Const k a b -> Int Source # Bits a => Bits (Const k a b) Source # Methods(.&.) :: Const k a b -> Const k a b -> Const k a b Source #(.|.) :: Const k a b -> Const k a b -> Const k a b Source #xor :: Const k a b -> Const k a b -> Const k a b Source #complement :: Const k a b -> Const k a b Source #shift :: Const k a b -> Int -> Const k a b Source #rotate :: Const k a b -> Int -> Const k a b Source #zeroBits :: Const k a b Source #bit :: Int -> Const k a b Source #setBit :: Const k a b -> Int -> Const k a b Source #clearBit :: Const k a b -> Int -> Const k a b Source #complementBit :: Const k a b -> Int -> Const k a b Source #testBit :: Const k a b -> Int -> Bool Source #bitSizeMaybe :: Const k a b -> Maybe Int Source #bitSize :: Const k a b -> Int Source #isSigned :: Const k a b -> Bool Source #shiftL :: Const k a b -> Int -> Const k a b Source #unsafeShiftL :: Const k a b -> Int -> Const k a b Source #shiftR :: Const k a b -> Int -> Const k a b Source #unsafeShiftR :: Const k a b -> Int -> Const k a b Source #rotateL :: Const k a b -> Int -> Const k a b Source #rotateR :: Const k a b -> Int -> Const k a b Source #popCount :: Const k a b -> Int Source # Storable a => Storable (Const k a b) Source # MethodssizeOf :: 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 * a) Source # type Rep1 (Const * 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) Source # 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 FieldsunwrapMonad :: m a Instances  Monad m => Monad (WrappedMonad m) Source # 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 # Monad m => Functor (WrappedMonad m) Source # Methodsfmap :: (a -> b) -> WrappedMonad m a -> WrappedMonad m b Source #(<) :: a -> WrappedMonad m b -> WrappedMonad m a Source # Monad m => Applicative (WrappedMonad m) Source # Methodspure :: 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 # Source # Associated Typestype Rep1 (WrappedMonad m :: * -> *) :: * -> * Source # Methodsfrom1 :: WrappedMonad m a -> Rep1 (WrappedMonad m) a Source #to1 :: Rep1 (WrappedMonad m) a -> WrappedMonad m a Source # Source # Methods(<|>) :: 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) Source # Associated Typestype Rep (WrappedMonad m a) :: * -> * Source # Methodsfrom :: WrappedMonad m a -> Rep (WrappedMonad m a) x Source #to :: Rep (WrappedMonad m a) x -> WrappedMonad m a Source # type Rep1 (WrappedMonad m) 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) Source # 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 FieldsunwrapArrow :: a b c

Instances

 Arrow a => Functor (WrappedArrow a b) Source # Methodsfmap :: (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) Source # Methodspure :: 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) Source # Associated Typestype Rep1 (WrappedArrow a b :: * -> *) :: * -> * Source # Methodsfrom1 :: 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) Source # Methodsempty :: 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) Source # Associated Typestype Rep (WrappedArrow a b c) :: * -> * Source # Methodsfrom :: 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) 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) Source # 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 FieldsgetZipList :: [a]

Instances

 Source # Methodsfmap :: (a -> b) -> ZipList a -> ZipList b Source #(<$) :: a -> ZipList b -> ZipList a Source # Source # Methodspure :: 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 # Source # Methodsfold :: 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 # Source # Methodstraverse :: 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 # Source # Associated Typestype Rep1 (ZipList :: * -> *) :: * -> * Source # Methodsto1 :: Rep1 ZipList a -> ZipList a Source # Eq a => Eq (ZipList a) Source # Methods(==) :: ZipList a -> ZipList a -> Bool #(/=) :: ZipList a -> ZipList a -> Bool # Ord a => Ord (ZipList a) Source # Methodscompare :: ZipList a -> ZipList a -> Ordering #(<) :: ZipList a -> ZipList a -> Bool #(<=) :: ZipList a -> ZipList a -> Bool #(>) :: ZipList a -> ZipList a -> Bool #(>=) :: ZipList a -> ZipList a -> Bool #max :: ZipList a -> ZipList a -> ZipList a #min :: ZipList a -> ZipList a -> ZipList a # Read a => Read (ZipList a) Source # Methods Show a => Show (ZipList a) Source # MethodsshowsPrec :: Int -> ZipList a -> ShowS Source #show :: ZipList a -> String Source #showList :: [ZipList a] -> ShowS Source # Source # Associated Typestype Rep (ZipList a) :: * -> * Source # Methodsfrom :: ZipList a -> Rep (ZipList a) x Source #to :: Rep (ZipList a) x -> ZipList a Source # type Rep1 ZipList 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) Source # 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.

The name of this operator is an allusion to $. Note the similarities between their types:  ($)  ::              (a -> b) ->   a ->   b
(<$>) :: Functor f => (a -> b) -> f a -> f b Whereas $ is function application, <$> is function application lifted over a Functor. Examples Convert from a Maybe Int to a Maybe String using show: >>> show <$> Nothing
Nothing
>>> show <$> Just 3 Just "3"  Convert from an Either Int Int to an Either Int String using show: >>> show <$> Left 17
Left 17
>>> show <$> Right 17 Right "17"  Double each element of a list: >>> (*2) <$> [1,2,3]
[2,4,6]


Apply even to the second element of a pair:

>>> even <$> (2,2) (2,True)  (<$) :: 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.