quickcheck-combinators 0.0.0 → 0.0.1

raw patch · 3 files changed

+83/−18 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• ChangeLog.md +12/−0
• quickcheck-combinators.cabal +3/−2
• src/Test/QuickCheck/Combinators.hs +68/−16

@@ -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.

@@ -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

@@ -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