diff --git a/EdisonCore.cabal b/EdisonCore.cabal
--- a/EdisonCore.cabal
+++ b/EdisonCore.cabal
@@ -1,7 +1,7 @@
 Name:           EdisonCore
-Cabal-Version:  >= 1.2.3
+Cabal-Version:  >= 1.22
 Build-Type:     Simple
-Version:        1.2.2.1
+Version:        1.3
 License:        OtherLicense
 License-File:   COPYRIGHT
 Author:         Chris Okasaki
@@ -17,6 +17,11 @@
      implementations in this package have no dependencies other than those
      commonly bundled with Haskell compilers.
 
+Source-Repository head
+  Type: git
+  Location: https://github.com/robdockins/edison/
+  Subdir: edison-core
+
 Library
   Hs-Source-Dirs: src
   Exposed-modules:
@@ -47,14 +52,14 @@
      Data.Edison.Seq.SimpleQueue
      Data.Edison.Seq.SizedSeq
   Build-Depends:
-     base < 5,
+     base == 4.*,
      mtl,
      QuickCheck >= 2.0 && < 3,
-     EdisonAPI == 1.2.2.1
-  if impl( ghc >= 6.8 )
-     Build-Depends:
-        containers, array
-  Extensions:
+     EdisonAPI,
+     containers,
+     array
+  Default-Language: Haskell2010
+  Default-Extensions:
      MultiParamTypeClasses
      FunctionalDependencies
      UndecidableInstances
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
@@ -609,7 +609,7 @@
   readsPrec = readsPrecUsingFromList
 
 instance (Eq k,Arbitrary k,Arbitrary a) => Arbitrary (FM k a) where
-   arbitrary = do xs <- arbitrary
+   arbitrary = do (xs::[(k,a)]) <- arbitrary
                   return (Prelude.foldr (uncurry insert) empty xs)
 
 instance (Eq k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
diff --git a/src/Data/Edison/Assoc/Defaults.hs b/src/Data/Edison/Assoc/Defaults.hs
--- a/src/Data/Edison/Assoc/Defaults.hs
+++ b/src/Data/Edison/Assoc/Defaults.hs
@@ -42,9 +42,6 @@
         Just _  -> True
         Nothing -> False
 
-sizeUsingElements :: (AssocX m k) => m a -> Int
-sizeUsingElements m = length (elements m)
-
 countUsingMember :: AssocX m k => k -> m a -> Int
 countUsingMember k m = if member k m then 1 else 0
 
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
@@ -831,7 +831,7 @@
   compare = compareUsingToOrdList
 
 instance (Arbitrary a) => Arbitrary (FM a) where
-   arbitrary = do xs <- arbitrary
+   arbitrary = do (xs::[(Int,a)]) <- arbitrary
                   return (Prelude.foldr (uncurry insert) empty xs)
 
 instance (CoArbitrary a) => CoArbitrary (FM a) where
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
@@ -361,7 +361,7 @@
 instance Ord k => A.OrdFiniteMap (FM k) k
 
 instance (Ord k,Arbitrary k,Arbitrary a) => Arbitrary (FM k a) where
-   arbitrary = do xs <- arbitrary
+   arbitrary = do (xs::[(k,a)]) <- arbitrary
                   return (Prelude.foldr (uncurry insert) empty xs)
 
 instance (Ord k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
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
@@ -1140,7 +1140,7 @@
 
 
 instance (Ord k,Arbitrary k,Arbitrary a) => Arbitrary (FM k a) where
-  arbitrary = do xs <- arbitrary
+  arbitrary = do (xs::[([k],a)]) <- arbitrary
                  return (Prelude.foldr (uncurry insert) empty xs)
 
 instance (Ord k,CoArbitrary k,CoArbitrary a) => CoArbitrary (FM k a) where
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
@@ -179,7 +179,7 @@
 newtype Set a = Set Word deriving (Eq)
 
 wordLength :: Int
-wordLength = bitSize (0::Word)
+wordLength = finiteBitSize (0::Word)
 
 check :: String -> Int -> Int
 check msg x
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
@@ -263,9 +263,8 @@
 
 instance Ord a => C.OrdSet (Set a) a
 
-
 instance (Ord a, Arbitrary a) => Arbitrary (Set a) where
-  arbitrary = do xs <- arbitrary
+  arbitrary = do (xs::[a]) <- arbitrary
                  return (Prelude.foldr insert empty xs)
 
 instance (Ord a, CoArbitrary a) => CoArbitrary (Set 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
@@ -421,7 +421,7 @@
 
 
 instance (Ord a, Arbitrary a) => Arbitrary (Set a) where
-  arbitrary = do xs <- arbitrary
+  arbitrary = do (xs::[a]) <- arbitrary
                  return (Prelude.foldr insert empty xs)
 
 instance (Ord a, CoArbitrary a) => CoArbitrary (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
@@ -49,6 +49,8 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
+
 import qualified Data.Edison.Seq as S ( Sequence(..) )
 import Data.Edison.Seq.Defaults
 import qualified Data.Edison.Seq.ListSeq as L
@@ -384,6 +386,17 @@
 
 instance Functor Seq where
   fmap = map
+
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance Monad Seq where
   return = singleton
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
@@ -54,6 +54,7 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
 import Control.Monad.Identity
 import Data.Maybe
 
@@ -417,6 +418,17 @@
 
 instance Functor Seq where
   fmap = map
+
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance Monad Seq where
   return = singleton
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
@@ -71,11 +71,13 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
 import Control.Monad.Identity
 import Data.Maybe
 import Data.Monoid
 import Test.QuickCheck
 
+
 import qualified Data.Edison.Seq as S ( Sequence(..) )
 import Data.Edison.Seq.Defaults
 import qualified Data.Edison.Seq.ListSeq as L
@@ -521,6 +523,17 @@
 
 instance Functor Seq where
   fmap = map
+
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance Monad Seq where
   return = singleton
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
@@ -36,6 +36,7 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
 import Data.Edison.Prelude (measure, Measured())
 import qualified Data.Edison.Seq as S
 import Data.Edison.Seq.Defaults
@@ -347,6 +348,17 @@
 
 instance Functor Seq where
   fmap = map
+
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance Monad Seq where
   return = singleton
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
@@ -53,6 +53,8 @@
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
 import qualified Data.Edison.Seq as S ( Sequence(..) )
+import qualified Control.Applicative as App
+
 import Data.Edison.Seq.Defaults
 import Control.Monad
 import Data.Monoid
@@ -386,6 +388,17 @@
 
 instance Functor Seq where
   fmap = map
+
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance Monad Seq where
   return = singleton
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
@@ -48,6 +48,7 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
 import qualified Data.Edison.Seq as S ( Sequence(..) )
 import Data.Edison.Seq.Defaults
 import Control.Monad.Identity
@@ -388,6 +389,17 @@
 instance Functor Seq where
   fmap = map
 
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
+
 instance Monad Seq where
   return = singleton
   xs >>= k = concatMap k xs
@@ -435,4 +447,3 @@
 
 I don't believe any will do any better, except possibly the first
 -}
-
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
@@ -53,6 +53,8 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
+
 import qualified Data.Edison.Seq as S( Sequence(..) )
 import Data.Edison.Seq.Defaults
 import Control.Monad.Identity
@@ -452,6 +454,17 @@
 
 instance Functor Seq where
   fmap = map
+
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance Monad Seq where
   return = singleton
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
@@ -56,6 +56,8 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
+
 import qualified Data.Edison.Seq as S
 import qualified Data.Edison.Seq.ListSeq as L
 import Data.Edison.Seq.Defaults -- only used by concatMap
@@ -344,6 +346,17 @@
 
 instance S.Sequence s => Functor (Rev s) where
   fmap = map
+
+instance S.Sequence s => App.Alternative (Rev s) where
+  empty = empty
+  (<|>) = append
+
+instance S.Sequence s => App.Applicative (Rev s) where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance S.Sequence s => Monad (Rev s) where
   return = singleton
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
@@ -51,6 +51,8 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
+
 import qualified Data.Edison.Seq as S ( Sequence(..) )
 import Data.Edison.Seq.Defaults
 import qualified Data.Edison.Seq.ListSeq as L
@@ -340,6 +342,17 @@
 
 instance Functor Seq where
   fmap = map
+
+instance App.Alternative Seq where
+  empty = empty
+  (<|>) = append
+
+instance App.Applicative Seq where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance Monad Seq where
   return = singleton
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
@@ -46,6 +46,8 @@
                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,
                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)
 
+import qualified Control.Applicative as App
+
 import qualified Data.Edison.Seq as S
 import qualified Data.Edison.Seq.ListSeq as L
 import Data.Edison.Seq.Defaults -- only used by concatMap
@@ -313,6 +315,17 @@
 
 instance S.Sequence s => Functor (Sized s) where
   fmap = map
+
+instance S.Sequence s => App.Alternative (Sized s) where
+  empty = empty
+  (<|>) = append
+
+instance S.Sequence s => App.Applicative (Sized s) where
+  pure = return
+  x <*> y = do
+     x' <- x
+     y' <- y
+     return (x' y')
 
 instance S.Sequence s => Monad (Sized s) where
   return = singleton