Precursor.Control.Applicative

Applicative functors

class Functor f => Applicative f where

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

Lift a value.

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

Sequential application.

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

Sequence actions, discarding the value of the first argument.

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

Sequence actions, discarding the value of the second argument.

Instances

Applicative []

Methods

pure :: a -> [a]

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

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

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

Applicative Maybe

Methods

pure :: a -> Maybe a

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

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

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

Applicative IO

Methods

pure :: a -> IO a

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

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

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

Applicative U1

Methods

pure :: a -> U1 a

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

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

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

Applicative Par1

Methods

pure :: a -> Par1 a

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

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

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

Applicative Q

Methods

pure :: a -> Q a

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

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

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

Applicative Id

Methods

pure :: a -> Id a

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

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

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

Applicative Identity

Methods

pure :: a -> Identity a

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

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

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

Applicative Min

Methods

pure :: a -> Min a

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

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

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

Applicative Max

Methods

pure :: a -> Max a

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

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

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

Applicative First

Methods

pure :: a -> First a

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

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

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

Applicative Last

Methods

pure :: a -> Last a

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

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

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

Applicative Option

Methods

pure :: a -> Option a

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

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

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

Applicative NonEmpty

Methods

pure :: a -> NonEmpty a

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

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

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

Applicative Complex

Methods

pure :: a -> Complex a

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

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

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

Applicative ZipList

Methods

pure :: a -> ZipList a

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

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

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

Applicative Dual

Methods

pure :: a -> Dual a

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

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

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

Applicative Sum

Methods

pure :: a -> Sum a

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

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

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

Applicative Product

Methods

pure :: a -> Product a

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

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

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

Applicative First

Methods

pure :: a -> First a

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

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

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

Applicative Last

Methods

pure :: a -> Last a

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

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

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

Applicative Seq

Methods

pure :: a -> Seq a

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

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

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

Applicative Product

Methods

pure :: a -> Product a

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

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

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

Applicative Sum

Methods

pure :: a -> Sum a

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

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

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

Applicative ((->) a)

Methods

pure :: a -> a -> a

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

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

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

Applicative (Either e)

Methods

pure :: a -> Either e a

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

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

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

Applicative f => Applicative (Rec1 f)

Methods

pure :: a -> Rec1 f a

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

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

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

Monoid a => Applicative ((,) a)

Methods

pure :: a -> (a, a)

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

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

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

Applicative (StateL s)

Methods

pure :: a -> StateL s a

(<*>) :: StateL s (a -> b) -> StateL s a -> StateL s b

(*>) :: StateL s a -> StateL s b -> StateL s b

(<*) :: StateL s a -> StateL s b -> StateL s a

Applicative (StateR s)

Methods

pure :: a -> StateR s a

(<*>) :: StateR s (a -> b) -> StateR s a -> StateR s b

(*>) :: StateR s a -> StateR s b -> StateR s b

(<*) :: StateR s a -> StateR s b -> StateR s a

Monad m => Applicative (WrappedMonad m)

Methods

pure :: a -> WrappedMonad m a

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

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

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

Arrow a => Applicative (ArrowMonad a)

Methods

pure :: a -> ArrowMonad a a

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

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

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

Applicative (Proxy *)

Methods

pure :: a -> Proxy * a

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

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

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

Applicative (State s)

Methods

pure :: a -> State s a

(<*>) :: State s (a -> b) -> State s a -> State s b

(*>) :: State s a -> State s b -> State s b

(<*) :: State s a -> State s b -> State s a

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

Methods

pure :: a -> (f :*: g) a

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

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

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

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

Methods

pure :: a -> (f :.: g) a

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

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

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

Arrow a => Applicative (WrappedArrow a b)

Methods

pure :: a -> WrappedArrow a b a

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

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

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

Monoid m => Applicative (Const * m)

Methods

pure :: a -> Const * m a

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

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

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

Applicative f => Applicative (Alt * f)

Methods

pure :: a -> Alt * f a

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

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

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

(Functor m, Monad m) => Applicative (ErrorT e m)

Methods

pure :: a -> ErrorT e m a

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

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

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

(Functor m, Monad m) => Applicative (StateT s m)

Methods

pure :: a -> StateT s m a

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

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

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

Applicative (Tagged k s)

Methods

pure :: a -> Tagged k s a

(<*>) :: Tagged k s (a -> b) -> Tagged k s a -> Tagged k s b

(*>) :: Tagged k s a -> Tagged k s b -> Tagged k s b

(<*) :: Tagged k s a -> Tagged k s b -> Tagged k s a

Applicative f => Applicative (M1 i c f)

Methods

pure :: a -> M1 i c f a

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

(*>) :: 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

(Applicative f, Applicative g) => Applicative (Product * f g)

Methods

pure :: a -> Product * f g a

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

(*>) :: 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 (Compose * * f g)

Methods

pure :: a -> Compose * * f g a

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

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

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

pure :: Applicative f => forall a. a -> f a

Lift a value.

(<*>) :: Applicative f => forall a b. f (a -> b) -> f a -> f b

Sequential application.

(*>) :: Applicative f => forall a b. f a -> f b -> f b

Sequence actions, discarding the value of the first argument.

(<*) :: Applicative f => forall a b. f a -> f b -> f a

Sequence actions, discarding the value of the second argument.

Instances

newtype Const k a b :: forall k. * -> k -> *

The Const functor.

Constructors

Const

Fields

• getConst :: a

Instances

Eq2 (Const *)

Methods

liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Const * a c -> Const * b d -> Bool

Ord2 (Const *)

Methods

liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Const * a c -> Const * b d -> Ordering

Read2 (Const *)

Methods

liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Const * a b)

liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Const * a b]

Show2 (Const *)

Methods

liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Const * a b -> ShowS

liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Const * a b] -> ShowS

Bifunctor (Const *)

Methods

bimap :: (a -> b) -> (c -> d) -> Const * a c -> Const * b d

first :: (a -> b) -> Const * a c -> Const * b c

second :: (b -> c) -> Const * a b -> Const * a c

Functor (Const * m)

Methods

fmap :: (a -> b) -> Const * m a -> Const * m b

(<$) :: a -> Const * m b -> Const * m a

Monoid m => Applicative (Const * m)

Methods

pure :: a -> Const * m a

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

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

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

Foldable (Const * m)

Methods

fold :: Monoid m => Const * m m -> m

foldMap :: Monoid m => (a -> m) -> Const * m a -> m

foldr :: (a -> b -> b) -> b -> Const * m a -> b

foldr' :: (a -> b -> b) -> b -> Const * m a -> b

foldl :: (b -> a -> b) -> b -> Const * m a -> b

foldl' :: (b -> a -> b) -> b -> Const * m a -> b

foldr1 :: (a -> a -> a) -> Const * m a -> a

foldl1 :: (a -> a -> a) -> Const * m a -> a

toList :: Const * m a -> [a]

null :: Const * m a -> Bool

length :: Const * m a -> Int

elem :: Eq a => a -> Const * m a -> Bool

maximum :: Ord a => Const * m a -> a

minimum :: Ord a => Const * m a -> a

sum :: Num a => Const * m a -> a

product :: Num a => Const * m a -> a

Traversable (Const * m)

Methods

traverse :: Applicative f => (a -> f b) -> Const * m a -> f (Const * m b)

sequenceA :: Applicative f => Const * m (f a) -> f (Const * m a)

mapM :: Monad m => (a -> m b) -> Const * m a -> m (Const * m b)

sequence :: Monad m => Const * m (m a) -> m (Const * m a)

Generic1 (Const * a)

Associated Types

type Rep1 (Const * a :: * -> *) :: * -> *

Methods

from1 :: Const * a a -> Rep1 (Const * a) a

to1 :: Rep1 (Const * a) a -> Const * a a

Eq a => Eq1 (Const * a)

Methods

liftEq :: (a -> b -> Bool) -> Const * a a -> Const * a b -> Bool

Ord a => Ord1 (Const * a)

Methods

liftCompare :: (a -> b -> Ordering) -> Const * a a -> Const * a b -> Ordering

Read a => Read1 (Const * a)

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Const * a a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Const * a a]

Show a => Show1 (Const * a)

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Const * a a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Const * a a] -> ShowS

Bounded a => Bounded (Const k a b)

Methods

minBound :: Const k a b

maxBound :: Const k a b

Enum a => Enum (Const k a b)

Methods

succ :: Const k a b -> Const k a b

pred :: Const k a b -> Const k a b

toEnum :: Int -> Const k a b

fromEnum :: Const k a b -> Int

enumFrom :: Const k a b -> [Const k a b]

enumFromThen :: Const k a b -> Const k a b -> [Const k a b]

enumFromTo :: Const k a b -> Const k a b -> [Const k a b]

enumFromThenTo :: Const k a b -> Const k a b -> Const k a b -> [Const k a b]

Eq a => Eq (Const k a b)

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)

Methods

pi :: Const k a b

exp :: Const k a b -> Const k a b

log :: Const k a b -> Const k a b

sqrt :: Const k a b -> Const k a b

(**) :: Const k a b -> Const k a b -> Const k a b

logBase :: Const k a b -> Const k a b -> Const k a b

sin :: Const k a b -> Const k a b

cos :: Const k a b -> Const k a b

tan :: Const k a b -> Const k a b

asin :: Const k a b -> Const k a b

acos :: Const k a b -> Const k a b

atan :: Const k a b -> Const k a b

sinh :: Const k a b -> Const k a b

cosh :: Const k a b -> Const k a b

tanh :: Const k a b -> Const k a b

asinh :: Const k a b -> Const k a b

acosh :: Const k a b -> Const k a b

atanh :: Const k a b -> Const k a b

log1p :: Const k a b -> Const k a b

expm1 :: Const k a b -> Const k a b

log1pexp :: Const k a b -> Const k a b

log1mexp :: Const k a b -> Const k a b

Fractional a => Fractional (Const k a b)

Methods

(/) :: Const k a b -> Const k a b -> Const k a b

recip :: Const k a b -> Const k a b

fromRational :: Rational -> Const k a b

Integral a => Integral (Const k a b)

Methods

quot :: Const k a b -> Const k a b -> Const k a b

rem :: Const k a b -> Const k a b -> Const k a b

div :: Const k a b -> Const k a b -> Const k a b

mod :: Const k a b -> Const k a b -> Const k a b

quotRem :: Const k a b -> Const k a b -> (Const k a b, Const k a b)

divMod :: Const k a b -> Const k a b -> (Const k a b, Const k a b)

toInteger :: Const k a b -> Integer

Num a => Num (Const k a b)

Methods

(+) :: Const k a b -> Const k a b -> Const k a b

(-) :: Const k a b -> Const k a b -> Const k a b

(*) :: Const k a b -> Const k a b -> Const k a b

negate :: Const k a b -> Const k a b

abs :: Const k a b -> Const k a b

signum :: Const k a b -> Const k a b

fromInteger :: Integer -> Const k a b

Ord a => Ord (Const k a b)

Methods

compare :: 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)

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)

readList :: ReadS [Const k a b]

readPrec :: ReadPrec (Const k a b)

readListPrec :: ReadPrec [Const k a b]

Real a => Real (Const k a b)

Methods

toRational :: Const k a b -> Rational

RealFloat a => RealFloat (Const k a b)

Methods

floatRadix :: Const k a b -> Integer

floatDigits :: Const k a b -> Int

floatRange :: Const k a b -> (Int, Int)

decodeFloat :: Const k a b -> (Integer, Int)

encodeFloat :: Integer -> Int -> Const k a b

exponent :: Const k a b -> Int

significand :: Const k a b -> Const k a b

scaleFloat :: Int -> Const k a b -> Const k a b

isNaN :: Const k a b -> Bool

isInfinite :: Const k a b -> Bool

isDenormalized :: Const k a b -> Bool

isNegativeZero :: Const k a b -> Bool

isIEEE :: Const k a b -> Bool

atan2 :: Const k a b -> Const k a b -> Const k a b

RealFrac a => RealFrac (Const k a b)

Methods

properFraction :: Integral b => Const k a b -> (b, Const k a b)

truncate :: Integral b => Const k a b -> b

round :: Integral b => Const k a b -> b

ceiling :: Integral b => Const k a b -> b

floor :: Integral b => Const k a b -> b

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

show :: Const k a b -> String

showList :: [Const k a b] -> ShowS

Ix a => Ix (Const k a b)

Methods

range :: (Const k a b, Const k a b) -> [Const k a b]

index :: (Const k a b, Const k a b) -> Const k a b -> Int

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

rangeSize :: (Const k a b, Const k a b) -> Int

unsafeRangeSize :: (Const k a b, Const k a b) -> Int

IsString a => IsString (Const * a b)

Methods

fromString :: String -> Const * a b

Generic (Const k a b)

Associated Types

type Rep (Const k a b) :: * -> *

Methods

from :: Const k a b -> Rep (Const k a b) x

to :: Rep (Const k a b) x -> Const k a b

Semigroup a => Semigroup (Const k a b)

Methods

(<>) :: Const k a b -> Const k a b -> Const k a b

sconcat :: NonEmpty (Const k a b) -> Const k a b

stimes :: Integral b => b -> Const k a b -> Const k a b

Monoid a => Monoid (Const k a b)

Methods

mempty :: Const k a b

mappend :: Const k a b -> Const k a b -> Const k a b

mconcat :: [Const k a b] -> Const k a b

Storable a => Storable (Const k a b)

Methods

sizeOf :: Const k a b -> Int

alignment :: Const k a b -> Int

peekElemOff :: Ptr (Const k a b) -> Int -> IO (Const k a b)

pokeElemOff :: Ptr (Const k a b) -> Int -> Const k a b -> IO ()

peekByteOff :: Ptr b -> Int -> IO (Const k a b)

pokeByteOff :: Ptr b -> Int -> Const k a b -> IO ()

peek :: Ptr (Const k a b) -> IO (Const k a b)

poke :: Ptr (Const k a b) -> Const k a b -> IO ()

Bits a => Bits (Const k a b)

Methods

(.&.) :: Const k a b -> Const k a b -> Const k a b

(.|.) :: Const k a b -> Const k a b -> Const k a b

xor :: Const k a b -> Const k a b -> Const k a b

complement :: Const k a b -> Const k a b

shift :: Const k a b -> Int -> Const k a b

rotate :: Const k a b -> Int -> Const k a b

zeroBits :: Const k a b

bit :: Int -> Const k a b

setBit :: Const k a b -> Int -> Const k a b

clearBit :: Const k a b -> Int -> Const k a b

complementBit :: Const k a b -> Int -> Const k a b

testBit :: Const k a b -> Int -> Bool

bitSizeMaybe :: Const k a b -> Maybe Int

bitSize :: Const k a b -> Int

isSigned :: Const k a b -> Bool

shiftL :: Const k a b -> Int -> Const k a b

unsafeShiftL :: Const k a b -> Int -> Const k a b

shiftR :: Const k a b -> Int -> Const k a b

unsafeShiftR :: Const k a b -> Int -> Const k a b

rotateL :: Const k a b -> Int -> Const k a b

rotateR :: Const k a b -> Int -> Const k a b

popCount :: Const k a b -> Int

FiniteBits a => FiniteBits (Const k a b)

Methods

finiteBitSize :: Const k a b -> Int

countLeadingZeros :: Const k a b -> Int

countTrailingZeros :: Const k a b -> Int

type Rep1 (Const * a)

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)

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 WrappedArrow a b c :: (* -> * -> *) -> * -> * -> *

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

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

Arrow a => Applicative (WrappedArrow a b)

Methods

pure :: a -> WrappedArrow a b a

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

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

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

Generic1 (WrappedArrow a b)

Associated Types

type Rep1 (WrappedArrow a b :: * -> *) :: * -> *

Methods

from1 :: WrappedArrow a b a -> Rep1 (WrappedArrow a b) a

to1 :: Rep1 (WrappedArrow a b) a -> WrappedArrow a b a

(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

Methods

empty :: WrappedArrow a b a

(<|>) :: WrappedArrow a b a -> WrappedArrow a b a -> WrappedArrow a b a

some :: WrappedArrow a b a -> WrappedArrow a b [a]

many :: WrappedArrow a b a -> WrappedArrow a b [a]

Generic (WrappedArrow a b c)

Associated Types

type Rep (WrappedArrow a b c) :: * -> *

Methods

from :: WrappedArrow a b c -> Rep (WrappedArrow a b c) x

to :: Rep (WrappedArrow a b c) x -> WrappedArrow a b c

type Rep1 (WrappedArrow a b)

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)

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

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

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

Applicative ZipList

Methods

pure :: a -> ZipList a

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

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

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

Foldable ZipList

Methods

fold :: Monoid m => ZipList m -> m

foldMap :: Monoid m => (a -> m) -> ZipList a -> m

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

foldr' :: (a -> b -> b) -> b -> ZipList a -> b

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

foldl' :: (b -> a -> b) -> b -> ZipList a -> b

foldr1 :: (a -> a -> a) -> ZipList a -> a

foldl1 :: (a -> a -> a) -> ZipList a -> a

toList :: ZipList a -> [a]

null :: ZipList a -> Bool

length :: ZipList a -> Int

elem :: Eq a => a -> ZipList a -> Bool

maximum :: Ord a => ZipList a -> a

minimum :: Ord a => ZipList a -> a

sum :: Num a => ZipList a -> a

product :: Num a => ZipList a -> a

Traversable ZipList

Methods

traverse :: Applicative f => (a -> f b) -> ZipList a -> f (ZipList b)

sequenceA :: Applicative f => ZipList (f a) -> f (ZipList a)

mapM :: Monad m => (a -> m b) -> ZipList a -> m (ZipList b)

sequence :: Monad m => ZipList (m a) -> m (ZipList a)

Generic1 ZipList

Associated Types

type Rep1 (ZipList :: * -> *) :: * -> *

Methods

from1 :: ZipList a -> Rep1 ZipList a

to1 :: Rep1 ZipList a -> ZipList a

Eq a => Eq (ZipList a)

Methods

(==) :: ZipList a -> ZipList a -> Bool

(/=) :: ZipList a -> ZipList a -> Bool

Ord a => Ord (ZipList a)

Methods

compare :: 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)

Methods

readsPrec :: Int -> ReadS (ZipList a)

readList :: ReadS [ZipList a]

readPrec :: ReadPrec (ZipList a)

readListPrec :: ReadPrec [ZipList a]

Show a => Show (ZipList a)

Methods

showsPrec :: Int -> ZipList a -> ShowS

show :: ZipList a -> String

showList :: [ZipList a] -> ShowS

Generic (ZipList a)

Associated Types

type Rep (ZipList a) :: * -> *

Methods

from :: ZipList a -> Rep (ZipList a) x

to :: Rep (ZipList a) x -> ZipList a

type Rep1 ZipList

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)

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

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

Lift a binary function to actions.

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

A variant of <*> with the arguments reversed.

forever :: Applicative f => f a -> f b

forever act repeats the action infinitely.

when :: Applicative f => Bool -> f () -> f ()

Conditional execution of Applicative expressions. For example,

when debug (putStrLn "Debugging")

will output the string Debugging if the Boolean value debug is True, and otherwise do nothing.

unless :: Applicative f => Bool -> f () -> f ()

The reverse of when.

replicateA :: Applicative f => Int -> f a -> f [a]

replicateA n act performs the action n times, gathering the results.

replicateA_ :: Applicative f => Int -> f a -> f ()

Like replicateA, but discards the result.

filterA :: Applicative f => (a -> f Bool) -> [a] -> f [a]

This generalizes the list-based filter function.