diff --git a/EdisonCore.cabal b/EdisonCore.cabal
--- a/EdisonCore.cabal
+++ b/EdisonCore.cabal
@@ -1,7 +1,7 @@
 Name:           EdisonCore
-Cabal-Version:  >= 1.2
+Cabal-Version:  >= 1.2.3
 Build-Type:     Simple
-Version:        1.2.1.3
+Version:        1.2.2
 License:        OtherLicense
 License-File:   COPYRIGHT
 Author:         Chris Okasaki
@@ -47,9 +47,10 @@
      Data.Edison.Seq.SimpleQueue
      Data.Edison.Seq.SizedSeq
   Build-Depends:
-     base, mtl,
-     QuickCheck >= 1.0 && < 2,
-     EdisonAPI == 1.2.1
+     base < 5,
+     mtl,
+     QuickCheck >= 2.0 && < 3,
+     EdisonAPI == 1.2.2
   if impl( ghc >= 6.8 )
      Build-Depends:
         containers, array
@@ -57,5 +58,10 @@
      MultiParamTypeClasses
      FunctionalDependencies
      UndecidableInstances
+     FlexibleInstances
      CPP
-  Ghc-Options: -funbox-strict-fields -fwarn-incomplete-patterns -O2 -fglasgow-exts
+     MagicHash
+     ScopedTypeVariables
+     GeneralizedNewtypeDeriving
+     FlexibleContexts
+  Ghc-Options: -funbox-strict-fields -fwarn-incomplete-patterns
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
@@ -62,7 +62,7 @@
 import qualified Data.Edison.Seq as S
 import qualified Data.Edison.Seq.BinaryRandList as RL
 import Data.Edison.Assoc.Defaults
-import Test.QuickCheck (Arbitrary(..), variant)
+import Test.QuickCheck (Arbitrary(..), CoArbitrary(..), variant)
 
 -- signatures for exported functions
 moduleName    :: String
@@ -612,6 +612,7 @@
    arbitrary = do xs <- arbitrary
                   return (Prelude.foldr (uncurry insert) empty xs)
 
+instance (Eq k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
    coarbitrary E = variant 0
    coarbitrary (I k a m) = variant 1 . coarbitrary k
                          . coarbitrary a . coarbitrary m
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
@@ -63,7 +63,7 @@
 import Data.Edison.Assoc.Defaults
 import Data.Int
 import Data.Bits
-import Test.QuickCheck (Arbitrary(..), variant)
+import Test.QuickCheck (Arbitrary(..), CoArbitrary(..), variant)
 
 moduleName :: String
 moduleName = "Data.Edison.Assoc.PatriciaLoMap"
@@ -834,6 +834,7 @@
    arbitrary = do xs <- arbitrary
                   return (Prelude.foldr (uncurry insert) empty xs)
 
+instance (CoArbitrary a) => CoArbitrary (FM a) where
    coarbitrary E = variant 0
    coarbitrary (L i a) = variant 1 . coarbitrary i . coarbitrary a
    coarbitrary (B i j m n) = variant 2 . coarbitrary i . coarbitrary j
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
@@ -56,7 +56,7 @@
 import qualified Data.Edison.Seq.ListSeq as L
 import Data.Edison.Assoc.Defaults
 import Data.Int
-import Test.QuickCheck (Arbitrary(..))
+import Test.QuickCheck (Arbitrary(..), CoArbitrary(..))
 
 import qualified Data.Map as DM
 
@@ -364,4 +364,5 @@
    arbitrary = do xs <- arbitrary
                   return (Prelude.foldr (uncurry insert) empty xs)
 
+instance (Ord k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
    coarbitrary mp = coarbitrary (A.toList mp)
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
@@ -62,7 +62,7 @@
 import Data.Maybe (isNothing)
 
 import Data.Edison.Assoc.Defaults
-import Test.QuickCheck (Arbitrary(..), Gen(), variant)
+import Test.QuickCheck (Arbitrary(..), CoArbitrary(..), Gen(), variant)
 
 
 -- signatures for exported functions
@@ -1142,15 +1142,17 @@
 instance (Ord k,Arbitrary k,Arbitrary a) => Arbitrary (FM k a) where
   arbitrary = do xs <- arbitrary
                  return (Prelude.foldr (uncurry insert) empty xs)
+
+instance (Ord k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
   coarbitrary (FM x fmb) = coarbitrary_maybe x . coarbitrary_fmb fmb
 
 
-coarbitrary_maybe :: (Arbitrary t) => Maybe t    -> Test.QuickCheck.Gen b
+coarbitrary_maybe :: (CoArbitrary t) => Maybe t  -> Test.QuickCheck.Gen b
                                                  -> Test.QuickCheck.Gen b
 coarbitrary_maybe Nothing = variant 0
 coarbitrary_maybe (Just x) = variant 1 . coarbitrary x
 
-coarbitrary_fmb :: (Arbitrary t1, Arbitrary t) => FMB t t1 -> Gen a -> Gen a
+coarbitrary_fmb :: (CoArbitrary t1, CoArbitrary t) => FMB t t1 -> Gen a -> Gen a
 coarbitrary_fmb E = variant 0
 coarbitrary_fmb (I _ k x l (FMB' m) r) =
         variant 1 . coarbitrary k . coarbitrary_maybe x .
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
@@ -165,7 +165,7 @@
 import qualified Data.Edison.Seq as S
 import qualified Data.Edison.Coll as C
 import Data.Edison.Coll.Defaults
-import Test.QuickCheck hiding (check)
+import Test.QuickCheck (Arbitrary(..), CoArbitrary(..))
 
 moduleName :: String
 moduleName = "Data.Edison.Coll.EnumSet"
@@ -786,6 +786,7 @@
   arbitrary = do (w::Int) <- arbitrary
                  return (Set (fromIntegral w))
 
+instance (Eq a, Enum a, CoArbitrary a) => CoArbitrary (Set a) where
   coarbitrary (Set w) = coarbitrary (fromIntegral w :: Int)
 
 instance (Eq a, Enum a) => Monoid (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
@@ -550,6 +550,7 @@
           siftInto x (H2 _ a b) = sift x a b
           siftInto _ E = error "LazyPairingHeap.arbitrary: bug!"
 
+instance (Ord a, CoArbitrary a) => CoArbitrary (Heap a) where
   coarbitrary E = variant 0
   coarbitrary (H1 x a) = variant 1 . coarbitrary x . coarbitrary a
   coarbitrary (H2 x a b) =
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
@@ -477,6 +477,7 @@
                 L r y a (sift (L r' x b c))
           sift _ = error "LeftistHeap.arbitrary: bug!"
 
+instance (Ord a, CoArbitrary a) => CoArbitrary (Heap a) where
   coarbitrary E = variant 0
   coarbitrary (L _ x a b) =
       variant 1 . coarbitrary x . coarbitrary a . coarbitrary b
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
@@ -393,6 +393,7 @@
                          else if odd i then M (C.minElem xs) xs
                                        else fromPrim xs)
 
+instance (C.OrdColl h a,CoArbitrary h,CoArbitrary a) => CoArbitrary (Min h a) where
   coarbitrary E = variant 0
   coarbitrary (M x xs) = variant 1 . coarbitrary x . coarbitrary xs
 
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
@@ -444,6 +444,7 @@
             | z < x           = T z s (sift x c d)
           sift x a b = T x a b
 
+instance (Ord a, CoArbitrary a) => CoArbitrary (Heap a) where
   coarbitrary E = variant 0
   coarbitrary (T x a b) =
       variant 1 . coarbitrary x . coarbitrary a . coarbitrary b
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
@@ -480,6 +480,7 @@
   arbitrary = do xs <- arbitrary
                  return (C.fromList xs)
 
+instance (Ord a,CoArbitrary a) => CoArbitrary (Heap a) where
   coarbitrary E = variant 0
   coarbitrary (T a x b) =
     variant 1 . coarbitrary a . coarbitrary x . coarbitrary b
diff --git a/src/Data/Edison/Coll/StandardSet.hs b/src/Data/Edison/Coll/StandardSet.hs
--- a/src/Data/Edison/Coll/StandardSet.hs
+++ b/src/Data/Edison/Coll/StandardSet.hs
@@ -268,4 +268,5 @@
   arbitrary = do xs <- arbitrary
                  return (Prelude.foldr insert empty xs)
 
+instance (Ord a, CoArbitrary a) => CoArbitrary (Set a) where
   coarbitrary set = coarbitrary (C.toList set)
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
@@ -424,6 +424,7 @@
   arbitrary = do xs <- arbitrary
                  return (Prelude.foldr insert empty xs)
 
+instance (Ord a, CoArbitrary a) => CoArbitrary (Set a) where
   coarbitrary E = variant 0
   coarbitrary (T a x b) =
     variant 1 . coarbitrary a . coarbitrary x . coarbitrary b
diff --git a/src/Data/Edison/Concrete/FingerTree.hs b/src/Data/Edison/Concrete/FingerTree.hs
--- a/src/Data/Edison/Concrete/FingerTree.hs
+++ b/src/Data/Edison/Concrete/FingerTree.hs
@@ -80,7 +80,9 @@
 
 import Data.Edison.Prelude
 
+import Control.Monad (liftM2, liftM3, liftM4)
 
+
 infixr 5 `lcons`
 infixl 5 `rcons0`
 
@@ -727,8 +729,15 @@
 reverseDigit f (Three a b c) = Three (f c) (f b) (f a)
 reverseDigit f (Four a b c d) = Four (f d) (f c) (f b) (f a)
 
+two :: Monad m => m a -> m (a, a)
+two m = liftM2 (,) m m
 
+three :: Monad m => m a -> m (a, a, a)
+three m = liftM3 (,,) m m m
 
+four :: Monad m => m a -> m (a, a, a, a)
+four m = liftM4 (,,,) m m m m
+
 instance (Arbitrary a) => Arbitrary (Digit a) where
   arbitrary = oneof
               [ arbitrary       >>= \x         -> return (One x)
@@ -737,6 +746,8 @@
               , four arbitrary  >>= \(x,y,z,w) -> return (Four x y z w)
               ]
 
+
+instance (CoArbitrary a) => CoArbitrary (Digit a) where
   coarbitrary p = case p of
       One x        -> variant 0 . coarbitrary x
       Two x y      -> variant 1 . coarbitrary x . coarbitrary y
@@ -752,6 +763,7 @@
               , three arbitrary >>= \(x,y,z)   -> return (node3 x y z)
               ]
 
+instance (Measured v a, CoArbitrary a) => CoArbitrary (Node v a) where
   coarbitrary p = case p of
        Node2 _ x y   -> variant 0 . coarbitrary x . coarbitrary y
        Node3 _ x y z -> variant 1 . coarbitrary x . coarbitrary y . coarbitrary z
@@ -768,6 +780,7 @@
                    return (deep pf m sf)
                ]
 
+instance (Measured v a, CoArbitrary a) => CoArbitrary (FingerTree v a) where
   coarbitrary p = case p of
          Empty          -> variant 0
          Single x       -> variant 1 . coarbitrary x
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
@@ -414,6 +414,7 @@
                    j = L.size ys
                in if i >= j then Q i xs ys j else Q j ys xs i)
 
+instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary (Q _ xs ys _) = coarbitrary xs . coarbitrary ys
 
 instance Monoid (Seq a) where
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
@@ -441,9 +441,11 @@
   arbitrary = do xs <- arbitrary
                  return (fromList xs)
 
+instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary E = variant 0
   coarbitrary (Even ps) = variant 1 . coarbitrary ps
   coarbitrary (Odd x ps) = variant 2 . coarbitrary x . coarbitrary ps
+
 
 instance Monoid (Seq a) where
   mempty  = empty
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
@@ -543,6 +543,8 @@
 
 instance Arbitrary a => Arbitrary (Seq a) where
   arbitrary = arbitrary >>= (return . fromList)
+
+instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary xs = coarbitrary (toList xs)
 
 instance Monoid (Seq a) where
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
@@ -370,10 +370,14 @@
 
 instance Arbitrary a => Arbitrary (Elem a) where
    arbitrary   = arbitrary >>= return . Elem
+
+instance CoArbitrary a => CoArbitrary (Elem a) where
    coarbitrary = coarbitrary . unElem
 
 instance Arbitrary a => Arbitrary (Seq a) where
    arbitrary   = arbitrary >>= return . Seq
+
+instance CoArbitrary a => CoArbitrary (Seq a) where
    coarbitrary = coarbitrary . unSeq
 
 instance Monoid (Seq a) where
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
@@ -416,6 +416,7 @@
                        (4, liftM2 A (arbTree (n `div` 2))
                                     (arbTree (n `div` 2)))]
 
+instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary E = variant 0
   coarbitrary (L x) = variant 1 . coarbitrary x
   coarbitrary (A xs ys) = variant 2 . coarbitrary xs . coarbitrary ys
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
@@ -414,6 +414,7 @@
   arbitrary = do xs <- arbitrary
                  return (fromList xs)
 
+instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary xs = coarbitrary (toList xs)
 
 instance Monoid (Seq a) where
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
@@ -474,6 +474,7 @@
   arbitrary = do xs <- arbitrary
                  return (fromList xs)
 
+instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary xs = coarbitrary (toList xs)
 
 instance Monoid (Seq a) where
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
@@ -374,6 +374,7 @@
   arbitrary = do xs <- arbitrary
                  return (fromSeq xs)
 
+instance (S.Sequence s, CoArbitrary (s a)) => CoArbitrary (Rev s a) where
   coarbitrary xs = coarbitrary (toSeq xs)
 
 instance S.Sequence s => Monoid (Rev s a) where
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
@@ -366,6 +366,7 @@
                  ys <- arbitrary
                  return (if L.null xs then Q ys [] else Q xs ys)
 
+instance CoArbitrary a => CoArbitrary (Seq a) where
   coarbitrary (Q xs ys) = coarbitrary xs . coarbitrary ys
 
 instance Monoid (Seq a) where
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
@@ -347,6 +347,7 @@
   arbitrary = do xs <- arbitrary
                  return (fromSeq xs)
 
+instance (S.Sequence s, CoArbitrary (s a)) => CoArbitrary (Sized s a) where
   coarbitrary xs = coarbitrary (toSeq xs)
 
 instance S.Sequence s => Monoid (Sized s a) where