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 Test.Validity.Applicative

Applicative properties You will need TypeApplications to use these.
class Functor f => Applicative (f :: Type -> Type)

rio RIO.Prelude.Types

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)

diagrams-lib Diagrams.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).
module Test.Syd.Validity.Applicative

Applicative properties You will need TypeApplications to use these.
class Functor f => Applicative (f :: Type -> Type)

Cabal-syntax Distribution.Compat.Prelude

No documentation available.
module Relude.Applicative

This module contains reexports of Applicative and related functional. Additionally, it provides convenient combinators to work with Applicative.
class Functor f => Applicative (f :: Type -> Type)

relude Relude.Applicative

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)

basement Basement.Compat.Base

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)

basement Basement.Imports

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-internal GHC.Internal.Base

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

rio	RIO.Prelude.Types

diagrams-lib	Diagrams.Prelude

Cabal-syntax	Distribution.Compat.Prelude

relude	Relude.Applicative

basement	Basement.Compat.Base

basement	Basement.Imports

ghc-internal	GHC.Internal.Base

Page 2 of many | Previous | Next