| base-3.0.2.0: Basic libraries | Source code | Contents | Index
Data.Monoid |
Portability | portable
Stability | experimental
Maintainer | libraries@haskell.org
Contents
Monoid typeclass Bool wrappers Num wrappers Maybe wrappers
Description
The Monoid class with various general-purpose instances. Inspired by the paper /Functional Programming with Overloading and Higher-Order Polymorphism/, Mark P Jones (http://citeseer.ist.psu.edu/jones95functional.html) Advanced School of Functional Programming, 1995.
Synopsis
class Monoid a where
mempty :: a
mappend :: a -> a -> a
mconcat :: [a] -> a
newtype Dual a = Dual {
getDual :: a
}
newtype Endo a = Endo {
appEndo :: (a -> a)
}
newtype All = All {
getAll :: Bool
}
newtype Any = Any {
getAny :: Bool
}
newtype Sum a = Sum {
getSum :: a
}
newtype Product a = Product {
getProduct :: a
}
newtype First a = First {
getFirst :: (Maybe a)
}
newtype Last a = Last {
getLast :: (Maybe a)
}
Monoid typeclass
class Monoid a where | Source
The monoid class. A minimal complete definition must supply `mempty` and `mappend`, and these should satisfy the monoid laws.
Methods
mempty :: a | Source
Identity of `mappend`
mappend :: a -> a -> a | Source
An associative operation
mconcat :: [a] -> a | Source
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
Monoid All
Monoid Any
Monoid Ordering
Monoid ()
(Monoid a, Monoid b) => Monoid (a, b)
(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)
Monoid b => Monoid (a -> b)
Monoid a => Monoid (Dual a)
Monoid (Endo a)
Monoid (First a)
Monoid (Last a)
Monoid a => Monoid (Maybe a)
Num a => Monoid (Product a)
Num a => Monoid (Sum a)
Monoid [a]
newtype Dual a | Source
The dual of a monoid, obtained by swapping the arguments of `mappend`.
Constructors
Dual |
getDual :: a |
Instances
Bounded a => Bounded (Dual a)
Eq a => Eq (Dual a)
Monoid a => Monoid (Dual a)
Ord a => Ord (Dual a)
Read a => Read (Dual a)
Show a => Show (Dual a)
newtype Endo a | Source
The monoid of endomorphisms under composition.
Constructors
Endo |
appEndo :: (a -> a) |
Instances
Monoid (Endo a)
Bool wrappers
newtype All | Source
Boolean monoid under conjunction.
Constructors
All |
getAll :: Bool |
Instances
Bounded All
Eq All
Monoid All
Ord All
Read All
Show All
newtype Any | Source
Boolean monoid under disjunction.
Constructors
Any |
getAny :: Bool |
Instances
Bounded Any
Eq Any
Monoid Any
Ord Any
Read Any
Show Any
Num wrappers
newtype Sum a | Source
Monoid under addition.
Constructors
Sum |
getSum :: a |
Instances
Bounded a => Bounded (Sum a)
Eq a => Eq (Sum a)
Num a => Monoid (Sum a)
Ord a => Ord (Sum a)
Read a => Read (Sum a)
Show a => Show (Sum a)
newtype Product a | Source
Monoid under multiplication.
Constructors
Product |
getProduct :: a |
Instances
Bounded a => Bounded (Product a)
Eq a => Eq (Product a)
Num a => Monoid (Product a)
Ord a => Ord (Product a)
Read a => Read (Product a)
Show a => Show (Product a)
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))
newtype First a | Source
Maybe monoid returning the leftmost non-Nothing value.
Constructors
First |
getFirst :: (Maybe a) |
Instances
Eq a => Eq (First a)
Monoid (First a)
Ord a => Ord (First a)
Read a => Read (First a)
Show a => Show (First a)
newtype Last a | Source
Maybe monoid returning the rightmost non-Nothing value.
Constructors
Last |
getLast :: (Maybe a) |
Instances
Eq a => Eq (Last a)
Monoid (Last a)
Ord a => Ord (Last a)
Read a => Read (Last a)
Show a => Show (Last a)
Produced by Haddock version 0.9