Safe Haskell	Safe
Language	Haskell98

Lens.Family.State.Strict

Contents

Compound Assignments
Strict Assignments
Types
Re-exports

Description

Lenses allow you to use fields of the state of a state monad as if they were variables in an imperative language. use is used to retrieve the value of a variable, and .= and %= allow you to set and modify a variable. C-style compound assignments are also provided.

Synopsis

Documentation

zoom :: Monad m => LensLike' (Zooming m c) a b -> StateT b m c -> StateT a m c #

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, Monad 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 b #

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 r #

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 => ASetter a a b b' -> (b -> b') -> StateT a m () infix 4 #

Modify a field of the state.

assign :: Monad m => ASetter a a b b' -> b' -> StateT a m () #

Set a field of the state.

(.=) :: Monad m => ASetter a a b b' -> b' -> StateT a m () infix 4 #

Set a field of the state.

(%%=) :: Monad m => LensLike (Writer c) a a b b' -> (b -> (c, b')) -> StateT a m c infix 4 #

(%%=) :: 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 () infixr 2 #

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

Compound Assignments

(+=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(-=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(*=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(//=) :: (Monad m, Fractional b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(&&=) :: Monad m => ASetter' a Bool -> Bool -> StateT a m () infixr 4 #

(||=) :: Monad m => ASetter' a Bool -> Bool -> StateT a m () infixr 4 #

(<>=) :: (Monoid o, Monad m) => ASetter' a o -> o -> StateT a m () infixr 4 #

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

Strict Assignments

(%!=) :: Monad m => ASetter a a b b' -> (b -> b') -> StateT a m () infix 4 #

Strictly modify a field of the state.

(+!=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(-!=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(*!=) :: (Monad m, Num b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(//!=) :: (Monad m, Fractional b) => ASetter' a b -> b -> StateT a m () infixr 4 #

(&&!=) :: Monad m => ASetter' a Bool -> Bool -> StateT a m () infixr 4 #

(||!=) :: Monad m => ASetter' a Bool -> Bool -> StateT a m () infixr 4 #

(<>!=) :: (Monoid o, Monad m) => ASetter' a o -> o -> StateT a m () infixr 4 #

Types

data Zooming m c a #

Instances

Monad m => Functor (Zooming m c) #
Methods fmap :: (a -> b) -> Zooming m c a -> Zooming m c b # (<$) :: a -> Zooming m c b -> Zooming m c a #
(Monoid c, Monad m) => Applicative (Zooming m c) #
Methods pure :: a -> Zooming m c a # (<>) :: Zooming m c (a -> b) -> Zooming m c a -> Zooming m c b # liftA2 :: (a -> b -> c) -> Zooming m c a -> Zooming m c b -> Zooming m c c # (>) :: Zooming m c a -> Zooming m c b -> Zooming m c b # (<*) :: Zooming m c a -> Zooming m c b -> Zooming m c a #

Re-exports

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 k a (b :: k) :: forall k. * -> k -> * #

Constant functor.

Instances

Bifunctor (Constant *)
Methods bimap :: (a -> b) -> (c -> d) -> Constant * a c -> Constant * b d # first :: (a -> b) -> Constant * a c -> Constant * b c # second :: (b -> c) -> Constant * a b -> Constant * a c #
Eq2 (Constant *)
Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> Constant * a c -> Constant * b d -> Bool #
Ord2 (Constant *)
Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> Constant * a c -> Constant * b d -> Ordering #
Read2 (Constant *)
Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Constant * a b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Constant * a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Constant * a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Constant * a b] #
Show2 (Constant *)
Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> Constant * a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [Constant * a b] -> ShowS #
Functor (Constant * a)
Methods fmap :: (a -> b) -> Constant * a a -> Constant * a b # (<$) :: a -> Constant * a b -> Constant * a a #
Monoid a => Applicative (Constant * a)
Methods pure :: a -> Constant * a a # (<>) :: Constant a (a -> b) -> Constant * a a -> Constant * a b # liftA2 :: (a -> b -> c) -> Constant * a a -> Constant * a b -> Constant * a c # (>) :: Constant a a -> Constant * a b -> Constant * a b # (<) :: Constant a a -> Constant * a b -> Constant * a a #
Foldable (Constant * a)
Methods fold :: Monoid m => Constant * a m -> m # foldMap :: Monoid m => (a -> m) -> Constant * a a -> m # foldr :: (a -> b -> b) -> b -> Constant * a a -> b # foldr' :: (a -> b -> b) -> b -> Constant * a a -> b # foldl :: (b -> a -> b) -> b -> Constant * a a -> b # foldl' :: (b -> a -> b) -> b -> Constant * a a -> b # foldr1 :: (a -> a -> a) -> Constant * a a -> a # foldl1 :: (a -> a -> a) -> Constant * a a -> a # toList :: Constant * a a -> [a] # null :: Constant * a a -> Bool # length :: Constant * a a -> Int # elem :: Eq a => a -> Constant * a a -> Bool # maximum :: Ord a => Constant * a a -> a # minimum :: Ord a => Constant * a a -> a # sum :: Num a => Constant * a a -> a # product :: Num a => Constant * a a -> a #
Traversable (Constant * a)
Methods traverse :: Applicative f => (a -> f b) -> Constant * a a -> f (Constant * a b) # sequenceA :: Applicative f => Constant * a (f a) -> f (Constant * a a) # mapM :: Monad m => (a -> m b) -> Constant * a a -> m (Constant * a b) # sequence :: Monad m => Constant * a (m a) -> m (Constant * a a) #
Eq a => Eq1 (Constant * a)
Methods liftEq :: (a -> b -> Bool) -> Constant * a a -> Constant * a b -> Bool #
Ord a => Ord1 (Constant * a)
Methods liftCompare :: (a -> b -> Ordering) -> Constant * a a -> Constant * a b -> Ordering #
Read a => Read1 (Constant * a)
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Constant * a a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Constant * a a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Constant * a a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Constant * a a] #
Show a => Show1 (Constant * a)
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Constant * a a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Constant * a a] -> ShowS #
Phantom (Constant * a) #
Methods coerce :: Constant * a a -> Constant * a b
Eq a => Eq (Constant k a b)
Methods (==) :: Constant k a b -> Constant k a b -> Bool # (/=) :: Constant k a b -> Constant k a b -> Bool #
Ord a => Ord (Constant k a b)
Methods compare :: Constant k a b -> Constant k a b -> Ordering # (<) :: Constant k a b -> Constant k a b -> Bool # (<=) :: Constant k a b -> Constant k a b -> Bool # (>) :: Constant k a b -> Constant k a b -> Bool # (>=) :: Constant k a b -> Constant k a b -> Bool # max :: Constant k a b -> Constant k a b -> Constant k a b # min :: Constant k a b -> Constant k a b -> Constant k a b #
Read a => Read (Constant k a b)
Methods readsPrec :: Int -> ReadS (Constant k a b) # readList :: ReadS [Constant k a b] # readPrec :: ReadPrec (Constant k a b) # readListPrec :: ReadPrec [Constant k a b] #
Show a => Show (Constant k a b)
Methods showsPrec :: Int -> Constant k a b -> ShowS # show :: Constant k a b -> String # showList :: [Constant k a b] -> ShowS #
Monoid a => Monoid (Constant k a b)
Methods mempty :: Constant k a b # mappend :: Constant k a b -> Constant k a b -> Constant k a b # mconcat :: [Constant k a b] -> Constant k 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 :: * -> * #

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

Since: 4.8.0.0

Instances

Monad Identity	Since: 4.8.0.0
Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a # fail :: String -> Identity a #
Functor Identity	Since: 4.8.0.0
Methods fmap :: (a -> b) -> Identity a -> Identity b # (<$) :: a -> Identity b -> Identity a #
MonadFix Identity	Since: 4.8.0.0
Methods mfix :: (a -> Identity a) -> Identity a #
Applicative Identity	Since: 4.8.0.0
Methods pure :: a -> Identity a # (<>) :: Identity (a -> b) -> Identity a -> Identity b # liftA2 :: (a -> b -> c) -> Identity a -> Identity b -> Identity c # (>) :: Identity a -> Identity b -> Identity b # (<*) :: Identity a -> Identity b -> Identity a #
Foldable Identity	Since: 4.8.0.0
Methods fold :: Monoid m => Identity m -> m # foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b # foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b # foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] # null :: Identity a -> Bool # length :: Identity a -> Int # elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # sum :: Num a => Identity a -> a # product :: Num a => Identity a -> a #
Eq1 Identity	Since: 4.9.0.0
Methods liftEq :: (a -> b -> Bool) -> Identity a -> Identity b -> Bool #
Ord1 Identity	Since: 4.9.0.0
Methods liftCompare :: (a -> b -> Ordering) -> Identity a -> Identity b -> Ordering #
Read1 Identity	Since: 4.9.0.0
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Identity a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Identity a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Identity a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Identity a] #
Show1 Identity	Since: 4.9.0.0
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> Identity a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [Identity a] -> ShowS #
Identical Identity #
Methods extract :: Identity a -> a
Bounded a => Bounded (Identity a)
Methods minBound :: Identity a # maxBound :: Identity a #
Enum a => Enum (Identity a)
Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # toEnum :: Int -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] #
Eq a => Eq (Identity a)
Methods (==) :: Identity a -> Identity a -> Bool # (/=) :: Identity a -> Identity a -> Bool #
Floating a => Floating (Identity a)
Methods pi :: Identity a # exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a # expm1 :: Identity a -> Identity a # log1pexp :: Identity a -> Identity a # log1mexp :: Identity a -> Identity a #
Fractional a => Fractional (Identity a)
Methods (/) :: Identity a -> Identity a -> Identity a # recip :: Identity a -> Identity a # fromRational :: Rational -> Identity a #
Integral a => Integral (Identity a)
Methods quot :: Identity a -> Identity a -> Identity a # rem :: Identity a -> Identity a -> Identity a # div :: Identity a -> Identity a -> Identity a # mod :: Identity a -> Identity a -> Identity a # quotRem :: Identity a -> Identity a -> (Identity a, Identity a) # divMod :: Identity a -> Identity a -> (Identity a, Identity a) # toInteger :: Identity a -> Integer #
Num a => Num (Identity a)
Methods (+) :: Identity a -> Identity a -> Identity a # (-) :: Identity a -> Identity a -> Identity a # (*) :: Identity a -> Identity a -> Identity a # negate :: Identity a -> Identity a # abs :: Identity a -> Identity a # signum :: Identity a -> Identity a # fromInteger :: Integer -> Identity a #
Ord a => Ord (Identity a)
Methods compare :: Identity a -> Identity a -> Ordering # (<) :: Identity a -> Identity a -> Bool # (<=) :: Identity a -> Identity a -> Bool # (>) :: Identity a -> Identity a -> Bool # (>=) :: Identity a -> Identity a -> Bool # max :: Identity a -> Identity a -> Identity a # min :: Identity a -> Identity a -> Identity a #
Read a => Read (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: 4.8.0.0
Methods readsPrec :: Int -> ReadS (Identity a) # readList :: ReadS [Identity a] # readPrec :: ReadPrec (Identity a) # readListPrec :: ReadPrec [Identity a] #
Real a => Real (Identity a)
Methods toRational :: Identity a -> Rational #
RealFloat a => RealFloat (Identity a)
Methods floatRadix :: Identity a -> Integer # floatDigits :: Identity a -> Int # floatRange :: Identity a -> (Int, Int) # decodeFloat :: Identity a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Identity a # exponent :: Identity a -> Int # significand :: Identity a -> Identity a # scaleFloat :: Int -> Identity a -> Identity a # isNaN :: Identity a -> Bool # isInfinite :: Identity a -> Bool # isDenormalized :: Identity a -> Bool # isNegativeZero :: Identity a -> Bool # isIEEE :: Identity a -> Bool # atan2 :: Identity a -> Identity a -> Identity a #
RealFrac a => RealFrac (Identity a)
Methods properFraction :: Integral b => Identity a -> (b, Identity a) # truncate :: Integral b => Identity a -> b # round :: Integral b => Identity a -> b # ceiling :: Integral b => Identity a -> b # floor :: Integral b => Identity a -> b #
Show a => Show (Identity a)	This instance would be equivalent to the derived instances of the `Identity` newtype if the `runIdentity` field were removed Since: 4.8.0.0
Methods showsPrec :: Int -> Identity a -> ShowS # show :: Identity a -> String # showList :: [Identity a] -> ShowS #
Ix a => Ix (Identity a)
Methods range :: (Identity a, Identity a) -> [Identity a] # index :: (Identity a, Identity a) -> Identity a -> Int # unsafeIndex :: (Identity a, Identity a) -> Identity a -> Int inRange :: (Identity a, Identity a) -> Identity a -> Bool # rangeSize :: (Identity a, Identity a) -> Int # unsafeRangeSize :: (Identity a, Identity a) -> Int
Generic (Identity a)
Associated Types type Rep (Identity a) :: * -> * # Methods from :: Identity a -> Rep (Identity a) x # to :: Rep (Identity a) x -> Identity a #
Monoid a => Monoid (Identity a)
Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Storable a => Storable (Identity a)
Methods sizeOf :: Identity a -> Int # alignment :: Identity a -> Int # peekElemOff :: Ptr (Identity a) -> Int -> IO (Identity a) # pokeElemOff :: Ptr (Identity a) -> Int -> Identity a -> IO () # peekByteOff :: Ptr b -> Int -> IO (Identity a) # pokeByteOff :: Ptr b -> Int -> Identity a -> IO () # peek :: Ptr (Identity a) -> IO (Identity a) # poke :: Ptr (Identity a) -> Identity a -> IO () #
Bits a => Bits (Identity a)
Methods (.&.) :: Identity a -> Identity a -> Identity a # (.\|.) :: Identity a -> Identity a -> Identity a # xor :: Identity a -> Identity a -> Identity a # complement :: Identity a -> Identity a # shift :: Identity a -> Int -> Identity a # rotate :: Identity a -> Int -> Identity a # zeroBits :: Identity a # bit :: Int -> Identity a # setBit :: Identity a -> Int -> Identity a # clearBit :: Identity a -> Int -> Identity a # complementBit :: Identity a -> Int -> Identity a # testBit :: Identity a -> Int -> Bool # bitSizeMaybe :: Identity a -> Maybe Int # bitSize :: Identity a -> Int # isSigned :: Identity a -> Bool # shiftL :: Identity a -> Int -> Identity a # unsafeShiftL :: Identity a -> Int -> Identity a # shiftR :: Identity a -> Int -> Identity a # unsafeShiftR :: Identity a -> Int -> Identity a # rotateL :: Identity a -> Int -> Identity a # rotateR :: Identity a -> Int -> Identity a # popCount :: Identity a -> Int #
FiniteBits a => FiniteBits (Identity a)
Methods finiteBitSize :: Identity a -> Int # countLeadingZeros :: Identity a -> Int # countTrailingZeros :: Identity a -> Int #
Generic1 * Identity
Associated Types type Rep1 Identity (f :: Identity -> ) :: k -> # Methods from1 :: f a -> Rep1 Identity f a # to1 :: Rep1 Identity f a -> f a #
type Rep (Identity a)
type Rep (Identity a) = D1 * (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 * (MetaCons "Identity" PrefixI True) (S1 * (MetaSel (Just Symbol "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))
type Rep1 * Identity
type Rep1 * Identity = D1 * (MetaData "Identity" "Data.Functor.Identity" "base" True) (C1 * (MetaCons "Identity" PrefixI True) (S1 * (MetaSel (Just Symbol "runIdentity") NoSourceUnpackedness NoSourceStrictness DecidedLazy) Par1))

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.

Instances

MonadTrans (StateT s)
Methods lift :: Monad m => m a -> StateT s m a #
Monad m => Monad (StateT s m)
Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a # fail :: String -> StateT s m a #
Functor m => Functor (StateT s m)
Methods fmap :: (a -> b) -> StateT s m a -> StateT s m b # (<$) :: a -> StateT s m b -> StateT s m a #
MonadFix m => MonadFix (StateT s m)
Methods mfix :: (a -> StateT s m a) -> StateT s m a #
MonadFail m => MonadFail (StateT s m)
Methods fail :: String -> StateT s m a #
(Functor m, Monad m) => Applicative (StateT s m)
Methods pure :: a -> StateT s m a # (<>) :: StateT s m (a -> b) -> StateT s m a -> StateT s m b # liftA2 :: (a -> b -> c) -> StateT s m a -> StateT s m b -> StateT s m c # (>) :: StateT s m a -> StateT s m b -> StateT s m b # (<*) :: StateT s m a -> StateT s m b -> StateT s m a #
MonadIO m => MonadIO (StateT s m)
Methods liftIO :: IO a -> StateT s m a #
(Functor m, MonadPlus m) => Alternative (StateT s m)
Methods empty :: StateT s m a # (<\|>) :: StateT s m a -> StateT s m a -> StateT s m a # some :: StateT s m a -> StateT s m [a] # many :: StateT s m a -> StateT s m [a] #
MonadPlus m => MonadPlus (StateT s m)
Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #

type Writer w = WriterT w Identity #

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

The return function produces the output mempty, while >>= combines the outputs of the subcomputations using mappend.

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.

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 newtypes and make those instances of Monoid, e.g. Sum and Product.

Minimal complete definition

mempty, mappend

Instances

Monoid Ordering	Since: 2.1
Methods mempty :: Ordering # mappend :: Ordering -> Ordering -> Ordering # mconcat :: [Ordering] -> Ordering #
Monoid ()	Since: 2.1
Methods mempty :: () # mappend :: () -> () -> () # mconcat :: [()] -> () #
Monoid All	Since: 2.1
Methods mempty :: All # mappend :: All -> All -> All # mconcat :: [All] -> All #
Monoid Any	Since: 2.1
Methods mempty :: Any # mappend :: Any -> Any -> Any # mconcat :: [Any] -> Any #
Monoid IntSet
Methods mempty :: IntSet # mappend :: IntSet -> IntSet -> IntSet # mconcat :: [IntSet] -> IntSet #
Monoid [a]	Since: 2.1
Methods mempty :: [a] # mappend :: [a] -> [a] -> [a] # mconcat :: [[a]] -> [a] #
Monoid a => Monoid (Maybe a)	Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `ee = e` and `es = s = se` for all `s ∈ S`." Since there used to be no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead. Since: 2.1*
Methods mempty :: Maybe a # mappend :: Maybe a -> Maybe a -> Maybe a # mconcat :: [Maybe a] -> Maybe a #
Monoid a => Monoid (IO a)	Since: 4.9.0.0
Methods mempty :: IO a # mappend :: IO a -> IO a -> IO a # mconcat :: [IO a] -> IO a #
Monoid a => Monoid (Identity a)
Methods mempty :: Identity a # mappend :: Identity a -> Identity a -> Identity a # mconcat :: [Identity a] -> Identity a #
Monoid a => Monoid (Dual a)	Since: 2.1
Methods mempty :: Dual a # mappend :: Dual a -> Dual a -> Dual a # mconcat :: [Dual a] -> Dual a #
Monoid (Endo a)	Since: 2.1
Methods mempty :: Endo a # mappend :: Endo a -> Endo a -> Endo a # mconcat :: [Endo a] -> Endo a #
Num a => Monoid (Sum a)	Since: 2.1
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
Num a => Monoid (Product a)	Since: 2.1
Methods mempty :: Product a # mappend :: Product a -> Product a -> Product a # mconcat :: [Product a] -> Product a #
Monoid (First a)	Since: 2.1
Methods mempty :: First a # mappend :: First a -> First a -> First a # mconcat :: [First a] -> First a #
Monoid (Last a)	Since: 2.1
Methods mempty :: Last a # mappend :: Last a -> Last a -> Last a # mconcat :: [Last a] -> Last a #
Monoid (IntMap a)
Methods mempty :: IntMap a # mappend :: IntMap a -> IntMap a -> IntMap a # mconcat :: [IntMap a] -> IntMap a #
Ord a => Monoid (Set a)
Methods mempty :: Set a # mappend :: Set a -> Set a -> Set a # mconcat :: [Set a] -> Set a #
Monoid b => Monoid (a -> b)	Since: 2.1
Methods mempty :: a -> b # mappend :: (a -> b) -> (a -> b) -> a -> b # mconcat :: [a -> b] -> a -> b #
(Monoid a, Monoid b) => Monoid (a, b)	Since: 2.1
Methods mempty :: (a, b) # mappend :: (a, b) -> (a, b) -> (a, b) # mconcat :: [(a, b)] -> (a, b) #
Monoid (Proxy k s)	Since: 4.7.0.0
Methods mempty :: Proxy k s # mappend :: Proxy k s -> Proxy k s -> Proxy k s # mconcat :: [Proxy k s] -> Proxy k s #
Ord k => Monoid (Map k v)
Methods mempty :: Map k v # mappend :: Map k v -> Map k v -> Map k v # mconcat :: [Map k v] -> Map k v #
(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c)	Since: 2.1
Methods mempty :: (a, b, c) # mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) # mconcat :: [(a, b, c)] -> (a, b, c) #
Monoid a => Monoid (Const k a b)
Methods mempty :: Const k a b # mappend :: Const k a b -> Const k a b -> Const k a b # mconcat :: [Const k a b] -> Const k a b #
Alternative f => Monoid (Alt * f a)	Since: 4.8.0.0
Methods mempty :: Alt * f a # mappend :: Alt * f a -> Alt * f a -> Alt * f a # mconcat :: [Alt * f a] -> Alt * f a #
Monoid a => Monoid (Constant k a b)
Methods mempty :: Constant k a b # mappend :: Constant k a b -> Constant k a b -> Constant k a b # mconcat :: [Constant k a b] -> Constant k a b #
(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d)	Since: 2.1
Methods mempty :: (a, b, c, d) # mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # mconcat :: [(a, b, c, d)] -> (a, b, c, d) #
(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)	Since: 2.1
Methods mempty :: (a, b, c, d, e) # mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #