Hoogle Search

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

module Text.Regex.Applicative

To get started, see some examples on the wiki: https://github.com/feuerbach/regex-applicative/wiki/Examples
module Control.Subcategory.Applicative

No documentation available.
module Agda.Utils.Applicative

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

breakpoint Debug.Breakpoint.GhcFacade

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)

clash-prelude Clash.HaskellPrelude

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)

configuration-tools Configuration.Utils.CommandLine

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)

dimensional Numeric.Units.Dimensional.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)

distribution-opensuse OpenSuse.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)

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

breakpoint	Debug.Breakpoint.GhcFacade

clash-prelude	Clash.HaskellPrelude

configuration-tools	Configuration.Utils.CommandLine

dimensional	Numeric.Units.Dimensional.Prelude

distribution-opensuse	OpenSuse.Prelude

faktory	Faktory.Prelude

This module implements a lightweight flags parser, inspired by optparse-applicative. Sample usage (note the default log level and optional context):

module Main where

import Control.Applicative ((<|>), optional)
import Data.Text (Text)
import Flags.Applicative

-- Custom flags for our example.
data Flags = Flags
{ rootPath :: Text
, logLevel :: Int
, context :: Maybe Text
} deriving Show

-- Returns a parser from CLI arguments to our custom flags.
flagsParser :: FlagsParser Flags
flagsParser = Flags
<$> flag textVal "root" "path to the root"
<*> (flag autoVal "log_level" "" <|> pure 0)
<*> (optional $ flag textVal "context" "")

main :: IO ()
main = do
(flags, args) <- parseSystemFlagsOrDie flagsParser
print flags

Page 5 of many | Previous | Next