Safe Haskell  SafeInferred 

 zoom :: Monad m => LensLike' (Zooming m c) a b > StateT b m c > StateT a m c
 use :: Monad m => FoldLike b a a' b b' > StateT a m b
 uses :: Monad m => FoldLike r a a' b b' > (b > r) > StateT a m r
 (%=) :: Monad m => ASetter a a b b' > (b > b') > StateT a m ()
 assign :: Monad m => ASetter a a b b' > b' > StateT a m ()
 (.=) :: Monad m => ASetter a a b b' > b' > StateT a m ()
 (%%=) :: Monad m => LensLike (Writer c) a a b b' > (b > (c, b')) > StateT a m c
 (<~) :: Monad m => ASetter a a b b' > StateT a m b' > StateT a m ()
 (+=) :: (Monad m, Num b) => ASetter' a b > b > StateT a m ()
 (=) :: (Monad m, Num b) => ASetter' a b > b > StateT a m ()
 (*=) :: (Monad m, Num b) => ASetter' a b > b > StateT a m ()
 (//=) :: (Monad m, Fractional b) => ASetter' a b > b > StateT a m ()
 (&&=) :: Monad m => ASetter' a Bool > Bool > StateT a m ()
 (=) :: Monad m => ASetter' a Bool > Bool > StateT a m ()
 (<>=) :: (Monoid o, Monad m) => ASetter' a o > o > StateT a m ()
 data Zooming m c a
 type LensLike f a a' b b' = (b > f b') > a > f a'
 type LensLike' f a b = (b > f b) > a > f a
 type FoldLike r a a' b b' = LensLike (Constant r) a a' b b'
 data Constant a b
 type ASetter a a' b b' = LensLike Identity a a' b b'
 type ASetter' a b = LensLike' Identity a b
 data Identity a
 data StateT s m a
 type Writer w = WriterT w Identity
 class Monoid a
Documentation
zoom :: Monad m => LensLike' (Zooming m c) a b > StateT b m c > StateT a m cSource
zoom :: Monad m => Lens' a b > StateT b m c > StateT a 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 :: (Monoid c, Moand m) => Traversal' a b > StateT b m c > StateT a m c
Run the "subroutine" on each element of the traversal in turn and mconcat
all the results together.
zoom :: Monad m => Traversal' a b > StateT b m () > StateT a m ()
Run the "subroutine" on each element the traversal in turn.
use :: Monad m => FoldLike b a a' b b' > StateT a m bSource
use :: Monad m => Getter a a' b b' > StateT a m b
Retrieve a field of the state
use :: (Monoid b, Monad m) => Fold a a' b b' > StateT a m b
Retrieve a monoidal summary of all the referenced fields from the state
uses :: Monad m => FoldLike r a a' b b' > (b > r) > StateT a m rSource
uses :: (Monoid r, Monad m) => Fold a a' b b' > (b > r) > StateT a m r
Retrieve all the referenced fields from the state and foldMap the results together with f :: b > r
.
uses :: Monad m => Getter a a' b b' > (b > r) > StateT a m r
Retrieve a field of the state and pass it through the function f :: b > r
.
uses l f = f <$> use l
(%%=) :: Monad m => LensLike (Writer c) a a b b' > (b > (c, b')) > StateT a m cSource
(%%=) :: Monad m => Lens a a b b' > (b > (c, b')) > StateT a m c
Modify a field of the state while returning another value.
(%%=) :: (Monad m, Monoid c) => Traversal a a b b' > (b > (c, b')) > StateT a m c
Modify each field of the state and return the mconcat
of the other values.
(<~) :: Monad m => ASetter a a b b' > StateT a m b' > StateT a m ()Source
Set a field of the state using the result of executing a stateful command.
Compound Assignments
(<>=) :: (Monoid o, Monad m) => ASetter' a o > o > StateT a m ()Source
Monoidally append a value to all referenced fields of the state.
Types
Reexports
data Constant a b
Constant functor.
data Identity a
Identity functor and monad.
data StateT s m a
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.
class Monoid a
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
mappend mempty x = x
mappend x mempty = x
mappend x (mappend y z) = mappend (mappend x y) z
mconcat =
foldr
mappend mempty
The method names refer to the monoid of lists under concatenation, but there are many other instances.
Minimal complete definition: mempty
and mappend
.
Some types can be viewed as a monoid in more than one way,
e.g. both addition and multiplication on numbers.
In such cases we often define newtype
s and make those instances
of Monoid
, e.g. Sum
and Product
.
Monoid Ordering  
Monoid ()  
Monoid All  
Monoid Any  
Monoid IntSet  
Monoid [a]  
Monoid a => Monoid (Dual a)  
Monoid (Endo a)  
Num a => Monoid (Sum a)  
Num a => Monoid (Product a)  
Monoid (First a)  
Monoid (Last a)  
Monoid a => Monoid (Maybe a)  Lift a semigroup into 
Monoid (IntMap a)  
Ord a => Monoid (Set a)  
Monoid b => Monoid (a > b)  
(Monoid a, Monoid b) => Monoid (a, b)  
Ord k => Monoid (Map k v)  
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)  
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)  
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) 