[project @ 2005-02-26 12:14:54 by panne]

Moved Monoid instances of collection types to Data.Monoid, concentrating non-H98
stuff to a single place.

diff --git a/Data/IntMap.hs b/Data/IntMap.hs
index 25b1558..fd648cb 100644 (file)
--- a/Data/IntMap.hs
+++ b/Data/IntMap.hs
@@ -135,7 +135,6 @@ module Data.IntMap  (
 import Prelude hiding (lookup,map,filter,foldr,foldl,null)
 import Data.Bits 
 import Data.Int
-import Data.Monoid
 import qualified Data.IntSet as IntSet
 import Data.Typeable
 
@@ -971,15 +970,6 @@ instance Functor IntMap where
     fmap = map
 
 {--------------------------------------------------------------------
-  Monoid 
---------------------------------------------------------------------}
-
-instance Ord a => Monoid (IntMap a) where
-    mempty = empty
-    mappend = union
-    mconcat = unions
-
-{--------------------------------------------------------------------
   Show 
 --------------------------------------------------------------------}
 

diff --git a/Data/IntSet.hs b/Data/IntSet.hs
index a3cb766..4dc1bf7 100644 (file)
--- a/Data/IntSet.hs
+++ b/Data/IntSet.hs
@@ -94,7 +94,6 @@ import Data.Bits
 import Data.Int
 
 import qualified Data.List as List
-import Data.Monoid
 import Data.Typeable
 
 {-
@@ -580,15 +579,6 @@ instance Ord IntSet where
     -- tentative implementation. See if more efficient exists.
 
 {--------------------------------------------------------------------
-  Monoid 
---------------------------------------------------------------------}
-
-instance Monoid IntSet where
-    mempty = empty
-    mappend = union
-    mconcat = unions
-
-{--------------------------------------------------------------------
   Show
 --------------------------------------------------------------------}
 instance Show IntSet where

diff --git a/Data/Map.hs b/Data/Map.hs
index 92cf158..dd12656 100644 (file)
--- a/Data/Map.hs
+++ b/Data/Map.hs
@@ -148,7 +148,6 @@ module Data.Map  (
             ) where
 
 import Prelude hiding (lookup,map,filter,foldr,foldl,null)
-import Data.Monoid
 import qualified Data.Set as Set
 import qualified Data.List as List
 import Data.Typeable
@@ -1298,15 +1297,6 @@ instance (Ord k, Ord v) => Ord (Map k v) where
     compare m1 m2 = compare (toList m1) (toList m2)
 
 {--------------------------------------------------------------------
-  Monoid 
---------------------------------------------------------------------}
-
-instance (Ord k) => Monoid (Map k v) where
-    mempty = empty
-    mappend = union
-    mconcat = unions
-
-{--------------------------------------------------------------------
   Functor
 --------------------------------------------------------------------}
 instance Functor (Map k) where

diff --git a/Data/Monoid.hs b/Data/Monoid.hs
index cfc8dd2..bc8633b 100644 (file)
--- a/Data/Monoid.hs
+++ b/Data/Monoid.hs
@@ -23,6 +23,14 @@ module Data.Monoid (
   ) 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.
@@ -88,3 +96,23 @@ instance Monoid Ordering where
        LT `mappend` _ = LT
        EQ `mappend` y = y
        GT `mappend` _ = GT
+
+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

diff --git a/Data/Set.hs b/Data/Set.hs
index 4b1e3a9..f321abf 100644 (file)
--- a/Data/Set.hs
+++ b/Data/Set.hs
@@ -112,7 +112,6 @@ module Data.Set  (
             ) where
 
 import Prelude hiding (filter,foldr,null,map)
-import Data.Monoid
 import qualified Data.List as List
 import Data.Typeable
 
@@ -506,15 +505,6 @@ instance Ord a => Ord (Set a) where
     compare s1 s2 = compare (toAscList s1) (toAscList s2) 
 
 {--------------------------------------------------------------------
-  Monoid 
---------------------------------------------------------------------}
-
-instance Ord a => Monoid (Set a) where
-    mempty = empty
-    mappend = union
-    mconcat = unions
-
-{--------------------------------------------------------------------
   Show
 --------------------------------------------------------------------}
 instance Show a => Show (Set a) where