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.

module Grisette.Lib.Control.Applicative

No documentation available.
module Grisette.Unified.Lib.Control.Applicative

No documentation available.
class Functor f => Applicative (f :: Type -> Type)

hledger-web Hledger.Web.Import

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 Language.Lexer.Applicative

For some background, see https://ro-che.info/articles/2015-01-02-lexical-analysis
module Data.Monoid.Applicative

No documentation available.
class Functor f => Applicative (f :: Type -> Type)

opt-env-conf OptEnvConf.Parser

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 Parameterized.Control.Applicative

No documentation available.
class Functor f => Applicative (f :: Type -> Type)

threepenny-gui Graphics.UI.Threepenny.Core

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-yesod ClassyPrelude.Yesod

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 (Monoidal f r t, Curry r, Curry t) => Applicative (f :: Type -> Type) (r :: Type -> Type -> Type) (t :: Type -> Type -> Type)

constrained-categories Control.Applicative.Constrained

No documentation available.

hledger-web	Hledger.Web.Import

opt-env-conf	OptEnvConf.Parser

threepenny-gui	Graphics.UI.Threepenny.Core

classy-prelude-yesod	ClassyPrelude.Yesod

constrained-categories	Control.Applicative.Constrained

Page 6 of many | Previous | Next