diff --git a/ChangeLog.md b/ChangeLog.md
new file mode 100644
--- /dev/null
+++ b/ChangeLog.md
@@ -0,0 +1,12 @@
+# Revision history for dnf
+
+## 0.0.0 -- 2016-04-08
+
+* First version. Released on an unsuspecting world.
+
+## 0.0.1  -- 2016-06-18
+
+* Added changelog (which you are now reading).
+* Added instances of ``AtLeast``, ``AtMost``, and ``Between`` for
+  ``OrderedList``.
+* Removed some redundant constraints.
diff --git a/quickcheck-combinators.cabal b/quickcheck-combinators.cabal
--- a/quickcheck-combinators.cabal
+++ b/quickcheck-combinators.cabal
@@ -1,5 +1,5 @@
 Name:                   quickcheck-combinators
-Version:                0.0.0
+Version:                0.0.1
 Author:                 Athan Clark <athan.clark@gmail.com>
 Maintainer:             Athan Clark <athan.clark@gmail.com>
 License:                BSD3
@@ -27,7 +27,8 @@
   .
 Cabal-Version:          >= 1.10
 Build-Type:             Simple
-
+Extra-Source-Files:     ChangeLog.md
+                        
 Library
   Default-Language:     Haskell2010
   HS-Source-Dirs:       src
diff --git a/src/Test/QuickCheck/Combinators.hs b/src/Test/QuickCheck/Combinators.hs
--- a/src/Test/QuickCheck/Combinators.hs
+++ b/src/Test/QuickCheck/Combinators.hs
@@ -2,10 +2,16 @@
     DataKinds
   , ScopedTypeVariables
   , FlexibleContexts
+  , FlexibleInstances
   , KindSignatures
   , GeneralizedNewtypeDeriving
   , ConstraintKinds
   , UndecidableInstances
+  , DeriveDataTypeable
+  , DeriveGeneric
+  , DeriveFunctor
+  , DeriveFoldable
+  , DeriveTraversable
   #-}
 
 module Test.QuickCheck.Combinators where
@@ -19,50 +25,82 @@
 
 import Test.QuickCheck
 
+import qualified Data.List as L (sort)
 
+import Data.Data
+import GHC.Generics
 
+
+
 -- | Generate with a minimum, inclusive size as @n :: Nat@
-newtype AtLeast (n :: Nat) t a = AtLeast (t a)
-  deriving (Show, Read, Eq, Ord, Enum)
+newtype AtLeast (n :: Nat) t a = AtLeast
+  { getAtLeast :: t a
+  } deriving (Show, Read, Eq, Ord, Enum, Data, Typeable, Generic, Functor
+             , Applicative, Monad, Foldable, Traversable, Monoid)
 
 instance ( UnfoldableR p t
          , Monoid (t a)
          , Arbitrary a
-         , Arbitrary (t a)
          , KnownNat n
          , p a
          ) => Arbitrary (AtLeast (n :: Nat) t a) where
   arbitrary = sized $ \m' -> do
     let n' = fromIntegral $ natVal (Proxy :: Proxy n)
-    k <- choose (n', m')
-    (ts :: t x) <- (fromMaybe mempty . fromList) <$> replicateM k arbitrary
-    return (AtLeast ts)
+    k  <- choose (min n' m', max n' m')
+    ts <- fromMaybe mempty . fromList <$> replicateM k arbitrary
+    return . AtLeast $ ts
 
+instance ( Arbitrary a
+         , Ord a
+         , UnfoldableR p []
+         , p a
+         , KnownNat n) => Arbitrary (AtLeast (n :: Nat) OrderedList a) where
+  arbitrary = sized $ \m -> do
+    let n' = fromIntegral $ natVal (Proxy :: Proxy n)
+        mkOrd = Ordered . L.sort . fromMaybe mempty . fromList
+    k  <- choose (min n' m, max n' m)
+    ts <- mkOrd <$> replicateM k arbitrary
+    return . AtLeast $ ts
+
 -- | Generate with a maximum, inclusive size as @n :: Nat@
-newtype AtMost (n :: Nat) t a = AtMost (t a)
-  deriving (Show, Read, Eq, Ord, Enum)
+newtype AtMost (n :: Nat) t a = AtMost
+  { getAtMost :: t a
+  } deriving (Show, Read, Eq, Ord, Enum, Data, Typeable, Generic, Functor
+             , Applicative, Monad, Foldable, Traversable, Monoid)
 
 instance ( UnfoldableR p t
          , Monoid (t a)
          , Arbitrary a
-         , Arbitrary (t a)
          , KnownNat m
          , p a
          ) => Arbitrary (AtMost (m :: Nat) t a) where
   arbitrary = sized $ \m'' -> do
     let m' = fromIntegral $ natVal (Proxy :: Proxy m)
     k <- choose (0, min m' m'')
-    (ts :: t x) <- (fromMaybe mempty . fromList) <$> replicateM k arbitrary
-    return (AtMost ts)
+    ts <- fromMaybe mempty . fromList <$> replicateM k arbitrary
+    return . AtMost $ ts
 
+instance ( Arbitrary a
+         , Ord a
+         , UnfoldableR p []
+         , p a
+         , KnownNat n) => Arbitrary (AtMost (n :: Nat) OrderedList a) where
+  arbitrary = sized $ \m -> do
+    let n' = fromIntegral $ natVal (Proxy :: Proxy n)
+        mkOrd = Ordered . L.sort . fromMaybe mempty . fromList
+    k <- choose (0, min n' m)
+    ts <- mkOrd <$> replicateM k arbitrary
+    return . AtMost $ ts
+
 -- | Generate between the inclusive range of @n :: Nat@ and @m :: Nat@
-newtype Between (n :: Nat) (m :: Nat) t a = Between (t a)
-  deriving (Show, Read, Eq, Ord, Enum)
+newtype Between (n :: Nat) (m :: Nat) t a = Between
+  { getBetween :: t a
+  } deriving (Show, Read, Eq, Ord, Enum, Data, Typeable, Generic, Functor
+             , Applicative, Monad, Foldable, Traversable, Monoid)
 
 instance ( UnfoldableR p t
          , Monoid (t a)
          , Arbitrary a
-         , Arbitrary (t a)
          , KnownNat n
          , KnownNat m
          , p a
@@ -71,8 +109,22 @@
     let n' = fromIntegral $ natVal (Proxy :: Proxy n)
         m' = fromIntegral $ natVal (Proxy :: Proxy m)
     k <- choose (n', min m' m'')
-    (ts :: t x) <- (fromMaybe mempty . fromList) <$> replicateM k arbitrary
-    return (Between ts)
+    ts <- fromMaybe mempty . fromList <$> replicateM k arbitrary
+    return . Between $ ts
+
+instance ( Arbitrary a
+         , Ord a
+         , KnownNat n
+         , UnfoldableR p []
+         , p a
+         , KnownNat m) => Arbitrary (Between (n :: Nat) (m :: Nat) OrderedList a) where
+  arbitrary = sized $ \s -> do
+    let n' = fromIntegral $ natVal (Proxy :: Proxy n)
+        m' = fromIntegral $ natVal (Proxy :: Proxy m)
+        mkOrd = Ordered . L.sort . fromMaybe mempty . fromList
+    k <- choose (n', min m' s)
+    ts <- mkOrd <$> replicateM k arbitrary
+    return . Between $ ts
 
 -- | Convenience for @AtLeast 1@
 type NonMempty = AtLeast 1