Lens.Family.State.Strict

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.

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.

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

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

Constant functor.

Instances

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]

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

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

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

(*>) :: 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]

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

Methods

(>>=) :: Identity a -> (a -> Identity b) -> Identity b

(>>) :: Identity a -> Identity b -> Identity b

return :: a -> Identity a

fail :: String -> Identity a

Functor Identity

Methods

fmap :: (a -> b) -> Identity a -> Identity b

(<$) :: a -> Identity b -> Identity a

MonadFix Identity

Methods

mfix :: (a -> Identity a) -> Identity a

Applicative Identity

Methods

pure :: a -> Identity a

(<*>) :: Identity (a -> b) -> Identity a -> Identity b

(*>) :: Identity a -> Identity b -> Identity b

(<*) :: Identity a -> Identity b -> Identity a

Foldable Identity

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

Traversable Identity

Methods

traverse :: Applicative f => (a -> f b) -> Identity a -> f (Identity b)

sequenceA :: Applicative f => Identity (f a) -> f (Identity a)

mapM :: Monad m => (a -> m b) -> Identity a -> m (Identity b)

sequence :: Monad m => Identity (m a) -> m (Identity a)

Generic1 Identity

Associated Types

type Rep1 (Identity :: * -> *) :: * -> *

Methods

from1 :: Identity a -> Rep1 Identity a

to1 :: Rep1 Identity a -> Identity a

MonadZip Identity

Methods

mzip :: Identity a -> Identity b -> Identity (a, b)

mzipWith :: (a -> b -> c) -> Identity a -> Identity b -> Identity c

munzip :: Identity (a, b) -> (Identity a, Identity b)

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

Data a => Data (Identity a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Identity a -> c (Identity a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Identity a)

toConstr :: Identity a -> Constr

dataTypeOf :: Identity a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Identity a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Identity a))

gmapT :: (forall b. Data b => b -> b) -> Identity a -> Identity a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Identity a -> r

gmapQ :: (forall d. Data d => d -> u) -> Identity a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Identity a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Identity a -> m (Identity a)

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

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

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

IsString a => IsString (Identity a)

Methods

fromString :: String -> Identity a

Generic (Identity a)

Associated Types

type Rep (Identity a) :: * -> *

Methods

from :: Identity a -> Rep (Identity a) x

to :: Rep (Identity a) x -> Identity a

Semigroup a => Semigroup (Identity a)

Methods

(<>) :: Identity a -> Identity a -> Identity a

sconcat :: NonEmpty (Identity a) -> Identity a

stimes :: Integral b => b -> Identity a -> 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

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))

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)))

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

(*>) :: 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

Methods

mempty :: Ordering

mappend :: Ordering -> Ordering -> Ordering

mconcat :: [Ordering] -> Ordering

Monoid ()

Methods

mempty :: ()

mappend :: () -> () -> ()

mconcat :: [()] -> ()

Monoid All

Methods

mempty :: All

mappend :: All -> All -> All

mconcat :: [All] -> All

Monoid Any

Methods

mempty :: Any

mappend :: Any -> Any -> Any

mconcat :: [Any] -> Any

Monoid IntSet

Methods

mempty :: IntSet

mappend :: IntSet -> IntSet -> IntSet

mconcat :: [IntSet] -> IntSet

Monoid [a]

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 e*e = e and e*s = s = s*e for all s ∈ S." Since there is no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Methods

mempty :: Maybe a

mappend :: Maybe a -> Maybe a -> Maybe a

mconcat :: [Maybe a] -> Maybe a

Monoid a => Monoid (IO a)

Methods

mempty :: IO a

mappend :: IO a -> IO a -> IO a

mconcat :: [IO a] -> IO a

Ord a => Monoid (Max a)

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Ord a => Monoid (Min a)

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

Monoid a => Monoid (Identity a)

Methods

mempty :: Identity a

mappend :: Identity a -> Identity a -> Identity a

mconcat :: [Identity a] -> Identity a

(Ord a, Bounded a) => Monoid (Min a)

Methods

mempty :: Min a

mappend :: Min a -> Min a -> Min a

mconcat :: [Min a] -> Min a

(Ord a, Bounded a) => Monoid (Max a)

Methods

mempty :: Max a

mappend :: Max a -> Max a -> Max a

mconcat :: [Max a] -> Max a

Monoid m => Monoid (WrappedMonoid m)

Methods

mempty :: WrappedMonoid m

mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

mconcat :: [WrappedMonoid m] -> WrappedMonoid m

Semigroup a => Monoid (Option a)

Methods

mempty :: Option a

mappend :: Option a -> Option a -> Option a

mconcat :: [Option a] -> Option a

Monoid a => Monoid (Dual a)

Methods

mempty :: Dual a

mappend :: Dual a -> Dual a -> Dual a

mconcat :: [Dual a] -> Dual a

Monoid (Endo a)

Methods

mempty :: Endo a

mappend :: Endo a -> Endo a -> Endo a

mconcat :: [Endo a] -> Endo a

Num a => Monoid (Sum a)

Methods

mempty :: Sum a

mappend :: Sum a -> Sum a -> Sum a

mconcat :: [Sum a] -> Sum a

Num a => Monoid (Product a)

Methods

mempty :: Product a

mappend :: Product a -> Product a -> Product a

mconcat :: [Product a] -> Product a

Monoid (First a)

Methods

mempty :: First a

mappend :: First a -> First a -> First a

mconcat :: [First a] -> First a

Monoid (Last a)

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)

Methods

mempty :: a -> b

mappend :: (a -> b) -> (a -> b) -> a -> b

mconcat :: [a -> b] -> a -> b

(Monoid a, Monoid b) => Monoid (a, b)

Methods

mempty :: (a, b)

mappend :: (a, b) -> (a, b) -> (a, b)

mconcat :: [(a, b)] -> (a, b)

Monoid (Proxy k s)

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)

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)

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)

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)

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)