diff --git a/EdisonCore.cabal b/EdisonCore.cabal
--- a/EdisonCore.cabal
+++ b/EdisonCore.cabal
@@ -1,12 +1,12 @@
 Name:           EdisonCore
 Cabal-Version:  >= 1.10
 Build-Type:     Simple
-Version:        1.3.1.1
-License:        OtherLicense
+Version:        1.3.2
+License:        MIT
 License-File:   COPYRIGHT
 Author:         Chris Okasaki
 Maintainer:     robdockins AT fastmail DOT fm
-Synopsis:       A library of efficent, purely-functional data structures (Core Implementations)
+Synopsis:       A library of efficient, purely-functional data structures (Core Implementations)
 Category:       Data Structures
 Homepage:	http://rwd.rdockins.name/edison/home/
 Stability:      Stable
@@ -69,4 +69,4 @@
      ScopedTypeVariables
      GeneralizedNewtypeDeriving
      FlexibleContexts
-  Ghc-Options: -funbox-strict-fields -fwarn-incomplete-patterns
+  Ghc-Options: -funbox-strict-fields -fwarn-incomplete-patterns -Wcompat
diff --git a/src/Data/Edison/Assoc/AssocList.hs b/src/Data/Edison/Assoc/AssocList.hs
--- a/src/Data/Edison/Assoc/AssocList.hs
+++ b/src/Data/Edison/Assoc/AssocList.hs
@@ -57,6 +57,7 @@
 import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
 import qualified Prelude
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad.Identity
 import qualified Data.Edison.Assoc as A
 import qualified Data.Edison.Seq as S
@@ -618,7 +619,9 @@
                          . coarbitrary a . coarbitrary m
 
 
+instance Eq k => Semigroup (FM k a) where
+   (<>) = union
 instance Eq k => Monoid (FM k a) where
    mempty  = empty
-   mappend = union
+   mappend = (SG.<>)
    mconcat = unionSeq
diff --git a/src/Data/Edison/Assoc/PatriciaLoMap.hs b/src/Data/Edison/Assoc/PatriciaLoMap.hs
--- a/src/Data/Edison/Assoc/PatriciaLoMap.hs
+++ b/src/Data/Edison/Assoc/PatriciaLoMap.hs
@@ -57,6 +57,7 @@
 import qualified Prelude
 import Control.Monad.Identity (runIdentity)
 import Data.Monoid
+import Data.Semigroup as SG
 import qualified Data.Edison.Assoc as A
 import qualified Data.Edison.Seq as S
 import qualified Data.Edison.Seq.ListSeq as L
@@ -841,7 +842,9 @@
                            . coarbitrary m . coarbitrary n
 
 
+instance Semigroup (FM a) where
+   (<>) = union
 instance Monoid (FM a) where
    mempty  = empty
-   mappend = union
+   mappend = (SG.<>)
    mconcat = unionSeq
diff --git a/src/Data/Edison/Assoc/StandardMap.hs b/src/Data/Edison/Assoc/StandardMap.hs
--- a/src/Data/Edison/Assoc/StandardMap.hs
+++ b/src/Data/Edison/Assoc/StandardMap.hs
@@ -94,7 +94,7 @@
 adjustOrDeleteAll :: Ord k => (a -> Maybe a) -> k -> FM k a -> FM k a
 strict            :: Ord k => FM k a -> FM k a
 strictWith        :: Ord k => (a -> b) -> FM k a -> FM k a
-map               :: (Ord k,Functor (FM k)) => (a -> b) -> FM k a -> FM k b
+map               :: Ord k => (a -> b) -> FM k a -> FM k b
 fold              :: Ord k => (a -> b -> b) -> b -> FM k a -> b
 fold1             :: Ord k => (a -> a -> a) -> FM k a -> a
 fold'             :: Ord k => (a -> b -> b) -> b -> FM k a -> b
@@ -211,10 +211,10 @@
 adjustAllOrInsert  = adjustOrInsertUsingMember
 adjustOrDelete     = DM.update
 adjustOrDeleteAll  = DM.update
-strict xs          = DM.fold (flip const) () xs `seq` xs
-strictWith f xs    = DM.fold (\x z -> f x `seq` z) () xs `seq` xs
+strict xs          = DM.foldr (flip const) () xs `seq` xs
+strictWith f xs    = DM.foldr (\x z -> f x `seq` z) () xs `seq` xs
 map                = fmap
-fold               = DM.fold
+fold               = DM.foldr
 fold' f x xs       = L.foldl' (flip f) x (DM.elems xs)
 fold1  f xs        = L.foldr1 f (DM.elems xs)
 fold1' f xs        = L.foldl1' (flip f) (DM.elems xs)
@@ -277,7 +277,7 @@
 toSeq              = toSeqUsingFoldWithKey
 keys               = keysUsingFoldWithKey
 mapWithKey         = DM.mapWithKey
-foldWithKey        = DM.foldWithKey
+foldWithKey        = DM.foldrWithKey
 foldWithKey' f x m = L.foldl' (\b (k,a) -> f k a b) x (DM.toList m)
 filterWithKey      = DM.filterWithKey
 partitionWithKey   = DM.partitionWithKey
@@ -290,7 +290,7 @@
                         then fail (moduleName ++ ".maxViewWithKey: failed")
                         else return (DM.deleteFindMax m)
 maxElemWithKey     = DM.findMax
-foldrWithKey        = DM.foldWithKey
+foldrWithKey        = DM.foldrWithKey
 foldrWithKey' f x m = L.foldr' (\(k,a) b -> f k a b) x (DM.toAscList m)
 foldlWithKey  f x m = L.foldl  (\b (k,a) -> f b k a) x (DM.toAscList m)
 foldlWithKey' f x m = L.foldl' (\b (k,a) -> f b k a) x (DM.toAscList m)
diff --git a/src/Data/Edison/Assoc/TernaryTrie.hs b/src/Data/Edison/Assoc/TernaryTrie.hs
--- a/src/Data/Edison/Assoc/TernaryTrie.hs
+++ b/src/Data/Edison/Assoc/TernaryTrie.hs
@@ -59,6 +59,7 @@
 import qualified Data.List as L
 import Control.Monad.Identity
 import Data.Monoid
+import Data.Semigroup as SG
 import Data.Maybe (isNothing)
 
 import Data.Edison.Assoc.Defaults
@@ -1158,8 +1159,10 @@
         variant 1 . coarbitrary k . coarbitrary_maybe x .
         coarbitrary_fmb l . coarbitrary_fmb m . coarbitrary_fmb r
 
+instance Ord k => Semigroup (FM k a) where
+   (<>) = union
 instance Ord k => Monoid (FM k a) where
    mempty  = empty
-   mappend = union
+   mappend = (SG.<>)
    mconcat = unionSeq
 
diff --git a/src/Data/Edison/Coll/EnumSet.hs b/src/Data/Edison/Coll/EnumSet.hs
--- a/src/Data/Edison/Coll/EnumSet.hs
+++ b/src/Data/Edison/Coll/EnumSet.hs
@@ -161,6 +161,7 @@
 import Data.Bits hiding (complement)
 import Data.Word
 import Data.Monoid (Monoid(..))
+import Data.Semigroup as SG
 
 import qualified Data.Edison.Seq as S
 import qualified Data.Edison.Coll as C
@@ -795,9 +796,11 @@
 instance (Eq a, Enum a, CoArbitrary a) => CoArbitrary (Set a) where
   coarbitrary (Set w) = coarbitrary (fromIntegral w :: Int)
 
+instance (Eq a, Enum a) => Semigroup (Set a) where
+    (<>) = union
 instance (Eq a, Enum a) => Monoid (Set a) where
     mempty  = empty
-    mappend = union
+    mappend = (SG.<>)
     mconcat = unionSeq
 
 instance (Ord a, Enum a) => Ord (Set a) where
diff --git a/src/Data/Edison/Coll/LazyPairingHeap.hs b/src/Data/Edison/Coll/LazyPairingHeap.hs
--- a/src/Data/Edison/Coll/LazyPairingHeap.hs
+++ b/src/Data/Edison/Coll/LazyPairingHeap.hs
@@ -47,6 +47,7 @@
 import Data.Edison.Coll.Defaults
 import Data.List (sort)
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad
 import Test.QuickCheck
 
@@ -556,9 +557,12 @@
   coarbitrary (H2 x a b) =
       variant 2 . coarbitrary x . coarbitrary a . coarbitrary b
 
+instance (Ord a) => Semigroup (Heap a) where
+    (<>) = union
+
 instance (Ord a) => Monoid (Heap a) where
     mempty  = empty
-    mappend = union
+    mappend = (SG.<>)
     mconcat = unionSeq
 
 instance (Ord a) => Ord (Heap a) where
diff --git a/src/Data/Edison/Coll/LeftistHeap.hs b/src/Data/Edison/Coll/LeftistHeap.hs
--- a/src/Data/Edison/Coll/LeftistHeap.hs
+++ b/src/Data/Edison/Coll/LeftistHeap.hs
@@ -45,6 +45,7 @@
 import qualified Data.Edison.Seq as S
 import Data.Edison.Coll.Defaults
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad
 import Test.QuickCheck
 
@@ -482,9 +483,12 @@
   coarbitrary (L _ x a b) =
       variant 1 . coarbitrary x . coarbitrary a . coarbitrary b
 
+instance (Ord a) => Semigroup (Heap a) where
+    (<>) = union
+
 instance (Ord a) => Monoid (Heap a) where
     mempty  = empty
-    mappend = union
+    mappend = (SG.<>)
     mconcat = unionSeq
 
 instance (Ord a) => Ord (Heap a) where
diff --git a/src/Data/Edison/Coll/MinHeap.hs b/src/Data/Edison/Coll/MinHeap.hs
--- a/src/Data/Edison/Coll/MinHeap.hs
+++ b/src/Data/Edison/Coll/MinHeap.hs
@@ -44,6 +44,7 @@
 import Data.Edison.Coll.Defaults
 import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)
 import Data.Monoid
+import qualified Data.Semigroup as SG
 import Control.Monad
 import Test.QuickCheck
 
@@ -397,9 +398,11 @@
   coarbitrary E = variant 0
   coarbitrary (M x xs) = variant 1 . coarbitrary x . coarbitrary xs
 
+instance (C.OrdColl h a) => SG.Semigroup (Min h a) where
+    (<>) = union
 instance (C.OrdColl h a) => Monoid (Min h a) where
     mempty  = empty
-    mappend = union
+    mappend = (SG.<>)
     mconcat = unionSeq
 
 instance (Eq h, C.OrdColl h a) => Ord (Min h a) where
diff --git a/src/Data/Edison/Coll/SkewHeap.hs b/src/Data/Edison/Coll/SkewHeap.hs
--- a/src/Data/Edison/Coll/SkewHeap.hs
+++ b/src/Data/Edison/Coll/SkewHeap.hs
@@ -45,7 +45,9 @@
 import qualified Data.Edison.Seq as S
 import Data.Edison.Coll.Defaults
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad
+
 import Test.QuickCheck
 
 moduleName :: String
@@ -449,9 +451,12 @@
   coarbitrary (T x a b) =
       variant 1 . coarbitrary x . coarbitrary a . coarbitrary b
 
+instance (Ord a) => Semigroup (Heap a) where
+    (<>) = union
+
 instance (Ord a) => Monoid (Heap a) where
     mempty  = empty
-    mappend = union
+    mappend = (SG.<>)
     mconcat = unionSeq
 
 instance (Ord a) => Ord (Heap a) where
diff --git a/src/Data/Edison/Coll/SplayHeap.hs b/src/Data/Edison/Coll/SplayHeap.hs
--- a/src/Data/Edison/Coll/SplayHeap.hs
+++ b/src/Data/Edison/Coll/SplayHeap.hs
@@ -48,6 +48,7 @@
 import qualified Data.Edison.Seq as S
 import Data.Edison.Coll.Defaults
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad
 import Test.QuickCheck
 
@@ -485,9 +486,11 @@
   coarbitrary (T a x b) =
     variant 1 . coarbitrary a . coarbitrary x . coarbitrary b
 
+instance (Ord a) => Semigroup (Heap a) where
+    (<>) = union
 instance (Ord a) => Monoid (Heap a) where
     mempty  = empty
-    mappend = union
+    mappend = (SG.<>)
     mconcat = unionSeq
 
 instance (Ord a) => Ord (Heap a) where
diff --git a/src/Data/Edison/Coll/UnbalancedSet.hs b/src/Data/Edison/Coll/UnbalancedSet.hs
--- a/src/Data/Edison/Coll/UnbalancedSet.hs
+++ b/src/Data/Edison/Coll/UnbalancedSet.hs
@@ -47,6 +47,7 @@
 import qualified Data.Edison.Seq as S
 import Data.Edison.Coll.Defaults
 import Data.Monoid
+import Data.Semigroup as SG
 import Test.QuickCheck
 
 -- signatures for exported functions
@@ -429,9 +430,12 @@
   coarbitrary (T a x b) =
     variant 1 . coarbitrary a . coarbitrary x . coarbitrary b
 
+instance (Ord a) => Semigroup (Set a) where
+  (<>) = union
+
 instance (Ord a) => Monoid (Set a) where
     mempty  = empty
-    mappend = union
+    mappend = (SG.<>)
     mconcat = unionSeq
 
 instance (Ord a) => Ord (Set a) where
diff --git a/src/Data/Edison/Seq/BankersQueue.hs b/src/Data/Edison/Seq/BankersQueue.hs
--- a/src/Data/Edison/Seq/BankersQueue.hs
+++ b/src/Data/Edison/Seq/BankersQueue.hs
@@ -55,6 +55,7 @@
 import Data.Edison.Seq.Defaults
 import qualified Data.Edison.Seq.ListSeq as L
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad.Identity
 import Test.QuickCheck
 
@@ -430,6 +431,8 @@
 instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary (Q _ xs ys _) = coarbitrary xs . coarbitrary ys
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/BinaryRandList.hs b/src/Data/Edison/Seq/BinaryRandList.hs
--- a/src/Data/Edison/Seq/BinaryRandList.hs
+++ b/src/Data/Edison/Seq/BinaryRandList.hs
@@ -61,6 +61,7 @@
 import qualified Data.Edison.Seq as S ( Sequence(..) )
 import Data.Edison.Seq.Defaults
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad
 import Test.QuickCheck
 
@@ -459,6 +460,8 @@
   coarbitrary (Odd x ps) = variant 2 . coarbitrary x . coarbitrary ps
 
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/BraunSeq.hs b/src/Data/Edison/Seq/BraunSeq.hs
--- a/src/Data/Edison/Seq/BraunSeq.hs
+++ b/src/Data/Edison/Seq/BraunSeq.hs
@@ -75,6 +75,7 @@
 import Control.Monad.Identity
 import Data.Maybe
 import Data.Monoid
+import Data.Semigroup as SG
 import Test.QuickCheck
 
 
@@ -560,6 +561,8 @@
 instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary xs = coarbitrary (toList xs)
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/FingerSeq.hs b/src/Data/Edison/Seq/FingerSeq.hs
--- a/src/Data/Edison/Seq/FingerSeq.hs
+++ b/src/Data/Edison/Seq/FingerSeq.hs
@@ -42,6 +42,7 @@
 import Data.Edison.Seq.Defaults
 import Control.Monad.Identity
 import Data.Monoid
+import Data.Semigroup as SG
 import Test.QuickCheck
 
 #ifdef __GLASGOW_HASKELL__
@@ -60,10 +61,11 @@
 unSizeM :: SizeM -> Int
 unSizeM (SizeM x) = x
 
+instance Semigroup SizeM where
+   (<>) = (+)
 instance Monoid SizeM where
    mempty  = 0
-   mappend = (+)
-
+   mappend = (SG.<>)
 
 newtype Elem a = Elem a
 
@@ -392,6 +394,8 @@
 instance CoArbitrary a => CoArbitrary (Seq a) where
    coarbitrary = coarbitrary . unSeq
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/JoinList.hs b/src/Data/Edison/Seq/JoinList.hs
--- a/src/Data/Edison/Seq/JoinList.hs
+++ b/src/Data/Edison/Seq/JoinList.hs
@@ -58,6 +58,7 @@
 import Data.Edison.Seq.Defaults
 import Control.Monad
 import Data.Monoid
+import Data.Semigroup as SG
 import Test.QuickCheck
 
 -- signatures for exported functions
@@ -434,6 +435,8 @@
   coarbitrary (L x) = variant 1 . coarbitrary x
   coarbitrary (A xs ys) = variant 2 . coarbitrary xs . coarbitrary ys
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/MyersStack.hs b/src/Data/Edison/Seq/MyersStack.hs
--- a/src/Data/Edison/Seq/MyersStack.hs
+++ b/src/Data/Edison/Seq/MyersStack.hs
@@ -53,6 +53,7 @@
 import Data.Edison.Seq.Defaults
 import Control.Monad.Identity
 import Data.Monoid
+import Data.Semigroup as SG
 import Test.QuickCheck
 
 -- signatures for exported functions
@@ -429,10 +430,11 @@
 instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary xs = coarbitrary (toList xs)
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
-
+  mappend = (SG.<>)
 
 -------------
 
diff --git a/src/Data/Edison/Seq/RandList.hs b/src/Data/Edison/Seq/RandList.hs
--- a/src/Data/Edison/Seq/RandList.hs
+++ b/src/Data/Edison/Seq/RandList.hs
@@ -59,6 +59,7 @@
 import Data.Edison.Seq.Defaults
 import Control.Monad.Identity
 import Data.Monoid
+import Data.Semigroup as SG
 import Test.QuickCheck
 
 -- signatures for exported functions
@@ -490,6 +491,8 @@
 instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary xs = coarbitrary (toList xs)
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/RevSeq.hs b/src/Data/Edison/Seq/RevSeq.hs
--- a/src/Data/Edison/Seq/RevSeq.hs
+++ b/src/Data/Edison/Seq/RevSeq.hs
@@ -63,6 +63,7 @@
 import Data.Edison.Seq.Defaults -- only used by concatMap
 import Control.Monad
 import Data.Monoid
+import Data.Semigroup as SG
 import Test.QuickCheck
 
 
@@ -390,6 +391,8 @@
 instance (S.Sequence s, CoArbitrary (s a)) => CoArbitrary (Rev s a) where
   coarbitrary xs = coarbitrary (toSeq xs)
 
+instance S.Sequence s => Semigroup (Rev s a) where
+  (<>) = append
 instance S.Sequence s => Monoid (Rev s a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/SimpleQueue.hs b/src/Data/Edison/Seq/SimpleQueue.hs
--- a/src/Data/Edison/Seq/SimpleQueue.hs
+++ b/src/Data/Edison/Seq/SimpleQueue.hs
@@ -57,6 +57,7 @@
 import Data.Edison.Seq.Defaults
 import qualified Data.Edison.Seq.ListSeq as L
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad
 import Test.QuickCheck
 
@@ -382,6 +383,8 @@
 instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary (Q xs ys) = coarbitrary xs . coarbitrary ys
 
+instance Semigroup (Seq a) where
+  (<>) = append
 instance Monoid (Seq a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)
diff --git a/src/Data/Edison/Seq/SizedSeq.hs b/src/Data/Edison/Seq/SizedSeq.hs
--- a/src/Data/Edison/Seq/SizedSeq.hs
+++ b/src/Data/Edison/Seq/SizedSeq.hs
@@ -52,6 +52,7 @@
 import qualified Data.Edison.Seq.ListSeq as L
 import Data.Edison.Seq.Defaults -- only used by concatMap
 import Data.Monoid
+import Data.Semigroup as SG
 import Control.Monad
 import Test.QuickCheck
 
@@ -363,6 +364,9 @@
 instance (S.Sequence s, CoArbitrary (s a)) => CoArbitrary (Sized s a) where
   coarbitrary xs = coarbitrary (toSeq xs)
 
+
+instance S.Sequence s => Semigroup (Sized s a) where
+  (<>) = append
 instance S.Sequence s => Monoid (Sized s a) where
   mempty  = empty
-  mappend = append
+  mappend = (SG.<>)