Profunctor.Monad.Core

Reexports important type classes from base, constraints.

Constraint synonyms

The quantified super-class instances are explicitly added, since the type system can not deduce them.

type Functor1 p = ForallF Functor p

Constraint equivalent to

forall a. Functor (p a)

type Applicative1 p = (Functor1 p, ForallF Applicative p)

Constraint equivalent to

forall a. Applicative (p a)

type Monad1 p = (Applicative1 p, ForallF Monad p)

Constraint equivalent to

forall a. Monad (p a)

type Alternative1 p = (Applicative1 p, ForallF Alternative p)

Constraint equivalent to

forall a. Alternative (p a)

type MonadPlus1 p = (Monad1 p, Alternative1 p, ForallF MonadPlus p)

Constraint equivalent to

forall a. MonadPlus (p a)

Standard type classes

class Functor (f :: Type -> Type)

A type f is a Functor if it provides a function fmap which, given any types a and b lets you apply any function from (a -> b) to turn an f a into an f b, preserving the structure of f. Furthermore f needs to adhere to the following:

Identity

fmap id == id

Composition

fmap (f . g) == fmap f . fmap g

Note, that the second law follows from the free theorem of the type fmap and the first law, so you need only check that the former condition holds.

Minimal complete definition

fmap

Instances

Functor []

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor Maybe

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor IO

Since: base-2.1

Defined in GHC.Base

Methods

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

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

Functor Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor ZipList

Since: base-2.1

Defined in Control.Applicative

Methods

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

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

Functor ReadP

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

fmap :: (a -> b) -> ReadP a -> ReadP b

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

Functor NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

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

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

Functor Tree

Defined in Data.Tree

Methods

fmap :: (a -> b) -> Tree a -> Tree b

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

Functor Seq

Defined in Data.Sequence.Internal

Methods

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

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

Functor FingerTree

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> FingerTree a -> FingerTree b

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

Functor Digit

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Digit a -> Digit b

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

Functor Node

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Node a -> Node b

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

Functor Elem

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> Elem a -> Elem b

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

Functor ViewL

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewL a -> ViewL b

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

Functor ViewR

Defined in Data.Sequence.Internal

Methods

fmap :: (a -> b) -> ViewR a -> ViewR b

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

Functor P

Since: base-4.8.0.0

Defined in Text.ParserCombinators.ReadP

Methods

fmap :: (a -> b) -> P a -> P b

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

Class () (Functor f)

Defined in Data.Constraint

Methods

cls :: Functor f :- ()

() :=> (Functor ((->) a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((->) a)

() :=> (Functor [])

Defined in Data.Constraint

Methods

ins :: () :- Functor []

() :=> (Functor Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Functor Maybe

() :=> (Functor IO)

Defined in Data.Constraint

Methods

ins :: () :- Functor IO

() :=> (Functor (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Either a)

() :=> (Functor ((,) a))

Defined in Data.Constraint

Methods

ins :: () :- Functor ((,) a)

() :=> (Functor Identity)

Defined in Data.Constraint

Methods

ins :: () :- Functor Identity

() :=> (Functor (Const a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Functor (Const a)

Functor (Either a)

Since: base-3.0

Defined in Data.Either

Methods

fmap :: (a0 -> b) -> Either a a0 -> Either a b

(<$) :: a0 -> Either a b -> Either a a0

Functor (V1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> V1 a -> V1 b

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

Functor (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor ((,) a)

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a0 -> b) -> (a, a0) -> (a, b)

(<$) :: a0 -> (a, b) -> (a, a0)

Monad m => Functor (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

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

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

Arrow a => Functor (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

fmap :: (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b

(<$) :: a0 -> ArrowMonad a b -> ArrowMonad a a0

Class (Functor f) (Applicative f)

Defined in Data.Constraint

Methods

cls :: Applicative f :- Functor f

(Monad m) :=> (Functor (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Functor (WrappedMonad m)

Functor f => Functor (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor (URec Char :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Functor (URec Double :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Functor (URec Float :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Functor (URec Int :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Functor (URec Word :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec Word a -> URec Word b

(<$) :: a -> URec Word b -> URec Word a

Functor (URec (Ptr ()) :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> URec (Ptr ()) a -> URec (Ptr ()) b

(<$) :: a -> URec (Ptr ()) b -> URec (Ptr ()) a

Functor ((,,) a b)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

fmap :: (a0 -> b0) -> (a, b, a0) -> (a, b, b0)

(<$) :: a0 -> (a, b, b0) -> (a, b, a0)

Arrow a => Functor (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

fmap :: (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0

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

Functor m => Functor (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

fmap :: (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b

(<$) :: a0 -> Kleisli m a b -> Kleisli m a a0

Functor (Const m :: Type -> Type)

Since: base-2.1

Defined in Data.Functor.Const

Methods

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

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

Functor (FreeMapping p a)

Defined in Data.Profunctor.Mapping

Methods

fmap :: (a0 -> b) -> FreeMapping p a a0 -> FreeMapping p a b

(<$) :: a0 -> FreeMapping p a b -> FreeMapping p a a0

Profunctor p => Functor (TambaraSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> TambaraSum p a a0 -> TambaraSum p a b

(<$) :: a0 -> TambaraSum p a b -> TambaraSum p a a0

Functor (PastroSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> PastroSum p a a0 -> PastroSum p a b

(<$) :: a0 -> PastroSum p a b -> PastroSum p a a0

Functor (CotambaraSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> CotambaraSum p a a0 -> CotambaraSum p a b

(<$) :: a0 -> CotambaraSum p a b -> CotambaraSum p a a0

Functor (CopastroSum p a)

Defined in Data.Profunctor.Choice

Methods

fmap :: (a0 -> b) -> CopastroSum p a a0 -> CopastroSum p a b

(<$) :: a0 -> CopastroSum p a b -> CopastroSum p a a0

Profunctor p => Functor (Closure p a)

Defined in Data.Profunctor.Closed

Methods

fmap :: (a0 -> b) -> Closure p a a0 -> Closure p a b

(<$) :: a0 -> Closure p a b -> Closure p a a0

Functor (Environment p a)

Defined in Data.Profunctor.Closed

Methods

fmap :: (a0 -> b) -> Environment p a a0 -> Environment p a b

(<$) :: a0 -> Environment p a b -> Environment p a a0

Profunctor p => Functor (Tambara p a)

Defined in Data.Profunctor.Strong

Methods

fmap :: (a0 -> b) -> Tambara p a a0 -> Tambara p a b

(<$) :: a0 -> Tambara p a b -> Tambara p a a0

Functor (Pastro p a)

Defined in Data.Profunctor.Strong

Methods

fmap :: (a0 -> b) -> Pastro p a a0 -> Pastro p a b

(<$) :: a0 -> Pastro p a b -> Pastro p a a0

Functor (Cotambara p a)

Defined in Data.Profunctor.Strong

Methods

fmap :: (a0 -> b) -> Cotambara p a a0 -> Cotambara p a b

(<$) :: a0 -> Cotambara p a b -> Cotambara p a a0

Functor (Copastro p a)

Defined in Data.Profunctor.Strong

Methods

fmap :: (a0 -> b) -> Copastro p a a0 -> Copastro p a b

(<$) :: a0 -> Copastro p a b -> Copastro p a a0

Functor (Tagged s)

Defined in Data.Tagged

Methods

fmap :: (a -> b) -> Tagged s a -> Tagged s b

(<$) :: a -> Tagged s b -> Tagged s a

Functor (Bar t b)

Defined in Data.Profunctor.Mapping

Methods

fmap :: (a -> b0) -> Bar t b a -> Bar t b b0

(<$) :: a -> Bar t b b0 -> Bar t b a

Functor ((->) r :: Type -> Type)

Since: base-2.1

Defined in GHC.Base

Methods

fmap :: (a -> b) -> (r -> a) -> r -> b

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

Functor (K1 i c :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> K1 i c a -> K1 i c b

(<$) :: a -> K1 i c b -> K1 i c a

(Functor f, Functor g) => Functor (f :+: g)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> (f :+: g) a -> (f :+: g) b

(<$) :: a -> (f :+: g) b -> (f :+: g) a

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor ((,,,) a b c)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

fmap :: (a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0)

(<$) :: a0 -> (a, b, c, b0) -> (a, b, c, a0)

Functor (Cokleisli w a)

Defined in Control.Comonad

Methods

fmap :: (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b

(<$) :: a0 -> Cokleisli w a b -> Cokleisli w a a0

Functor f => Functor (Star f a)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Star f a a0 -> Star f a b

(<$) :: a0 -> Star f a b -> Star f a a0

Functor (Costar f a)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Costar f a a0 -> Costar f a b

(<$) :: a0 -> Costar f a b -> Costar f a a0

Functor (Forget r a :: Type -> Type)

Defined in Data.Profunctor.Types

Methods

fmap :: (a0 -> b) -> Forget r a a0 -> Forget r a b

(<$) :: a0 -> Forget r a b -> Forget r a a0

Functor f => Functor (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

fmap :: (a -> b) -> M1 i c f a -> M1 i c f b

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

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

Functor g => Functor (Joker g a)

Defined in Data.Bifunctor.Joker

Methods

fmap :: (a0 -> b) -> Joker g a a0 -> Joker g a b

(<$) :: a0 -> Joker g a b -> Joker g a a0

Functor (Clown f a :: Type -> Type)

Defined in Data.Bifunctor.Clown

Methods

fmap :: (a0 -> b) -> Clown f a a0 -> Clown f a b

(<$) :: a0 -> Clown f a b -> Clown f a a0

(Functor f, Bifunctor p) => Functor (Tannen f p a)

Defined in Data.Bifunctor.Tannen

Methods

fmap :: (a0 -> b) -> Tannen f p a a0 -> Tannen f p a b

(<$) :: a0 -> Tannen f p a b -> Tannen f p a a0

(Bifunctor p, Functor g) => Functor (Biff p f g a)

Defined in Data.Bifunctor.Biff

Methods

fmap :: (a0 -> b) -> Biff p f g a a0 -> Biff p f g a b

(<$) :: a0 -> Biff p f g a b -> Biff p f g a a0

class Functor f => Applicative (f :: Type -> Type)

A functor with application, providing operations to

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

A minimal complete definition must include implementations of pure and of either <*> or liftA2. If it defines both, then they must behave the same as their default definitions:

(<*>) = liftA2 id

liftA2 f x y = f <$> x <*> y

Further, any definition must satisfy the following:

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 = (id <$ u) <*> v

• u <* v = liftA2 const u v

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

• fmap f x = pure f <*> x

It may be useful to note that supposing

forall x y. p (q x y) = f x . g y

it follows from the above that

liftA2 p (liftA2 q u v) = liftA2 f u . liftA2 g v

If f is also a Monad, it should satisfy

• pure = return

• m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

• (*>) = (>>)

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

Minimal complete definition

pure, ((<*>) | liftA2)

Instances

Applicative []

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> [a]

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

liftA2 :: (a -> b -> c) -> [a] -> [b] -> [c]

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

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

Applicative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> Maybe a

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

liftA2 :: (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c

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

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

Applicative IO

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> IO a

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

liftA2 :: (a -> b -> c) -> IO a -> IO b -> IO c

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

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

Applicative Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Par1 a

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

liftA2 :: (a -> b -> c) -> Par1 a -> Par1 b -> Par1 c

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

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

Applicative ZipList

f <$> ZipList xs1 <*> ... <*> ZipList xsN
    = ZipList (zipWithN f xs1 ... xsN)

where zipWithN refers to the zipWith function of the appropriate arity (zipWith, zipWith3, zipWith4, ...). For example:

(\a b c -> stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..]
    = ZipList (zipWith3 (\a b c -> stimes c [a, b]) "abcd" "567" [1..])
    = ZipList {getZipList = ["a5","b6b6","c7c7c7"]}

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> ZipList a

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

liftA2 :: (a -> b -> c) -> ZipList a -> ZipList b -> ZipList c

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

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

Applicative ReadP

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> ReadP a

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

liftA2 :: (a -> b -> c) -> ReadP a -> ReadP b -> ReadP c

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

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

Applicative NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

pure :: a -> NonEmpty a

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

liftA2 :: (a -> b -> c) -> NonEmpty a -> NonEmpty b -> NonEmpty c

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

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

Applicative Tree

Defined in Data.Tree

Methods

pure :: a -> Tree a

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

liftA2 :: (a -> b -> c) -> Tree a -> Tree b -> Tree c

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

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

Applicative Seq

Since: containers-0.5.4

Defined in Data.Sequence.Internal

Methods

pure :: a -> Seq a

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

liftA2 :: (a -> b -> c) -> Seq a -> Seq b -> Seq c

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

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

Applicative P

Since: base-4.5.0.0

Defined in Text.ParserCombinators.ReadP

Methods

pure :: a -> P a

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

liftA2 :: (a -> b -> c) -> P a -> P b -> P c

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

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

() :=> (Applicative ((->) a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Applicative ((->) a)

() :=> (Applicative [])

Defined in Data.Constraint

Methods

ins :: () :- Applicative []

() :=> (Applicative Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Applicative Maybe

() :=> (Applicative IO)

Defined in Data.Constraint

Methods

ins :: () :- Applicative IO

() :=> (Applicative (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Applicative (Either a)

Applicative (Either e)

Since: base-3.0

Defined in Data.Either

Methods

pure :: a -> Either e a

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

liftA2 :: (a -> b -> c) -> Either e a -> Either e b -> Either e c

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

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

Applicative (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> U1 a

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

liftA2 :: (a -> b -> c) -> U1 a -> U1 b -> U1 c

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

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

Monoid a => Applicative ((,) a)

For tuples, the Monoid constraint on a determines how the first values merge. For example, Strings concatenate:

("hello ", (+15)) <*> ("world!", 2002)
("hello world!",2017)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a0 -> (a, a0)

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

liftA2 :: (a0 -> b -> c) -> (a, a0) -> (a, b) -> (a, c)

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

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

Monad m => Applicative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a -> WrappedMonad m a

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

liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c

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

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

Arrow a => Applicative (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> ArrowMonad a a0

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

liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c

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

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

Class (Functor f) (Applicative f)

Defined in Data.Constraint

Methods

cls :: Applicative f :- Functor f

Class (Applicative f) (Monad f)

Defined in Data.Constraint

Methods

cls :: Monad f :- Applicative f

Class (Applicative f) (Alternative f)

Defined in Data.Constraint

Methods

cls :: Alternative f :- Applicative f

(Monad m) :=> (Applicative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Applicative (WrappedMonad m)

(Monoid a) :=> (Applicative ((,) a))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative ((,) a)

(Monoid a) :=> (Applicative (Const a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: Monoid a :- Applicative (Const a)

Applicative f => Applicative (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> Rec1 f a

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

liftA2 :: (a -> b -> c) -> Rec1 f a -> Rec1 f b -> Rec1 f c

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

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

(Monoid a, Monoid b) => Applicative ((,,) a b)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, a0)

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

liftA2 :: (a0 -> b0 -> c) -> (a, b, a0) -> (a, b, b0) -> (a, b, c)

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

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

Arrow a => Applicative (WrappedArrow a b)

Since: base-2.1

Defined in Control.Applicative

Methods

pure :: a0 -> WrappedArrow a b a0

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

liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c

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

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

Applicative m => Applicative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

pure :: a0 -> Kleisli m a a0

(<*>) :: Kleisli m a (a0 -> b) -> Kleisli m a a0 -> Kleisli m a b

liftA2 :: (a0 -> b -> c) -> Kleisli m a a0 -> Kleisli m a b -> Kleisli m a c

(*>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b

(<*) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a a0

Monoid m => Applicative (Const m :: Type -> Type)

Since: base-2.0.1

Defined in Data.Functor.Const

Methods

pure :: a -> Const m a

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

liftA2 :: (a -> b -> c) -> Const m a -> Const m b -> Const m c

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

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

(Profunctor p, Arrow p) => Applicative (Closure p a)

Defined in Data.Profunctor.Closed

Methods

pure :: a0 -> Closure p a a0

(<*>) :: Closure p a (a0 -> b) -> Closure p a a0 -> Closure p a b

liftA2 :: (a0 -> b -> c) -> Closure p a a0 -> Closure p a b -> Closure p a c

(*>) :: Closure p a a0 -> Closure p a b -> Closure p a b

(<*) :: Closure p a a0 -> Closure p a b -> Closure p a a0

(Profunctor p, Arrow p) => Applicative (Tambara p a)

Defined in Data.Profunctor.Strong

Methods

pure :: a0 -> Tambara p a a0

(<*>) :: Tambara p a (a0 -> b) -> Tambara p a a0 -> Tambara p a b

liftA2 :: (a0 -> b -> c) -> Tambara p a a0 -> Tambara p a b -> Tambara p a c

(*>) :: Tambara p a a0 -> Tambara p a b -> Tambara p a b

(<*) :: Tambara p a a0 -> Tambara p a b -> Tambara p a a0

Applicative (Tagged s)

Defined in Data.Tagged

Methods

pure :: a -> Tagged s a

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

liftA2 :: (a -> b -> c) -> Tagged s a -> Tagged s b -> Tagged s c

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

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

Applicative ((->) r :: Type -> Type)

Since: base-2.1

Defined in GHC.Base

Methods

pure :: a -> r -> a

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

liftA2 :: (a -> b -> c) -> (r -> a) -> (r -> b) -> r -> c

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

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

Monoid c => Applicative (K1 i c :: Type -> Type)

Since: base-4.12.0.0

Defined in GHC.Generics

Methods

pure :: a -> K1 i c a

(<*>) :: K1 i c (a -> b) -> K1 i c a -> K1 i c b

liftA2 :: (a -> b -> c0) -> K1 i c a -> K1 i c b -> K1 i c c0

(*>) :: K1 i c a -> K1 i c b -> K1 i c b

(<*) :: K1 i c a -> K1 i c b -> K1 i c a

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

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

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

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

(Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

pure :: a0 -> (a, b, c, a0)

(<*>) :: (a, b, c, a0 -> b0) -> (a, b, c, a0) -> (a, b, c, b0)

liftA2 :: (a0 -> b0 -> c0) -> (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, c0)

(*>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0)

(<*) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, a0)

Applicative (Cokleisli w a)

Defined in Control.Comonad

Methods

pure :: a0 -> Cokleisli w a a0

(<*>) :: Cokleisli w a (a0 -> b) -> Cokleisli w a a0 -> Cokleisli w a b

liftA2 :: (a0 -> b -> c) -> Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a c

(*>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b

(<*) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a a0

Applicative f => Applicative (Star f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Star f a a0

(<*>) :: Star f a (a0 -> b) -> Star f a a0 -> Star f a b

liftA2 :: (a0 -> b -> c) -> Star f a a0 -> Star f a b -> Star f a c

(*>) :: Star f a a0 -> Star f a b -> Star f a b

(<*) :: Star f a a0 -> Star f a b -> Star f a a0

Applicative (Costar f a)

Defined in Data.Profunctor.Types

Methods

pure :: a0 -> Costar f a a0

(<*>) :: Costar f a (a0 -> b) -> Costar f a a0 -> Costar f a b

liftA2 :: (a0 -> b -> c) -> Costar f a a0 -> Costar f a b -> Costar f a c

(*>) :: Costar f a a0 -> Costar f a b -> Costar f a b

(<*) :: Costar f a a0 -> Costar f a b -> Costar f a a0

Applicative f => Applicative (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

pure :: a -> M1 i c f a

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

liftA2 :: (a -> b -> c0) -> M1 i c f a -> M1 i c f b -> M1 i c f c0

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

liftA2 :: (a -> b -> c) -> (f :.: g) a -> (f :.: g) b -> (f :.: g) c

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

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

class Applicative m => Monad (m :: Type -> Type)

The Monad class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's do expressions provide a convenient syntax for writing monadic expressions.

Instances of Monad should satisfy the following:

Left identity

return a >>= k = k a

Right identity

m >>= return = m

Associativity

m >>= (\x -> k x >>= h) = (m >>= k) >>= h

Furthermore, the Monad and Applicative operations should relate as follows:

• pure = return

• m1 <*> m2 = m1 >>= (x1 -> m2 >>= (x2 -> return (x1 x2)))

The above laws imply:

• fmap f xs  =  xs >>= return . f

• (>>) = (*>)

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

The instances of Monad for lists, Maybe and IO defined in the Prelude satisfy these laws.

Minimal complete definition

(>>=)

Instances

Monad []

Since: base-2.1

Defined in GHC.Base

Methods

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

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

return :: a -> [a]

Monad Maybe

Since: base-2.1

Defined in GHC.Base

Methods

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

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

return :: a -> Maybe a

Monad IO

Since: base-2.1

Defined in GHC.Base

Methods

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

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

return :: a -> IO a

Monad Par1

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

return :: a -> Par1 a

Monad ReadP

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

(>>=) :: ReadP a -> (a -> ReadP b) -> ReadP b

(>>) :: ReadP a -> ReadP b -> ReadP b

return :: a -> ReadP a

Monad NonEmpty

Since: base-4.9.0.0

Defined in GHC.Base

Methods

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

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

return :: a -> NonEmpty a

Monad Tree

Defined in Data.Tree

Methods

(>>=) :: Tree a -> (a -> Tree b) -> Tree b

(>>) :: Tree a -> Tree b -> Tree b

return :: a -> Tree a

Monad Seq

Defined in Data.Sequence.Internal

Methods

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

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

return :: a -> Seq a

Monad P

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

(>>=) :: P a -> (a -> P b) -> P b

(>>) :: P a -> P b -> P b

return :: a -> P a

() :=> (Monad ((->) a :: Type -> Type))

Defined in Data.Constraint

Methods

ins :: () :- Monad ((->) a)

() :=> (Monad [])

Defined in Data.Constraint

Methods

ins :: () :- Monad []

() :=> (Monad IO)

Defined in Data.Constraint

Methods

ins :: () :- Monad IO

() :=> (Monad (Either a))

Defined in Data.Constraint

Methods

ins :: () :- Monad (Either a)

() :=> (Monad Identity)

Defined in Data.Constraint

Methods

ins :: () :- Monad Identity

Monad (Either e)

Since: base-4.4.0.0

Defined in Data.Either

Methods

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

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

return :: a -> Either e a

Monad (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

return :: a -> U1 a

Monoid a => Monad ((,) a)

Since: base-4.9.0.0

Defined in GHC.Base

Methods

(>>=) :: (a, a0) -> (a0 -> (a, b)) -> (a, b)

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

return :: a0 -> (a, a0)

Monad m => Monad (WrappedMonad m)

Since: base-4.7.0.0

Defined in Control.Applicative

Methods

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

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

return :: a -> WrappedMonad m a

ArrowApply a => Monad (ArrowMonad a)

Since: base-2.1

Defined in Control.Arrow

Methods

(>>=) :: ArrowMonad a a0 -> (a0 -> ArrowMonad a b) -> ArrowMonad a b

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

return :: a0 -> ArrowMonad a a0

Class (Applicative f) (Monad f)

Defined in Data.Constraint

Methods

cls :: Monad f :- Applicative f

(Monad m) :=> (Functor (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Functor (WrappedMonad m)

(Monad m) :=> (Applicative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: Monad m :- Applicative (WrappedMonad m)

Monad f => Monad (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

return :: a -> Rec1 f a

(Monoid a, Monoid b) => Monad ((,,) a b)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

(>>=) :: (a, b, a0) -> (a0 -> (a, b, b0)) -> (a, b, b0)

(>>) :: (a, b, a0) -> (a, b, b0) -> (a, b, b0)

return :: a0 -> (a, b, a0)

Monad m => Monad (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

(>>=) :: Kleisli m a a0 -> (a0 -> Kleisli m a b) -> Kleisli m a b

(>>) :: Kleisli m a a0 -> Kleisli m a b -> Kleisli m a b

return :: a0 -> Kleisli m a a0

Monad (Tagged s)

Defined in Data.Tagged

Methods

(>>=) :: Tagged s a -> (a -> Tagged s b) -> Tagged s b

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

return :: a -> Tagged s a

Class (Monad f, Alternative f) (MonadPlus f)

Defined in Data.Constraint

Methods

cls :: MonadPlus f :- (Monad f, Alternative f)

Monad ((->) r :: Type -> Type)

Since: base-2.1

Defined in GHC.Base

Methods

(>>=) :: (r -> a) -> (a -> r -> b) -> r -> b

(>>) :: (r -> a) -> (r -> b) -> r -> b

return :: a -> r -> a

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

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

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

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

(Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c)

Since: base-4.14.0.0

Defined in GHC.Base

Methods

(>>=) :: (a, b, c, a0) -> (a0 -> (a, b, c, b0)) -> (a, b, c, b0)

(>>) :: (a, b, c, a0) -> (a, b, c, b0) -> (a, b, c, b0)

return :: a0 -> (a, b, c, a0)

Monad (Cokleisli w a)

Defined in Control.Comonad

Methods

(>>=) :: Cokleisli w a a0 -> (a0 -> Cokleisli w a b) -> Cokleisli w a b

(>>) :: Cokleisli w a a0 -> Cokleisli w a b -> Cokleisli w a b

return :: a0 -> Cokleisli w a a0

Monad f => Monad (Star f a)

Defined in Data.Profunctor.Types

Methods

(>>=) :: Star f a a0 -> (a0 -> Star f a b) -> Star f a b

(>>) :: Star f a a0 -> Star f a b -> Star f a b

return :: a0 -> Star f a a0

Monad (Costar f a)

Defined in Data.Profunctor.Types

Methods

(>>=) :: Costar f a a0 -> (a0 -> Costar f a b) -> Costar f a b

(>>) :: Costar f a a0 -> Costar f a b -> Costar f a b

return :: a0 -> Costar f a a0

Monad f => Monad (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

(>>=) :: M1 i c f a -> (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 b

return :: a -> M1 i c f a

class Applicative f => Alternative (f :: Type -> Type)

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, (<|>)

Instances

Alternative []

Since: base-2.1

Defined in GHC.Base

Methods

empty :: [a]

(<|>) :: [a] -> [a] -> [a]

some :: [a] -> [[a]]

many :: [a] -> [[a]]

Alternative Maybe

Since: base-2.1

Defined in GHC.Base

Methods

empty :: Maybe a

(<|>) :: Maybe a -> Maybe a -> Maybe a

some :: Maybe a -> Maybe [a]

many :: Maybe a -> Maybe [a]

Alternative IO

Since: base-4.9.0.0

Defined in GHC.Base

Methods

empty :: IO a

(<|>) :: IO a -> IO a -> IO a

some :: IO a -> IO [a]

many :: IO a -> IO [a]

Alternative ZipList

Since: base-4.11.0.0

Defined in Control.Applicative

Methods

empty :: ZipList a

(<|>) :: ZipList a -> ZipList a -> ZipList a

some :: ZipList a -> ZipList [a]

many :: ZipList a -> ZipList [a]

Alternative ReadP

Since: base-4.6.0.0

Defined in Text.ParserCombinators.ReadP

Methods

empty :: ReadP a

(<|>) :: ReadP a -> ReadP a -> ReadP a

some :: ReadP a -> ReadP [a]

many :: ReadP a -> ReadP [a]

Alternative Seq

Since: containers-0.5.4

Defined in Data.Sequence.Internal

Methods

empty :: Seq a

(<|>) :: Seq a -> Seq a -> Seq a

some :: Seq a -> Seq [a]

many :: Seq a -> Seq [a]

Alternative P

Since: base-4.5.0.0

Defined in Text.ParserCombinators.ReadP

Methods

empty :: P a

(<|>) :: P a -> P a -> P a

some :: P a -> P [a]

many :: P a -> P [a]

() :=> (Alternative [])

Defined in Data.Constraint

Methods

ins :: () :- Alternative []

() :=> (Alternative Maybe)

Defined in Data.Constraint

Methods

ins :: () :- Alternative Maybe

Alternative (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: U1 a

(<|>) :: U1 a -> U1 a -> U1 a

some :: U1 a -> U1 [a]

many :: U1 a -> U1 [a]

MonadPlus m => Alternative (WrappedMonad m)

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedMonad m a

(<|>) :: WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

some :: WrappedMonad m a -> WrappedMonad m [a]

many :: WrappedMonad m a -> WrappedMonad m [a]

ArrowPlus a => Alternative (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

empty :: ArrowMonad a a0

(<|>) :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0

some :: ArrowMonad a a0 -> ArrowMonad a [a0]

many :: ArrowMonad a a0 -> ArrowMonad a [a0]

Class (Applicative f) (Alternative f)

Defined in Data.Constraint

Methods

cls :: Alternative f :- Applicative f

(MonadPlus m) :=> (Alternative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: MonadPlus m :- Alternative (WrappedMonad m)

Alternative f => Alternative (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: Rec1 f a

(<|>) :: Rec1 f a -> Rec1 f a -> Rec1 f a

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

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

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

Since: base-2.1

Defined in Control.Applicative

Methods

empty :: WrappedArrow a b a0

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

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

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

Alternative m => Alternative (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

empty :: Kleisli m a a0

(<|>) :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0

some :: Kleisli m a a0 -> Kleisli m a [a0]

many :: Kleisli m a a0 -> Kleisli m a [a0]

(Profunctor p, ArrowPlus p) => Alternative (Closure p a)

Defined in Data.Profunctor.Closed

Methods

empty :: Closure p a a0

(<|>) :: Closure p a a0 -> Closure p a a0 -> Closure p a a0

some :: Closure p a a0 -> Closure p a [a0]

many :: Closure p a a0 -> Closure p a [a0]

(Profunctor p, ArrowPlus p) => Alternative (Tambara p a)

Defined in Data.Profunctor.Strong

Methods

empty :: Tambara p a a0

(<|>) :: Tambara p a a0 -> Tambara p a a0 -> Tambara p a a0

some :: Tambara p a a0 -> Tambara p a [a0]

many :: Tambara p a a0 -> Tambara p a [a0]

Class (Monad f, Alternative f) (MonadPlus f)

Defined in Data.Constraint

Methods

cls :: MonadPlus f :- (Monad f, Alternative f)

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: (f :*: g) a

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

some :: (f :*: g) a -> (f :*: g) [a]

many :: (f :*: g) a -> (f :*: g) [a]

Alternative f => Alternative (Star f a)

Defined in Data.Profunctor.Types

Methods

empty :: Star f a a0

(<|>) :: Star f a a0 -> Star f a a0 -> Star f a a0

some :: Star f a a0 -> Star f a [a0]

many :: Star f a a0 -> Star f a [a0]

Alternative f => Alternative (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: M1 i c f a

(<|>) :: M1 i c f a -> M1 i c f a -> M1 i c f a

some :: M1 i c f a -> M1 i c f [a]

many :: M1 i c f a -> M1 i c f [a]

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

empty :: (f :.: g) a

(<|>) :: (f :.: g) a -> (f :.: g) a -> (f :.: g) a

some :: (f :.: g) a -> (f :.: g) [a]

many :: (f :.: g) a -> (f :.: g) [a]

class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)

Monads that also support choice and failure.

Instances

MonadPlus []

Since: base-2.1

Defined in GHC.Base

Methods

mzero :: [a]

mplus :: [a] -> [a] -> [a]

MonadPlus Maybe

Since: base-2.1

Defined in GHC.Base

Methods

mzero :: Maybe a

mplus :: Maybe a -> Maybe a -> Maybe a

MonadPlus IO

Since: base-4.9.0.0

Defined in GHC.Base

Methods

mzero :: IO a

mplus :: IO a -> IO a -> IO a

MonadPlus ReadP

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

mzero :: ReadP a

mplus :: ReadP a -> ReadP a -> ReadP a

MonadPlus Seq

Defined in Data.Sequence.Internal

Methods

mzero :: Seq a

mplus :: Seq a -> Seq a -> Seq a

MonadPlus P

Since: base-2.1

Defined in Text.ParserCombinators.ReadP

Methods

mzero :: P a

mplus :: P a -> P a -> P a

() :=> (MonadPlus [])

Defined in Data.Constraint

Methods

ins :: () :- MonadPlus []

() :=> (MonadPlus Maybe)

Defined in Data.Constraint

Methods

ins :: () :- MonadPlus Maybe

MonadPlus (U1 :: Type -> Type)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

mzero :: U1 a

mplus :: U1 a -> U1 a -> U1 a

(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a)

Since: base-4.6.0.0

Defined in Control.Arrow

Methods

mzero :: ArrowMonad a a0

mplus :: ArrowMonad a a0 -> ArrowMonad a a0 -> ArrowMonad a a0

(MonadPlus m) :=> (Alternative (WrappedMonad m))

Defined in Data.Constraint

Methods

ins :: MonadPlus m :- Alternative (WrappedMonad m)

MonadPlus f => MonadPlus (Rec1 f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

mzero :: Rec1 f a

mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a

MonadPlus m => MonadPlus (Kleisli m a)

Since: base-4.14.0.0

Defined in Control.Arrow

Methods

mzero :: Kleisli m a a0

mplus :: Kleisli m a a0 -> Kleisli m a a0 -> Kleisli m a a0

Class (Monad f, Alternative f) (MonadPlus f)

Defined in Data.Constraint

Methods

cls :: MonadPlus f :- (Monad f, Alternative f)

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

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

mzero :: (f :*: g) a

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

MonadPlus f => MonadPlus (Star f a)

Defined in Data.Profunctor.Types

Methods

mzero :: Star f a a0

mplus :: Star f a a0 -> Star f a a0 -> Star f a a0

MonadPlus f => MonadPlus (M1 i c f)

Since: base-4.9.0.0

Defined in GHC.Generics

Methods

mzero :: M1 i c f a

mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a

Constraints

class Forall (ComposeC p f) => ForallF (p :: k2 -> Constraint) (f :: k1 -> k2)

A representation of the quantified constraint forall a. p (f a).

Instances

Forall (ComposeC p f) => ForallF (p :: k2 -> Constraint) (f :: k1 -> k2)

Defined in Data.Constraint.Forall

instF :: forall k2 k1 p (f :: k1 -> k2) (a :: k1). ForallF p f :- p (f a)

Instantiate a quantified ForallF p f constraint at type a.

newtype a :- b infixr 9

This is the type of entailment.

a :- b is read as a "entails" b.

With this we can actually build a category for Constraint resolution.

e.g.

Because Eq a is a superclass of Ord a, we can show that Ord a entails Eq a.

Because instance Ord a => Ord [a] exists, we can show that Ord a entails Ord [a] as well.

This relationship is captured in the :- entailment type here.

Since p :- p and entailment composes, :- forms the arrows of a Category of constraints. However, Category only became sufficiently general to support this instance in GHC 7.8, so prior to 7.8 this instance is unavailable.

But due to the coherence of instance resolution in Haskell, this Category has some very interesting properties. Notably, in the absence of IncoherentInstances, this category is "thin", which is to say that between any two objects (constraints) there is at most one distinguishable arrow.

This means that for instance, even though there are two ways to derive Ord a :- Eq [a], the answers from these two paths _must_ by construction be equal. This is a property that Haskell offers that is pretty much unique in the space of languages with things they call "type classes".

What are the two ways?

Well, we can go from Ord a :- Eq a via the superclass relationship, and then from Eq a :- Eq [a] via the instance, or we can go from Ord a :- Ord [a] via the instance then from Ord [a] :- Eq [a] through the superclass relationship and this diagram by definition must "commute".

Diagrammatically,

                   Ord a
               ins /     \ cls
                  v       v
            Ord [a]     Eq a
               cls \     / ins
                    v   v
                   Eq [a]

This safety net ensures that pretty much anything you can write with this library is sensible and can't break any assumptions on the behalf of library authors.

Constructors

Sub (a => Dict b)

Instances

Category (:-)

Possible since GHC 7.8, when Category was made polykinded.

Defined in Data.Constraint

Methods

id :: forall (a :: k). a :- a

(.) :: forall (b :: k) (c :: k) (a :: k). (b :- c) -> (a :- b) -> a :- c

() :=> (Eq (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Eq (a :- b)

() :=> (Ord (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Ord (a :- b)

() :=> (Show (a :- b))

Defined in Data.Constraint

Methods

ins :: () :- Show (a :- b)

a => HasDict b (a :- b)

Defined in Data.Constraint

Methods

evidence :: (a :- b) -> Dict b

Eq (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

Methods

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

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

(Typeable p, Typeable q, p, q) => Data (p :- q)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> (p :- q) -> c (p :- q)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (p :- q)

toConstr :: (p :- q) -> Constr

dataTypeOf :: (p :- q) -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (p :- q))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (p :- q))

gmapT :: (forall b. Data b => b -> b) -> (p :- q) -> p :- q

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> (p :- q) -> r

gmapQ :: (forall d. Data d => d -> u) -> (p :- q) -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> (p :- q) -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> (p :- q) -> m (p :- q)

Ord (a :- b)

Assumes IncoherentInstances doesn't exist.

Defined in Data.Constraint

Methods

compare :: (a :- b) -> (a :- b) -> Ordering

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

(<=) :: (a :- b) -> (a :- b) -> Bool

(>) :: (a :- b) -> (a :- b) -> Bool

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

max :: (a :- b) -> (a :- b) -> a :- b

min :: (a :- b) -> (a :- b) -> a :- b

Show (a :- b)

Defined in Data.Constraint

Methods

showsPrec :: Int -> (a :- b) -> ShowS

show :: (a :- b) -> String

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

a => NFData (a :- b)

Defined in Data.Constraint

Methods

rnf :: (a :- b) -> ()

data Dict a where

Values of type Dict p capture a dictionary for a constraint of type p.

e.g.

Dict :: Dict (Eq Int)

captures a dictionary that proves we have an:

instance Eq Int

Pattern matching on the Dict constructor will bring this instance into scope.

Constructors

Dict :: forall a. a => Dict a

Instances

HasDict a (Dict a)

Defined in Data.Constraint

Methods

evidence :: Dict a -> Dict a

a :=> (Read (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Read (Dict a)

a :=> (Monoid (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Monoid (Dict a)

a :=> (Enum (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Enum (Dict a)

a :=> (Bounded (Dict a))

Defined in Data.Constraint

Methods

ins :: a :- Bounded (Dict a)

() :=> (Eq (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Eq (Dict a)

() :=> (Ord (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Ord (Dict a)

() :=> (Show (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Show (Dict a)

() :=> (Semigroup (Dict a))

Defined in Data.Constraint

Methods

ins :: () :- Semigroup (Dict a)

a => Bounded (Dict a)

Defined in Data.Constraint

Methods

minBound :: Dict a

maxBound :: Dict a

a => Enum (Dict a)

Defined in Data.Constraint

Methods

succ :: Dict a -> Dict a

pred :: Dict a -> Dict a

toEnum :: Int -> Dict a

fromEnum :: Dict a -> Int

enumFrom :: Dict a -> [Dict a]

enumFromThen :: Dict a -> Dict a -> [Dict a]

enumFromTo :: Dict a -> Dict a -> [Dict a]

enumFromThenTo :: Dict a -> Dict a -> Dict a -> [Dict a]

Eq (Dict a)

Defined in Data.Constraint

Methods

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

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

(Typeable p, p) => Data (Dict p)

Defined in Data.Constraint

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dict p -> c (Dict p)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dict p)

toConstr :: Dict p -> Constr

dataTypeOf :: Dict p -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dict p))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dict p))

gmapT :: (forall b. Data b => b -> b) -> Dict p -> Dict p

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dict p -> r

gmapQ :: (forall d. Data d => d -> u) -> Dict p -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Dict p -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dict p -> m (Dict p)

Ord (Dict a)

Defined in Data.Constraint

Methods

compare :: Dict a -> Dict a -> Ordering

(<) :: Dict a -> Dict a -> Bool

(<=) :: Dict a -> Dict a -> Bool

(>) :: Dict a -> Dict a -> Bool

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

max :: Dict a -> Dict a -> Dict a

min :: Dict a -> Dict a -> Dict a

a => Read (Dict a)

Defined in Data.Constraint

Methods

readsPrec :: Int -> ReadS (Dict a)

readList :: ReadS [Dict a]

readPrec :: ReadPrec (Dict a)

readListPrec :: ReadPrec [Dict a]

Show (Dict a)

Defined in Data.Constraint

Methods

showsPrec :: Int -> Dict a -> ShowS

show :: Dict a -> String

showList :: [Dict a] -> ShowS

Semigroup (Dict a)

Defined in Data.Constraint

Methods

(<>) :: Dict a -> Dict a -> Dict a

sconcat :: NonEmpty (Dict a) -> Dict a

stimes :: Integral b => b -> Dict a -> Dict a

a => Monoid (Dict a)

Defined in Data.Constraint

Methods

mempty :: Dict a

mappend :: Dict a -> Dict a -> Dict a

mconcat :: [Dict a] -> Dict a

NFData (Dict c)

Defined in Data.Constraint

Methods

rnf :: Dict c -> ()