module Data.Monoid (
Monoid(..),
- Endo(..),
Dual(..),
+ Endo(..),
+ All(..),
+ Any(..),
Sum(..),
Product(..)
) where
import Prelude
-import Data.Map ( Map )
-import qualified Data.Map as Map hiding ( Map )
-import Data.IntMap ( IntMap )
-import qualified Data.IntMap as IntMap hiding ( IntMap )
-import Data.Set ( Set )
-import qualified Data.Set as Set hiding ( Set )
-import Data.IntSet ( IntSet )
-import qualified Data.IntSet as IntSet hiding ( IntSet )
-- ---------------------------------------------------------------------------
-- | The monoid class.
EQ `mappend` y = y
GT `mappend` _ = GT
+-- | The dual of a monoid, obtained by swapping the arguments of 'mappend'.
+newtype Dual a = Dual { getDual :: a }
+
+instance Monoid a => Monoid (Dual a) where
+ mempty = Dual mempty
+ Dual x `mappend` Dual y = Dual (y `mappend` x)
+
-- | The monoid of endomorphisms under composition.
newtype Endo a = Endo { appEndo :: a -> a }
mempty = Endo id
Endo f `mappend` Endo g = Endo (f . g)
--- | The dual of a monoid, obtained by swapping the arguments of 'mappend'.
-newtype Dual a = Dual { getDual :: a }
+-- | Boolean monoid under conjunction.
+newtype All = All { getAll :: Bool }
+ deriving (Eq, Ord, Read, Show, Bounded)
-instance Monoid a => Monoid (Dual a) where
- mempty = Dual mempty
- Dual x `mappend` Dual y = Dual (y `mappend` x)
+instance Monoid All where
+ mempty = All True
+ All x `mappend` All y = All (x && y)
+
+-- | Boolean monoid under disjunction.
+newtype Any = Any { getAny :: Bool }
+ deriving (Eq, Ord, Read, Show, Bounded)
+
+instance Monoid Any where
+ mempty = Any False
+ Any x `mappend` Any y = Any (x || y)
-- | Monoid under addition.
newtype Sum a = Sum { getSum :: a }
+ deriving (Eq, Ord, Read, Show, Bounded)
instance Num a => Monoid (Sum a) where
mempty = Sum 0
-- | Monoid under multiplication.
newtype Product a = Product { getProduct :: a }
+ deriving (Eq, Ord, Read, Show, Bounded)
instance Num a => Monoid (Product a) where
mempty = Product 1
Product x `mappend` Product y = Product (x * y)
-
-instance (Ord k) => Monoid (Map k v) where
- mempty = Map.empty
- mappend = Map.union
- mconcat = Map.unions
-
-instance Ord a => Monoid (IntMap a) where
- mempty = IntMap.empty
- mappend = IntMap.union
- mconcat = IntMap.unions
-
-instance Ord a => Monoid (Set a) where
- mempty = Set.empty
- mappend = Set.union
- mconcat = Set.unions
-
-instance Monoid IntSet where
- mempty = IntSet.empty
- mappend = IntSet.union
- mconcat = IntSet.unions