| Copyright | (c) Andy Gill 2001 (c) Oregon Graduate Institute of Science and Technology 2001 |
|---|---|
| License | BSD-style (see the file libraries/base/LICENSE) |
| Maintainer | libraries@haskell.org |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
Data.Monoid
Description
A class for monoids (types with an associative binary operation that has an identity) with various general-purpose instances.
Synopsis
- class Semigroup a => Monoid a where
- (<>) :: Semigroup a => a -> a -> a
- newtype Dual a = Dual {
- getDual :: a
- newtype Endo a = Endo {
- appEndo :: a -> a
- newtype All = All {}
- newtype Any = Any {}
- newtype Sum a = Sum {
- getSum :: a
- newtype Product a = Product {
- getProduct :: a
- newtype First a = First {}
- newtype Last a = Last {}
- newtype Alt f a = Alt {
- getAlt :: f a
Monoid typeclass
class Semigroup a => Monoid a where Source #
The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:
x
<>mempty= xmempty<>x = xx(<>(y<>z) = (x<>y)<>zSemigrouplaw)mconcat=foldr'(<>)'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.
NOTE: Semigroup is a superclass of Monoid since base-4.11.0.0.
Minimal complete definition
Methods
Identity of mappend
mappend :: a -> a -> a Source #
An associative operation
NOTE: This method is redundant and has the default
implementation mappend = '(<>)'
Fold a list using the monoid.
For most types, the default definition for mconcat will be
used, but the function is included in the class definition so
that an optimized version can be provided for specific types.
Instances
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 4.11.0: constraint on inner a value generalised from
Monoid to Semigroup .
Since: 2.1
Instance details
Methods
mempty :: WrappedMonoid m Source #
mappend :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m Source #
mconcat :: [WrappedMonoid m] -> WrappedMonoid m Source #
The dual of a Monoid , obtained by swapping the arguments of mappend .
>>>getDual (mappend (Dual "Hello") (Dual "World"))"WorldHello"
Instances
Instance details
Methods
fold :: Monoid m => Dual m -> m Source #
foldMap :: Monoid m => (a -> m) -> Dual a -> m Source #
foldr :: (a -> b -> b) -> b -> Dual a -> b Source #
foldr' :: (a -> b -> b) -> b -> Dual a -> b Source #
foldl :: (b -> a -> b) -> b -> Dual a -> b Source #
foldl' :: (b -> a -> b) -> b -> Dual a -> b Source #
foldr1 :: (a -> a -> a) -> Dual a -> a Source #
foldl1 :: (a -> a -> a) -> Dual a -> a Source #
toList :: Dual a -> [a] Source #
null :: Dual a -> Bool Source #
length :: Dual a -> Int Source #
elem :: Eq a => a -> Dual a -> Bool Source #
maximum :: Ord a => Dual a -> a Source #
minimum :: Ord a => Dual a -> a Source #
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Dual a -> c (Dual a) Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Dual a) Source #
toConstr :: Dual a -> Constr Source #
dataTypeOf :: Dual a -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Dual a)) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Dual a)) Source #
gmapT :: (forall b. Data b => b -> b) -> Dual a -> Dual a Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Dual a -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> Dual a -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> Dual a -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Dual a -> m (Dual a) Source #
The monoid of endomorphisms under composition.
>>>let computation = Endo ("Hello, " ++) <> Endo (++ "!")>>>appEndo computation "Haskell""Hello, Haskell!"
Instances
Bool wrappers
Boolean monoid under conjunction (&& ).
>>>getAll (All True <> mempty <> All False)False
>>>getAll (mconcat (map (\x -> All (even x)) [2,4,6,7,8]))False
Instances
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> All -> c All Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c All Source #
toConstr :: All -> Constr Source #
dataTypeOf :: All -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c All) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c All) Source #
gmapT :: (forall b. Data b => b -> b) -> All -> All Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> All -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> All -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> All -> m All Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> All -> m All Source #
Boolean monoid under disjunction (|| ).
>>>getAny (Any True <> mempty <> Any False)True
>>>getAny (mconcat (map (\x -> Any (even x)) [2,4,6,7,8]))True
Instances
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Any -> c Any Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Any Source #
toConstr :: Any -> Constr Source #
dataTypeOf :: Any -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Any) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Any) Source #
gmapT :: (forall b. Data b => b -> b) -> Any -> Any Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> Any -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> Any -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> Any -> m Any Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Any -> m Any Source #
Num wrappers
Monoid under addition.
>>>getSum (Sum 1 <> Sum 2 <> mempty)3
Instances
Instance details
Methods
fold :: Monoid m => Sum m -> m Source #
foldMap :: Monoid m => (a -> m) -> Sum a -> m Source #
foldr :: (a -> b -> b) -> b -> Sum a -> b Source #
foldr' :: (a -> b -> b) -> b -> Sum a -> b Source #
foldl :: (b -> a -> b) -> b -> Sum a -> b Source #
foldl' :: (b -> a -> b) -> b -> Sum a -> b Source #
foldr1 :: (a -> a -> a) -> Sum a -> a Source #
foldl1 :: (a -> a -> a) -> Sum a -> a Source #
toList :: Sum a -> [a] Source #
null :: Sum a -> Bool Source #
length :: Sum a -> Int Source #
elem :: Eq a => a -> Sum a -> Bool Source #
maximum :: Ord a => Sum a -> a Source #
minimum :: Ord a => Sum a -> a Source #
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Sum a -> c (Sum a) Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Sum a) Source #
toConstr :: Sum a -> Constr Source #
dataTypeOf :: Sum a -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Sum a)) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Sum a)) Source #
gmapT :: (forall b. Data b => b -> b) -> Sum a -> Sum a Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sum a -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> Sum a -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sum a -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Sum a -> m (Sum a) Source #
Monoid under multiplication.
>>>getProduct (Product 3 <> Product 4 <> mempty)12
Instances
Instance details
Methods
fold :: Monoid m => Product m -> m Source #
foldMap :: Monoid m => (a -> m) -> Product a -> m Source #
foldr :: (a -> b -> b) -> b -> Product a -> b Source #
foldr' :: (a -> b -> b) -> b -> Product a -> b Source #
foldl :: (b -> a -> b) -> b -> Product a -> b Source #
foldl' :: (b -> a -> b) -> b -> Product a -> b Source #
foldr1 :: (a -> a -> a) -> Product a -> a Source #
foldl1 :: (a -> a -> a) -> Product a -> a Source #
toList :: Product a -> [a] Source #
null :: Product a -> Bool Source #
length :: Product a -> Int Source #
elem :: Eq a => a -> Product a -> Bool Source #
maximum :: Ord a => Product a -> a Source #
minimum :: Ord a => Product a -> a Source #
Instance details
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Product a -> c (Product a) Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Product a) Source #
toConstr :: Product a -> Constr Source #
dataTypeOf :: Product a -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Product a)) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Product a)) Source #
gmapT :: (forall b. Data b => b -> b) -> Product a -> Product a Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Product a -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> Product a -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> Product a -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Product a -> m (Product a) Source #
Instance details
Methods
(+) :: Product a -> Product a -> Product a Source #
(-) :: Product a -> Product a -> Product a Source #
(*) :: Product a -> Product a -> Product a Source #
negate :: Product a -> Product a Source #
abs :: Product a -> Product a Source #
signum :: Product a -> Product a Source #
fromInteger :: Integer -> Product a Source #
Maybe wrappers
To implement find or findLast on any Foldable:
findLast :: Foldable t => (a -> Bool) -> t a -> Maybe a findLast pred = getLast . foldMap (x -> if pred x then Last (Just x) else Last Nothing)
Much of Data.Map's interface can be implemented with
Data.Map.alter. Some of the rest can be implemented with a new
alterA function and either First or Last :
alterA :: (Applicative f, Ord k) => (Maybe a -> f (Maybe a)) -> k -> Map k a -> f (Map k a) instance Monoid a => Applicative ((,) a) -- from Control.Applicative
insertLookupWithKey :: Ord k => (k -> v -> v -> v) -> k -> v -> Map k v -> (Maybe v, Map k v) insertLookupWithKey combine key value = Arrow.first getFirst . alterA doChange key where doChange Nothing = (First Nothing, Just value) doChange (Just oldValue) = (First (Just oldValue), Just (combine key value oldValue))
Maybe monoid returning the leftmost non-Nothing value.
First aAlt Maybe a
>>>getFirst (First (Just "hello") <> First Nothing <> First (Just "world"))Just "hello"
Instances
Instance details
Methods
fold :: Monoid m => First m -> m Source #
foldMap :: Monoid m => (a -> m) -> First a -> m Source #
foldr :: (a -> b -> b) -> b -> First a -> b Source #
foldr' :: (a -> b -> b) -> b -> First a -> b Source #
foldl :: (b -> a -> b) -> b -> First a -> b Source #
foldl' :: (b -> a -> b) -> b -> First a -> b Source #
foldr1 :: (a -> a -> a) -> First a -> a Source #
foldl1 :: (a -> a -> a) -> First a -> a Source #
toList :: First a -> [a] Source #
null :: First a -> Bool Source #
length :: First a -> Int Source #
elem :: Eq a => a -> First a -> Bool Source #
maximum :: Ord a => First a -> a Source #
minimum :: Ord a => First a -> a Source #
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> First a -> c (First a) Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (First a) Source #
toConstr :: First a -> Constr Source #
dataTypeOf :: First a -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (First a)) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (First a)) Source #
gmapT :: (forall b. Data b => b -> b) -> First a -> First a Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> First a -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> First a -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> First a -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> First a -> m (First a) Source #
Maybe monoid returning the rightmost non-Nothing value.
Last aDual (First a)Dual (Alt Maybe a)
>>>getLast (Last (Just "hello") <> Last Nothing <> Last (Just "world"))Just "world"
Instances
Instance details
Methods
fold :: Monoid m => Last m -> m Source #
foldMap :: Monoid m => (a -> m) -> Last a -> m Source #
foldr :: (a -> b -> b) -> b -> Last a -> b Source #
foldr' :: (a -> b -> b) -> b -> Last a -> b Source #
foldl :: (b -> a -> b) -> b -> Last a -> b Source #
foldl' :: (b -> a -> b) -> b -> Last a -> b Source #
foldr1 :: (a -> a -> a) -> Last a -> a Source #
foldl1 :: (a -> a -> a) -> Last a -> a Source #
toList :: Last a -> [a] Source #
null :: Last a -> Bool Source #
length :: Last a -> Int Source #
elem :: Eq a => a -> Last a -> Bool Source #
maximum :: Ord a => Last a -> a Source #
minimum :: Ord a => Last a -> a Source #
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Last a -> c (Last a) Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Last a) Source #
toConstr :: Last a -> Constr Source #
dataTypeOf :: Last a -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Last a)) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Last a)) Source #
gmapT :: (forall b. Data b => b -> b) -> Last a -> Last a Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Last a -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> Last a -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> Last a -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Last a -> m (Last a) Source #
Alternative wrapper
Monoid under <|> .
Since: 4.8.0.0
Instances
Instance details
Methods
succ :: Alt f a -> Alt f a Source #
pred :: Alt f a -> Alt f a Source #
toEnum :: Int -> Alt f a Source #
fromEnum :: Alt f a -> Int Source #
enumFrom :: Alt f a -> [Alt f a] Source #
enumFromThen :: Alt f a -> Alt f a -> [Alt f a] Source #
enumFromTo :: Alt f a -> Alt f a -> [Alt f a] Source #
enumFromThenTo :: Alt f a -> Alt f a -> Alt f a -> [Alt f a] Source #
Instance details
Methods
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Alt f a -> c (Alt f a) Source #
gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Alt f a) Source #
toConstr :: Alt f a -> Constr Source #
dataTypeOf :: Alt f a -> DataType Source #
dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Alt f a)) Source #
dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Alt f a)) Source #
gmapT :: (forall b. Data b => b -> b) -> Alt f a -> Alt f a Source #
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r Source #
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Alt f a -> r Source #
gmapQ :: (forall d. Data d => d -> u) -> Alt f a -> [u] Source #
gmapQi :: Int -> (forall d. Data d => d -> u) -> Alt f a -> u Source #
gmapM :: Monad m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) Source #
gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) Source #
gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Alt f a -> m (Alt f a) Source #