Safe Haskell | None |
---|---|

Language | Haskell2010 |

## Synopsis

- (&) :: a -> (a -> b) -> b
- (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- (<&>) :: Functor f => f a -> (a -> b) -> f b
- toList :: Foldable t => t a -> [a]
- bool :: a -> a -> Bool -> a
- first :: Bifunctor p => (a -> b) -> p a c -> p b c
- second :: Bifunctor p => (b -> c) -> p a b -> p a c
- on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- isNothing :: Maybe a -> Bool
- isJust :: Maybe a -> Bool
- fromMaybe :: a -> Maybe a -> a
- guard :: Alternative f => Bool -> f ()
- foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- fold :: (Foldable t, Monoid m) => t m -> m
- for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b)
- throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- join :: Monad m => m (m a) -> m a
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- ($>) :: Functor f => f a -> b -> f b
- fromRight :: b -> Either a b -> b
- isRight :: Either a b -> Bool
- void :: Functor f => f a -> f ()
- through :: Functor f => (a -> f b) -> a -> f a
- coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- class Generic a
- class NFData a
- data Natural
- data NonEmpty a = a :| [a]
- data Word8
- class Applicative f => Alternative (f :: Type -> Type) where
- class (Typeable e, Show e) => Exception e
- newtype PairT b f a = PairT {
- unPairT :: f (b, a)

- class a ~R# b => Coercible (a :: k) (b :: k)
- class Typeable (a :: k)
- type Lens' s a = Lens s s a a
- lens :: (s -> a) -> (s -> b -> t) -> Lens s t a b
- (^.) :: s -> Getting a s a -> a
- view :: MonadReader s m => Getting a s a -> m a
- (.~) :: ASetter s t a b -> b -> s -> t
- set :: ASetter s t a b -> b -> s -> t
- (%~) :: ASetter s t a b -> (a -> b) -> s -> t
- over :: ASetter s t a b -> (a -> b) -> s -> t
- traceShowId :: Show a => a -> a
- trace :: String -> a -> a
- (.*) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
- (<<$>>) :: (Functor f1, Functor f2) => (a -> b) -> f1 (f2 a) -> f1 (f2 b)
- (<<*>>) :: (Applicative f1, Applicative f2) => f1 (f2 (a -> b)) -> f1 (f2 a) -> f1 (f2 b)
- mtraverse :: (Monad m, Traversable m, Applicative f) => (a -> f (m b)) -> m a -> f (m b)
- foldMapM :: (Foldable f, Monad m, Monoid b) => (a -> m b) -> f a -> m b
- reoption :: (Foldable f, Alternative g) => f a -> g a
- enumeration :: (Bounded a, Enum a) => [a]
- tabulateArray :: (Bounded i, Enum i, Ix i) => (i -> a) -> Array i a
- (?) :: Alternative f => Bool -> a -> f a
- ensure :: Alternative f => (a -> Bool) -> a -> f a
- asksM :: MonadReader r m => (r -> m a) -> m a
- data Doc ann
- newtype ShowPretty a = ShowPretty {
- unShowPretty :: a

- class Pretty a where
- pretty :: a -> Doc ann
- prettyList :: [a] -> Doc ann

- class PrettyBy config a where
- prettyBy :: config -> a -> Doc ann
- prettyListBy :: config -> [a] -> Doc ann

- type family HasPrettyDefaults config :: Bool
- type PrettyDefaultBy config = DispatchPrettyDefaultBy (NonStuckHasPrettyDefaults config) config
- newtype PrettyAny a = PrettyAny {
- unPrettyAny :: a

- class Render str where
- display :: forall str a. (Pretty a, Render str) => a -> str
- printPretty :: Pretty a => a -> IO ()
- showText :: Show a => a -> Text

# Reexports from base

(&&&) :: Arrow a => a b c -> a b c' -> a b (c, c') infixr 3 Source #

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

toList :: Foldable t => t a -> [a] Source #

List of elements of a structure, from left to right.

*Since: base-4.8.0.0*

bool :: a -> a -> Bool -> a Source #

Case analysis for the `Bool`

type.

evaluates to `bool`

x y p`x`

when `p`

is `False`

, and evaluates to `y`

when `p`

is `True`

.

This is equivalent to `if p then y else x`

; that is, one can
think of it as an if-then-else construct with its arguments
reordered.

#### Examples

Basic usage:

`>>>`

"bar"`bool "foo" "bar" True`

`>>>`

"foo"`bool "foo" "bar" False`

Confirm that

and `bool`

x y p`if p then y else x`

are
equivalent:

`>>>`

`let p = True; x = "bar"; y = "foo"`

`>>>`

True`bool x y p == if p then y else x`

`>>>`

`let p = False`

`>>>`

True`bool x y p == if p then y else x`

*Since: base-4.7.0.0*

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c infixl 0 Source #

fromMaybe :: a -> Maybe a -> a Source #

The `fromMaybe`

function takes a default value and and `Maybe`

value. If the `Maybe`

is `Nothing`

, it returns the default values;
otherwise, it returns the value contained in the `Maybe`

.

#### Examples

Basic usage:

`>>>`

"Hello, World!"`fromMaybe "" (Just "Hello, World!")`

`>>>`

""`fromMaybe "" Nothing`

Read an integer from a string using `readMaybe`

. If we fail to
parse an integer, we want to return `0`

by default:

`>>>`

`import Text.Read ( readMaybe )`

`>>>`

5`fromMaybe 0 (readMaybe "5")`

`>>>`

0`fromMaybe 0 (readMaybe "")`

guard :: Alternative f => Bool -> f () Source #

Conditional failure of `Alternative`

computations. Defined by

guard True =`pure`

() guard False =`empty`

#### Examples

Common uses of `guard`

include conditionally signaling an error in
an error monad and conditionally rejecting the current choice in an
`Alternative`

-based parser.

As an example of signaling an error in the error monad `Maybe`

,
consider a safe division function `safeDiv x y`

that returns
`Nothing`

when the denominator `y`

is zero and

otherwise. For example:`Just`

(x `div`
y)

>>> safeDiv 4 0 Nothing >>> safeDiv 4 2 Just 2

A definition of `safeDiv`

using guards, but not `guard`

:

safeDiv :: Int -> Int -> Maybe Int safeDiv x y | y /= 0 = Just (x `div` y) | otherwise = Nothing

A definition of `safeDiv`

using `guard`

and `Monad`

`do`

-notation:

safeDiv :: Int -> Int -> Maybe Int safeDiv x y = do guard (y /= 0) return (x `div` y)

foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b Source #

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to weak head normal
form before being applied, avoiding the collection of thunks that would
otherwise occur. This is often what you want to strictly reduce a finite
list to a single, monolithic result (e.g. `length`

).

For a general `Foldable`

structure this should be semantically identical
to,

foldl' f z =`foldl'`

f z .`toList`

*Since: base-4.6.0.0*

fold :: (Foldable t, Monoid m) => t m -> m Source #

Combine the elements of a structure using a monoid.

for :: (Traversable t, Applicative f) => t a -> (a -> f b) -> f (t b) Source #

throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a Source #

Throw an exception. Exceptions may be thrown from purely
functional code, but may only be caught within the `IO`

monad.

join :: Monad m => m (m a) -> m a Source #

The `join`

function is the conventional monad join operator. It
is used to remove one level of monadic structure, projecting its
bound argument into the outer level.

'

' can be understood as the `join`

bss`do`

expression

do bs <- bss bs

#### Examples

A common use of `join`

is to run an `IO`

computation returned from
an `STM`

transaction, since `STM`

transactions
can't perform `IO`

directly. Recall that

`atomically`

:: STM a -> IO a

is used to run `STM`

transactions atomically. So, by
specializing the types of `atomically`

and `join`

to

`atomically`

:: STM (IO b) -> IO (IO b)`join`

:: IO (IO b) -> IO b

we can compose them as

`join`

.`atomically`

:: STM (IO b) -> IO b

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 Source #

Left-to-right composition of Kleisli arrows.

'`(bs `

' can be understood as the `>=>`

cs) a`do`

expression

do b <- bs a cs b

($>) :: Functor f => f a -> b -> f b infixl 4 Source #

Flipped version of `<$`

.

Using `ApplicativeDo`

: '`as `

' can be understood as the
`$>`

b`do`

expression

do as pure b

with an inferred `Functor`

constraint.

#### Examples

Replace the contents of a

with a constant
`Maybe`

`Int`

`String`

:

`>>>`

Nothing`Nothing $> "foo"`

`>>>`

Just "foo"`Just 90210 $> "foo"`

Replace the contents of an

with a constant `Either`

`Int`

`Int`

`String`

, resulting in an

:`Either`

`Int`

`String`

`>>>`

Left 8675309`Left 8675309 $> "foo"`

`>>>`

Right "foo"`Right 8675309 $> "foo"`

Replace each element of a list with a constant `String`

:

`>>>`

["foo","foo","foo"]`[1,2,3] $> "foo"`

Replace the second element of a pair with a constant `String`

:

`>>>`

(1,"foo")`(1,2) $> "foo"`

*Since: base-4.7.0.0*

fromRight :: b -> Either a b -> b Source #

Return the contents of a `Right`

-value or a default value otherwise.

#### Examples

Basic usage:

`>>>`

3`fromRight 1 (Right 3)`

`>>>`

1`fromRight 1 (Left "foo")`

*Since: base-4.10.0.0*

isRight :: Either a b -> Bool Source #

Return `True`

if the given value is a `Right`

-value, `False`

otherwise.

#### Examples

Basic usage:

`>>>`

False`isRight (Left "foo")`

`>>>`

True`isRight (Right 3)`

Assuming a `Left`

value signifies some sort of error, we can use
`isRight`

to write a very simple reporting function that only
outputs "SUCCESS" when a computation has succeeded.

This example shows how `isRight`

might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:

`>>>`

`import Control.Monad ( when )`

`>>>`

`let report e = when (isRight e) $ putStrLn "SUCCESS"`

`>>>`

`report (Left "parse error")`

`>>>`

SUCCESS`report (Right 1)`

*Since: base-4.7.0.0*

void :: Functor f => f a -> f () Source #

discards or ignores the result of evaluation, such
as the return value of an `void`

value`IO`

action.

Using `ApplicativeDo`

: '

' can be understood as the
`void`

as`do`

expression

do as pure ()

with an inferred `Functor`

constraint.

#### Examples

Replace the contents of a

with unit:`Maybe`

`Int`

`>>>`

Nothing`void Nothing`

`>>>`

Just ()`void (Just 3)`

Replace the contents of an

with unit, resulting in an `Either`

`Int`

`Int`

:`Either`

`Int`

`()`

`>>>`

Left 8675309`void (Left 8675309)`

`>>>`

Right ()`void (Right 8675309)`

Replace every element of a list with unit:

`>>>`

[(),(),()]`void [1,2,3]`

Replace the second element of a pair with unit:

`>>>`

(1,())`void (1,2)`

Discard the result of an `IO`

action:

`>>>`

1 2 [(),()]`mapM print [1,2]`

`>>>`

1 2`void $ mapM print [1,2]`

through :: Functor f => (a -> f b) -> a -> f a Source #

Makes an effectful function ignore its result value and return its input value.

coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b Source #

The function `coerce`

allows you to safely convert between values of
types that have the same representation with no run-time overhead. In the
simplest case you can use it instead of a newtype constructor, to go from
the newtype's concrete type to the abstract type. But it also works in
more complicated settings, e.g. converting a list of newtypes to a list of
concrete types.

This function is runtime-representation polymorphic, but the
`RuntimeRep`

type argument is marked as `Inferred`

, meaning
that it is not available for visible type application. This means
the typechecker will accept `coerce @Int @Age 42`

.

Representable types of kind `*`

.
This class is derivable in GHC with the `DeriveGeneric`

flag on.

A `Generic`

instance must satisfy the following laws:

`from`

.`to`

≡`id`

`to`

.`from`

≡`id`

#### Instances

A class of types that can be fully evaluated.

*Since: deepseq-1.1.0.0*