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

Language | Haskell2010 |

Re-exports common internal imports. Not recommended for external use.

## Synopsis

- at :: At m => Index m -> Lens' m (Maybe (IxValue m))
- non :: Eq a => a -> Iso' (Maybe a) a
- use :: MonadState s m => Getting a s a -> m a
- view :: MonadReader s m => Getting a s a -> m a
- modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m ()
- assign :: MonadState s m => ASetter s s a b -> b -> m ()
- set :: ASetter s t a b -> b -> s -> t
- over :: ASetter s t a b -> (a -> b) -> s -> t
- unless :: Applicative f => Bool -> f () -> f ()
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- when :: Applicative f => Bool -> f () -> f ()
- throwError :: MonadError e m => e -> m a
- catchError :: MonadError e m => m a -> (e -> m a) -> m a

# Documentation

non :: Eq a => a -> Iso' (Maybe a) a #

If `v`

is an element of a type `a`

, and `a'`

is `a`

sans the element `v`

, then

is an isomorphism from
`non`

v

to `Maybe`

a'`a`

.

`non`

≡`non'`

`.`

`only`

Keep in mind this is only a real isomorphism if you treat the domain as being

.`Maybe`

(a sans v)

This is practically quite useful when you want to have a `Map`

where all the entries should have non-zero values.

`>>>`

fromList [("hello",3)]`Map.fromList [("hello",1)] & at "hello" . non 0 +~ 2`

`>>>`

fromList []`Map.fromList [("hello",1)] & at "hello" . non 0 -~ 1`

`>>>`

1`Map.fromList [("hello",1)] ^. at "hello" . non 0`

`>>>`

0`Map.fromList [] ^. at "hello" . non 0`

This combinator is also particularly useful when working with nested maps.

*e.g.* When you want to create the nested `Map`

when it is missing:

`>>>`

fromList [("hello",fromList [("world","!!!")])]`Map.empty & at "hello" . non Map.empty . at "world" ?~ "!!!"`

and when have deleting the last entry from the nested `Map`

mean that we
should delete its entry from the surrounding one:

`>>>`

fromList []`fromList [("hello",fromList [("world","!!!")])] & at "hello" . non Map.empty . at "world" .~ Nothing`

It can also be used in reverse to exclude a given value:

`>>>`

Just 2`non 0 # rem 10 4`

`>>>`

Nothing`non 0 # rem 10 5`

use :: MonadState s m => Getting a s a -> m a #

Use the target of a `Lens`

, `Iso`

, or
`Getter`

in the current state, or use a summary of a
`Fold`

or `Traversal`

that points
to a monoidal value.

`>>>`

a`evalState (use _1) (a,b)`

`>>>`

"hello"`evalState (use _1) ("hello","world")`

`use`

::`MonadState`

s m =>`Getter`

s a -> m a`use`

:: (`MonadState`

s m,`Monoid`

r) =>`Fold`

s r -> m r`use`

::`MonadState`

s m =>`Iso'`

s a -> m a`use`

::`MonadState`

s m =>`Lens'`

s a -> m a`use`

:: (`MonadState`

s m,`Monoid`

r) =>`Traversal'`

s r -> m r

view :: MonadReader s m => Getting a s a -> m a #

View the value pointed to by a `Getter`

, `Iso`

or
`Lens`

or the result of folding over all the results of a
`Fold`

or `Traversal`

that points
at a monoidal value.

`view`

`.`

`to`

≡`id`

`>>>`

f a`view (to f) a`

`>>>`

"hello"`view _2 (1,"hello")`

`>>>`

6`view (to succ) 5`

`>>>`

"world"`view (_2._1) ("hello",("world","!!!"))`

As `view`

is commonly used to access the target of a `Getter`

or obtain a monoidal summary of the targets of a `Fold`

,
It may be useful to think of it as having one of these more restricted signatures:

`view`

::`Getter`

s a -> s -> a`view`

::`Monoid`

m =>`Fold`

s m -> s -> m`view`

::`Iso'`

s a -> s -> a`view`

::`Lens'`

s a -> s -> a`view`

::`Monoid`

m =>`Traversal'`

s m -> s -> m

In a more general setting, such as when working with a `Monad`

transformer stack you can use:

`view`

::`MonadReader`

s m =>`Getter`

s a -> m a`view`

:: (`MonadReader`

s m,`Monoid`

a) =>`Fold`

s a -> m a`view`

::`MonadReader`

s m =>`Iso'`

s a -> m a`view`

::`MonadReader`

s m =>`Lens'`

s a -> m a`view`

:: (`MonadReader`

s m,`Monoid`

a) =>`Traversal'`

s a -> m a

modifying :: MonadState s m => ASetter s s a b -> (a -> b) -> m () #

This is an alias for (`%=`

).

assign :: MonadState s m => ASetter s s a b -> b -> m () #

Replace the target of a `Lens`

or all of the targets of a `Setter`

or `Traversal`

in our monadic
state with a new value, irrespective of the old.

This is an alias for (`.=`

).

`>>>`

(c,d)`execState (do assign _1 c; assign _2 d) (a,b)`

`>>>`

(c,c)`execState (both .= c) (a,b)`

`assign`

::`MonadState`

s m =>`Iso'`

s a -> a -> m ()`assign`

::`MonadState`

s m =>`Lens'`

s a -> a -> m ()`assign`

::`MonadState`

s m =>`Traversal'`

s a -> a -> m ()`assign`

::`MonadState`

s m =>`Setter'`

s a -> a -> m ()

set :: ASetter s t a b -> b -> s -> t #

Replace the target of a `Lens`

or all of the targets of a `Setter`

or `Traversal`

with a constant value.

(`<$`

) ≡`set`

`mapped`

`>>>`

(1,"hello")`set _2 "hello" (1,())`

`>>>`

[(),(),(),()]`set mapped () [1,2,3,4]`

Note: Attempting to `set`

a `Fold`

or `Getter`

will fail at compile time with an
relatively nice error message.

`set`

::`Setter`

s t a b -> b -> s -> t`set`

::`Iso`

s t a b -> b -> s -> t`set`

::`Lens`

s t a b -> b -> s -> t`set`

::`Traversal`

s t a b -> b -> s -> t

over :: ASetter s t a b -> (a -> b) -> s -> t #

Modify the target of a `Lens`

or all the targets of a `Setter`

or `Traversal`

with a function.

`fmap`

≡`over`

`mapped`

`fmapDefault`

≡`over`

`traverse`

`sets`

`.`

`over`

≡`id`

`over`

`.`

`sets`

≡`id`

Given any valid `Setter`

`l`

, you can also rely on the law:

`over`

l f`.`

`over`

l g =`over`

l (f`.`

g)

*e.g.*

`>>>`

True`over mapped f (over mapped g [a,b,c]) == over mapped (f . g) [a,b,c]`

Another way to view `over`

is to say that it transforms a `Setter`

into a
"semantic editor combinator".

`>>>`

Just (f a)`over mapped f (Just a)`

`>>>`

[10,20,30]`over mapped (*10) [1,2,3]`

`>>>`

(f a,b)`over _1 f (a,b)`

`>>>`

("10",20)`over _1 show (10,20)`

`over`

::`Setter`

s t a b -> (a -> b) -> s -> t`over`

::`ASetter`

s t a b -> (a -> b) -> s -> t

unless :: Applicative f => Bool -> f () -> f () #

The reverse of `when`

.

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b #

The `foldM`

function is analogous to `foldl`

, except that its result is
encapsulated in a monad. Note that `foldM`

works from left-to-right over
the list arguments. This could be an issue where `(`

and the `folded
function' are not commutative.`>>`

)

foldM f a1 [x1, x2, ..., xm] == do a2 <- f a1 x1 a3 <- f a2 x2 ... f am xm

If right-to-left evaluation is required, the input list should be reversed.

when :: Applicative f => Bool -> f () -> f () #

Conditional execution of `Applicative`

expressions. For example,

when debug (putStrLn "Debugging")

will output the string `Debugging`

if the Boolean value `debug`

is `True`

, and otherwise do nothing.

throwError :: MonadError e m => e -> m a #

Is used within a monadic computation to begin exception processing.

catchError :: MonadError e m => m a -> (e -> m a) -> m a #

A handler function to handle previous errors and return to normal execution. A common idiom is:

do { action1; action2; action3 } `catchError` handler

where the `action`

functions can call `throwError`

.
Note that `handler`

and the do-block must have the same return type.