Lens.Family.State.Lazy

zoom :: Monad m => Lens' s a -> StateT a m c -> StateT s m c

Lift a stateful operation on a field to a stateful operation on the whole state. This is a good way to call a "subroutine" that only needs access to part of the state.

zoom :: (Monad m, Monoid c) => Traversal' s a -> StateT a m c -> StateT s m c

Run the "subroutine" on each element of the traversal in turn and mconcat all the results together.

zoom :: Monad m => Traversal' s a -> StateT a m () -> StateT s m ()

Run the "subroutine" on each element the traversal in turn.

use :: Monad m => Getter s t a b -> StateT s m a

Retrieve a field of the state

use :: (Monad m, Monoid a) => Fold s t a b -> StateT s m a

Retrieve a monoidal summary of all the referenced fields from the state

uses :: (Monad m, Monoid r) => Fold s t a b -> (a -> r) -> StateT s m r

Retrieve all the referenced fields from the state and foldMap the results together with f :: a -> r.

uses :: Monad m => Getter s t a b -> (a -> r) -> StateT s m r

Retrieve a field of the state and pass it through the function f :: a -> r.

uses l f = f <$> use l

Modify a field of the state.

Set a field of the state.

Set a field of the state.

(%%=) :: Monad m => Lens s s a b -> (a -> (c, b)) -> StateT s m c

Modify a field of the state while returning another value.

(%%=) :: (Monad m, Monoid c) => Traversal s s a b -> (a -> (c, b)) -> StateT s m c

Modify each field of the state and return the mconcat of the other values.

Set a field of the state using the result of executing a stateful command.

Monoidally append a value to all referenced fields of the state.

Strictly modify a field of the state.

Constant functor.

Identity functor and monad. (a non-strict monad)

Examples

>>> fmap (+1) (Identity 0)Identity 1

>>> Identity [1, 2, 3] <> Identity [4, 5, 6]Identity [1,2,3,4,5,6]

>>> do
      x <- Identity 10
      y <- Identity (x + 5)
      pure (x + y)
Identity 25

A state transformer monad parameterized by:

• s - The state.

• m - The inner monad.

The return function leaves the state unchanged, while >>= uses the final state of the first computation as the initial state of the second.

A writer monad parameterized by the type w of output to accumulate.

The return function produces the output mempty, while m >>= k combines the outputs of the subcomputations using mappend (also known as <>):

image: images/bind-WriterT.svg