Moved Monoid instances of collection types to Data.Monoid, concentrating non-H98
stuff to a single place.
import Prelude hiding (lookup,map,filter,foldr,foldl,null)
import Data.Bits
import Data.Int
import Prelude hiding (lookup,map,filter,foldr,foldl,null)
import Data.Bits
import Data.Int
import qualified Data.IntSet as IntSet
import Data.Typeable
import qualified Data.IntSet as IntSet
import Data.Typeable
fmap = map
{--------------------------------------------------------------------
fmap = map
{--------------------------------------------------------------------
- Monoid
---------------------------------------------------------------------}
-
-instance Ord a => Monoid (IntMap a) where
- mempty = empty
- mappend = union
- mconcat = unions
-
-{--------------------------------------------------------------------
Show
--------------------------------------------------------------------}
Show
--------------------------------------------------------------------}
import Data.Int
import qualified Data.List as List
import Data.Int
import qualified Data.List as List
-- tentative implementation. See if more efficient exists.
{--------------------------------------------------------------------
-- tentative implementation. See if more efficient exists.
{--------------------------------------------------------------------
- Monoid
---------------------------------------------------------------------}
-
-instance Monoid IntSet where
- mempty = empty
- mappend = union
- mconcat = unions
-
-{--------------------------------------------------------------------
Show
--------------------------------------------------------------------}
instance Show IntSet where
Show
--------------------------------------------------------------------}
instance Show IntSet where
) where
import Prelude hiding (lookup,map,filter,foldr,foldl,null)
) where
import Prelude hiding (lookup,map,filter,foldr,foldl,null)
import qualified Data.Set as Set
import qualified Data.List as List
import Data.Typeable
import qualified Data.Set as Set
import qualified Data.List as List
import Data.Typeable
compare m1 m2 = compare (toList m1) (toList m2)
{--------------------------------------------------------------------
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
Functor
--------------------------------------------------------------------}
instance Functor (Map k) where
+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.
-- ---------------------------------------------------------------------------
-- | The monoid class.
LT `mappend` _ = LT
EQ `mappend` y = y
GT `mappend` _ = GT
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
) where
import Prelude hiding (filter,foldr,null,map)
) where
import Prelude hiding (filter,foldr,null,map)
import qualified Data.List as List
import Data.Typeable
import qualified Data.List as List
import Data.Typeable
compare s1 s2 = compare (toAscList s1) (toAscList s2)
{--------------------------------------------------------------------
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
Show
--------------------------------------------------------------------}
instance Show a => Show (Set a) where