Hoogle Search

Within LTS Haskell 24.13 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

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

protolude Protolude

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).
module Protolude.Applicative

No documentation available.
module TextShow.Control.Applicative

TextShow instances for Const and ZipList. Since: 2
class Functor f => Applicative (f :: Type -> Type)

graphviz Data.GraphViz.Parsing

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).
class Functor f => Applicative (f :: Type -> Type)

numhask NumHask.Prelude

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).
class Functor f => Applicative (f :: Type -> Type)

basic-prelude CorePrelude

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).
class Functor f => Applicative (f :: Type -> Type)

classy-prelude ClassyPrelude

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).
class Functor f => Applicative (f :: Type -> Type)

ghc-lib-parser GHC.Prelude.Basic

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).
class Functor f => Applicative (f :: Type -> Type)

ghc-lib-parser GHC.Utils.Monad

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).
class Functor f => Applicative (f :: Type -> Type)

foundation Foundation

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

protolude	Protolude

graphviz	Data.GraphViz.Parsing

numhask	NumHask.Prelude

basic-prelude	CorePrelude

classy-prelude	ClassyPrelude

ghc-lib-parser	GHC.Prelude.Basic

ghc-lib-parser	GHC.Utils.Monad

foundation	Foundation

Page 3 of many | Previous | Next