{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleContexts #-}
#ifndef NO_GENERICS
{-# LANGUAGE DefaultSignatures, FlexibleContexts, TypeOperators #-}
{-# LANGUAGE FlexibleInstances, KindSignatures, ScopedTypeVariables #-}
{-# LANGUAGE MultiParamTypeClasses #-}
#if __GLASGOW_HASKELL__ >= 710
#define OVERLAPPING_ {-# OVERLAPPING #-}
#else
{-# LANGUAGE OverlappingInstances #-}
#define OVERLAPPING_
#endif
#endif
#ifndef NO_POLYKINDS
{-# LANGUAGE PolyKinds #-}
#endif
#ifndef NO_SAFE_HASKELL
{-# LANGUAGE Trustworthy #-}
#endif
#ifndef NO_NEWTYPE_DERIVING
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
#endif
module Test.QuickCheck.Arbitrary
(
Arbitrary(..)
, CoArbitrary(..)
, Arbitrary1(..)
, arbitrary1
, shrink1
, Arbitrary2(..)
, arbitrary2
, shrink2
, applyArbitrary2
, applyArbitrary3
, applyArbitrary4
, arbitrarySizedIntegral
, arbitrarySizedNatural
, arbitraryBoundedIntegral
, arbitrarySizedBoundedIntegral
, arbitrarySizedFractional
, arbitraryBoundedRandom
, arbitraryBoundedEnum
, arbitraryUnicodeChar
, arbitraryASCIIChar
, arbitraryPrintableChar
#ifndef NO_GENERICS
, RecursivelyShrink
, GSubterms
, genericShrink
, subterms
, recursivelyShrink
, genericCoarbitrary
#endif
, shrinkNothing
, shrinkList
, shrinkMap
, shrinkMapBy
, shrinkIntegral
, shrinkRealFrac
, shrinkDecimal
, coarbitraryIntegral
, coarbitraryReal
, coarbitraryShow
, coarbitraryEnum
, (><)
, vector
, orderedList
, infiniteList
)
where
import Control.Applicative
import Data.Foldable(toList)
import System.Random(Random)
import Test.QuickCheck.Gen
import Test.QuickCheck.Random
import Test.QuickCheck.Gen.Unsafe
import Data.Char
( ord
, isLower
, isUpper
, toLower
, isDigit
, isSpace
, isPrint
, generalCategory
, GeneralCategory(..)
)
#ifndef NO_FIXED
import Data.Fixed
( Fixed
, HasResolution
)
#endif
import Data.Ratio
( Ratio
, (%)
, numerator
, denominator
)
import Data.Complex
( Complex((:+)) )
import Data.List
( sort
, nub
)
import Data.Version (Version (..))
import Control.Monad
( liftM
, liftM2
, liftM3
, liftM4
, liftM5
)
import Data.Int(Int8, Int16, Int32, Int64)
import Data.Word(Word, Word8, Word16, Word32, Word64)
import System.Exit (ExitCode(..))
import Foreign.C.Types
#ifndef NO_GENERICS
import GHC.Generics
#endif
import qualified Data.Set as Set
import qualified Data.Map as Map
import qualified Data.IntSet as IntSet
import qualified Data.IntMap as IntMap
import qualified Data.Sequence as Sequence
import qualified Data.Tree as Tree
import Data.Bits
import qualified Data.Monoid as Monoid
#ifndef NO_TRANSFORMERS
import Data.Functor.Identity
import Data.Functor.Constant
import Data.Functor.Compose
import Data.Functor.Product
#endif
class Arbitrary a where
arbitrary :: Gen a
shrink :: a -> [a]
shrink a
_ = []
class Arbitrary1 f where
liftArbitrary :: Gen a -> Gen (f a)
liftShrink :: (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
_ f a
_ = []
arbitrary1 :: (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1 :: Gen (f a)
arbitrary1 = Gen a -> Gen (f a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary Gen a
forall a. Arbitrary a => Gen a
arbitrary
shrink1 :: (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1 :: f a -> [f a]
shrink1 = (a -> [a]) -> f a -> [f a]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
forall a. Arbitrary a => a -> [a]
shrink
class Arbitrary2 f where
liftArbitrary2 :: Gen a -> Gen b -> Gen (f a b)
liftShrink2 :: (a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
liftShrink2 a -> [a]
_ b -> [b]
_ f a b
_ = []
arbitrary2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => Gen (f a b)
arbitrary2 :: Gen (f a b)
arbitrary2 = Gen a -> Gen b -> Gen (f a b)
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
Gen a -> Gen b -> Gen (f a b)
liftArbitrary2 Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen b
forall a. Arbitrary a => Gen a
arbitrary
shrink2 :: (Arbitrary2 f, Arbitrary a, Arbitrary b) => f a b -> [f a b]
shrink2 :: f a b -> [f a b]
shrink2 = (a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
(a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
liftShrink2 a -> [a]
forall a. Arbitrary a => a -> [a]
shrink b -> [b]
forall a. Arbitrary a => a -> [a]
shrink
#ifndef NO_GENERICS
genericShrink :: (Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) => a -> [a]
genericShrink :: a -> [a]
genericShrink a
x = a -> [a]
forall a. (Generic a, GSubterms (Rep a) a) => a -> [a]
subterms a
x [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a -> [a]
forall a. (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
recursivelyShrink a
x
recursivelyShrink :: (Generic a, RecursivelyShrink (Rep a)) => a -> [a]
recursivelyShrink :: a -> [a]
recursivelyShrink = (Rep a Any -> a) -> [Rep a Any] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Rep a Any -> a
forall a x. Generic a => Rep a x -> a
to ([Rep a Any] -> [a]) -> (a -> [Rep a Any]) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a Any -> [Rep a Any]
forall k (f :: k -> *) (a :: k).
RecursivelyShrink f =>
f a -> [f a]
grecursivelyShrink (Rep a Any -> [Rep a Any]) -> (a -> Rep a Any) -> a -> [Rep a Any]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall a x. Generic a => a -> Rep a x
from
class RecursivelyShrink f where
grecursivelyShrink :: f a -> [f a]
instance (RecursivelyShrink f, RecursivelyShrink g) => RecursivelyShrink (f :*: g) where
grecursivelyShrink :: (:*:) f g a -> [(:*:) f g a]
grecursivelyShrink (f a
x :*: g a
y) =
[f a
x' f a -> g a -> (:*:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: g a
y | f a
x' <- f a -> [f a]
forall k (f :: k -> *) (a :: k).
RecursivelyShrink f =>
f a -> [f a]
grecursivelyShrink f a
x] [(:*:) f g a] -> [(:*:) f g a] -> [(:*:) f g a]
forall a. [a] -> [a] -> [a]
++
[f a
x f a -> g a -> (:*:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: g a
y' | g a
y' <- g a -> [g a]
forall k (f :: k -> *) (a :: k).
RecursivelyShrink f =>
f a -> [f a]
grecursivelyShrink g a
y]
instance (RecursivelyShrink f, RecursivelyShrink g) => RecursivelyShrink (f :+: g) where
grecursivelyShrink :: (:+:) f g a -> [(:+:) f g a]
grecursivelyShrink (L1 f a
x) = (f a -> (:+:) f g a) -> [f a] -> [(:+:) f g a]
forall a b. (a -> b) -> [a] -> [b]
map f a -> (:+:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (f a -> [f a]
forall k (f :: k -> *) (a :: k).
RecursivelyShrink f =>
f a -> [f a]
grecursivelyShrink f a
x)
grecursivelyShrink (R1 g a
x) = (g a -> (:+:) f g a) -> [g a] -> [(:+:) f g a]
forall a b. (a -> b) -> [a] -> [b]
map g a -> (:+:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (g a -> [g a]
forall k (f :: k -> *) (a :: k).
RecursivelyShrink f =>
f a -> [f a]
grecursivelyShrink g a
x)
instance RecursivelyShrink f => RecursivelyShrink (M1 i c f) where
grecursivelyShrink :: M1 i c f a -> [M1 i c f a]
grecursivelyShrink (M1 f a
x) = (f a -> M1 i c f a) -> [f a] -> [M1 i c f a]
forall a b. (a -> b) -> [a] -> [b]
map f a -> M1 i c f a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (f a -> [f a]
forall k (f :: k -> *) (a :: k).
RecursivelyShrink f =>
f a -> [f a]
grecursivelyShrink f a
x)
instance Arbitrary a => RecursivelyShrink (K1 i a) where
grecursivelyShrink :: K1 i a a -> [K1 i a a]
grecursivelyShrink (K1 a
x) = (a -> K1 i a a) -> [a] -> [K1 i a a]
forall a b. (a -> b) -> [a] -> [b]
map a -> K1 i a a
forall k i c (p :: k). c -> K1 i c p
K1 (a -> [a]
forall a. Arbitrary a => a -> [a]
shrink a
x)
instance RecursivelyShrink U1 where
grecursivelyShrink :: U1 a -> [U1 a]
grecursivelyShrink U1 a
U1 = []
instance RecursivelyShrink V1 where
grecursivelyShrink :: V1 a -> [V1 a]
grecursivelyShrink V1 a
_ = []
subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a]
subterms :: a -> [a]
subterms = Rep a a -> [a]
forall (f :: * -> *) a. GSubterms f a => f a -> [a]
gSubterms (Rep a a -> [a]) -> (a -> Rep a a) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a a
forall a x. Generic a => a -> Rep a x
from
class GSubterms f a where
gSubterms :: f a -> [a]
instance GSubterms V1 a where
gSubterms :: V1 a -> [a]
gSubterms V1 a
_ = []
instance GSubterms U1 a where
gSubterms :: U1 a -> [a]
gSubterms U1 a
U1 = []
instance (GSubtermsIncl f a, GSubtermsIncl g a) => GSubterms (f :*: g) a where
gSubterms :: (:*:) f g a -> [a]
gSubterms (f a
l :*: g a
r) = f a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl f a
l [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ g a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl g a
r
instance (GSubtermsIncl f a, GSubtermsIncl g a) => GSubterms (f :+: g) a where
gSubterms :: (:+:) f g a -> [a]
gSubterms (L1 f a
x) = f a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl f a
x
gSubterms (R1 g a
x) = g a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl g a
x
instance GSubterms f a => GSubterms (M1 i c f) a where
gSubterms :: M1 i c f a -> [a]
gSubterms (M1 f a
x) = f a -> [a]
forall (f :: * -> *) a. GSubterms f a => f a -> [a]
gSubterms f a
x
instance GSubterms (K1 i a) b where
gSubterms :: K1 i a b -> [b]
gSubterms (K1 a
_) = []
class GSubtermsIncl f a where
gSubtermsIncl :: f a -> [a]
instance GSubtermsIncl V1 a where
gSubtermsIncl :: V1 a -> [a]
gSubtermsIncl V1 a
_ = []
instance GSubtermsIncl U1 a where
gSubtermsIncl :: U1 a -> [a]
gSubtermsIncl U1 a
U1 = []
instance (GSubtermsIncl f a, GSubtermsIncl g a) => GSubtermsIncl (f :*: g) a where
gSubtermsIncl :: (:*:) f g a -> [a]
gSubtermsIncl (f a
l :*: g a
r) = f a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl f a
l [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ g a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl g a
r
instance (GSubtermsIncl f a, GSubtermsIncl g a) => GSubtermsIncl (f :+: g) a where
gSubtermsIncl :: (:+:) f g a -> [a]
gSubtermsIncl (L1 f a
x) = f a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl f a
x
gSubtermsIncl (R1 g a
x) = g a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl g a
x
instance GSubtermsIncl f a => GSubtermsIncl (M1 i c f) a where
gSubtermsIncl :: M1 i c f a -> [a]
gSubtermsIncl (M1 f a
x) = f a -> [a]
forall (f :: * -> *) a. GSubtermsIncl f a => f a -> [a]
gSubtermsIncl f a
x
instance OVERLAPPING_ GSubtermsIncl (K1 i a) a where
gSubtermsIncl :: K1 i a a -> [a]
gSubtermsIncl (K1 a
x) = [a
x]
instance OVERLAPPING_ GSubtermsIncl (K1 i a) b where
gSubtermsIncl :: K1 i a b -> [b]
gSubtermsIncl (K1 a
_) = []
#endif
instance (CoArbitrary a) => Arbitrary1 ((->) a) where
liftArbitrary :: Gen a -> Gen (a -> a)
liftArbitrary Gen a
arbB = (a -> Gen a) -> Gen (a -> a)
forall (m :: * -> *) a. Monad m => m (Gen a) -> Gen (m a)
promote (a -> Gen a -> Gen a
forall a b. CoArbitrary a => a -> Gen b -> Gen b
`coarbitrary` Gen a
arbB)
instance (CoArbitrary a, Arbitrary b) => Arbitrary (a -> b) where
arbitrary :: Gen (a -> b)
arbitrary = Gen (a -> b)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
instance Arbitrary () where
arbitrary :: Gen ()
arbitrary = () -> Gen ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
instance Arbitrary Bool where
arbitrary :: Gen Bool
arbitrary = (Bool, Bool) -> Gen Bool
forall a. Enum a => (a, a) -> Gen a
chooseEnum (Bool
False,Bool
True)
shrink :: Bool -> [Bool]
shrink Bool
True = [Bool
False]
shrink Bool
False = []
instance Arbitrary Ordering where
arbitrary :: Gen Ordering
arbitrary = [Ordering] -> Gen Ordering
forall a. [a] -> Gen a
elements [Ordering
LT, Ordering
EQ, Ordering
GT]
shrink :: Ordering -> [Ordering]
shrink Ordering
GT = [Ordering
EQ, Ordering
LT]
shrink Ordering
LT = [Ordering
EQ]
shrink Ordering
EQ = []
instance Arbitrary1 Maybe where
liftArbitrary :: Gen a -> Gen (Maybe a)
liftArbitrary Gen a
arb = [(Int, Gen (Maybe a))] -> Gen (Maybe a)
forall a. [(Int, Gen a)] -> Gen a
frequency [(Int
1, Maybe a -> Gen (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing), (Int
3, (a -> Maybe a) -> Gen a -> Gen (Maybe a)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM a -> Maybe a
forall a. a -> Maybe a
Just Gen a
arb)]
liftShrink :: (a -> [a]) -> Maybe a -> [Maybe a]
liftShrink a -> [a]
shr (Just a
x) = Maybe a
forall a. Maybe a
Nothing Maybe a -> [Maybe a] -> [Maybe a]
forall a. a -> [a] -> [a]
: [ a -> Maybe a
forall a. a -> Maybe a
Just a
x' | a
x' <- a -> [a]
shr a
x ]
liftShrink a -> [a]
_ Maybe a
Nothing = []
instance Arbitrary a => Arbitrary (Maybe a) where
arbitrary :: Gen (Maybe a)
arbitrary = Gen (Maybe a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: Maybe a -> [Maybe a]
shrink = Maybe a -> [Maybe a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
instance Arbitrary2 Either where
liftArbitrary2 :: Gen a -> Gen b -> Gen (Either a b)
liftArbitrary2 Gen a
arbA Gen b
arbB = [Gen (Either a b)] -> Gen (Either a b)
forall a. [Gen a] -> Gen a
oneof [(a -> Either a b) -> Gen a -> Gen (Either a b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM a -> Either a b
forall a b. a -> Either a b
Left Gen a
arbA, (b -> Either a b) -> Gen b -> Gen (Either a b)
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM b -> Either a b
forall a b. b -> Either a b
Right Gen b
arbB]
liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Either a b -> [Either a b]
liftShrink2 a -> [a]
shrA b -> [b]
_ (Left a
x) = [ a -> Either a b
forall a b. a -> Either a b
Left a
x' | a
x' <- a -> [a]
shrA a
x ]
liftShrink2 a -> [a]
_ b -> [b]
shrB (Right b
y) = [ b -> Either a b
forall a b. b -> Either a b
Right b
y' | b
y' <- b -> [b]
shrB b
y ]
instance Arbitrary a => Arbitrary1 (Either a) where
liftArbitrary :: Gen a -> Gen (Either a a)
liftArbitrary = Gen a -> Gen a -> Gen (Either a a)
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
Gen a -> Gen b -> Gen (f a b)
liftArbitrary2 Gen a
forall a. Arbitrary a => Gen a
arbitrary
liftShrink :: (a -> [a]) -> Either a a -> [Either a a]
liftShrink = (a -> [a]) -> (a -> [a]) -> Either a a -> [Either a a]
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
(a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
liftShrink2 a -> [a]
forall a. Arbitrary a => a -> [a]
shrink
instance (Arbitrary a, Arbitrary b) => Arbitrary (Either a b) where
arbitrary :: Gen (Either a b)
arbitrary = Gen (Either a b)
forall (f :: * -> * -> *) a b.
(Arbitrary2 f, Arbitrary a, Arbitrary b) =>
Gen (f a b)
arbitrary2
shrink :: Either a b -> [Either a b]
shrink = Either a b -> [Either a b]
forall (f :: * -> * -> *) a b.
(Arbitrary2 f, Arbitrary a, Arbitrary b) =>
f a b -> [f a b]
shrink2
instance Arbitrary1 [] where
liftArbitrary :: Gen a -> Gen [a]
liftArbitrary = Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
listOf
liftShrink :: (a -> [a]) -> [a] -> [[a]]
liftShrink = (a -> [a]) -> [a] -> [[a]]
forall a. (a -> [a]) -> [a] -> [[a]]
shrinkList
instance Arbitrary a => Arbitrary [a] where
arbitrary :: Gen [a]
arbitrary = Gen [a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: [a] -> [[a]]
shrink = [a] -> [[a]]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
shrinkList :: (a -> [a]) -> [a] -> [[a]]
shrinkList :: (a -> [a]) -> [a] -> [[a]]
shrinkList a -> [a]
shr [a]
xs = [[[a]]] -> [[a]]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [ Int -> Int -> [a] -> [[a]]
forall a. Int -> Int -> [a] -> [[a]]
removes Int
k Int
n [a]
xs | Int
k <- (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>Int
0) ((Int -> Int) -> Int -> [Int]
forall a. (a -> a) -> a -> [a]
iterate (Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div`Int
2) Int
n) ]
[[a]] -> [[a]] -> [[a]]
forall a. [a] -> [a] -> [a]
++ [a] -> [[a]]
shrinkOne [a]
xs
where
n :: Int
n = [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
xs
shrinkOne :: [a] -> [[a]]
shrinkOne [] = []
shrinkOne (a
x:[a]
xs) = [ a
x'a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs | a
x' <- a -> [a]
shr a
x ]
[[a]] -> [[a]] -> [[a]]
forall a. [a] -> [a] -> [a]
++ [ a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
xs' | [a]
xs' <- [a] -> [[a]]
shrinkOne [a]
xs ]
removes :: Int -> Int -> [a] -> [[a]]
removes Int
k Int
n [a]
xs
| Int
k Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
n = []
| [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [a]
xs2 = [[]]
| Bool
otherwise = [a]
xs2 [a] -> [[a]] -> [[a]]
forall a. a -> [a] -> [a]
: ([a] -> [a]) -> [[a]] -> [[a]]
forall a b. (a -> b) -> [a] -> [b]
map ([a]
xs1 [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++) (Int -> Int -> [a] -> [[a]]
removes Int
k (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
k) [a]
xs2)
where
xs1 :: [a]
xs1 = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take Int
k [a]
xs
xs2 :: [a]
xs2 = Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
drop Int
k [a]
xs
instance Integral a => Arbitrary (Ratio a) where
arbitrary :: Gen (Ratio a)
arbitrary = Gen (Ratio a)
forall a. Fractional a => Gen a
arbitrarySizedFractional
shrink :: Ratio a -> [Ratio a]
shrink = Ratio a -> [Ratio a]
forall a. RealFrac a => a -> [a]
shrinkRealFrac
#if defined(MIN_VERSION_base) && MIN_VERSION_base(4,4,0)
instance Arbitrary a => Arbitrary (Complex a) where
#else
instance (RealFloat a, Arbitrary a) => Arbitrary (Complex a) where
#endif
arbitrary :: Gen (Complex a)
arbitrary = (a -> a -> Complex a) -> Gen a -> Gen a -> Gen (Complex a)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 a -> a -> Complex a
forall a. a -> a -> Complex a
(:+) Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen a
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Complex a -> [Complex a]
shrink (a
x :+ a
y) = [ a
x' a -> a -> Complex a
forall a. a -> a -> Complex a
:+ a
y | a
x' <- a -> [a]
forall a. Arbitrary a => a -> [a]
shrink a
x ] [Complex a] -> [Complex a] -> [Complex a]
forall a. [a] -> [a] -> [a]
++
[ a
x a -> a -> Complex a
forall a. a -> a -> Complex a
:+ a
y' | a
y' <- a -> [a]
forall a. Arbitrary a => a -> [a]
shrink a
y ]
#ifndef NO_FIXED
instance HasResolution a => Arbitrary (Fixed a) where
arbitrary :: Gen (Fixed a)
arbitrary = Gen (Fixed a)
forall a. Fractional a => Gen a
arbitrarySizedFractional
shrink :: Fixed a -> [Fixed a]
shrink = Fixed a -> [Fixed a]
forall a. RealFrac a => a -> [a]
shrinkDecimal
#endif
instance Arbitrary2 (,) where
liftArbitrary2 :: Gen a -> Gen b -> Gen (a, b)
liftArbitrary2 = (a -> b -> (a, b)) -> Gen a -> Gen b -> Gen (a, b)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (,)
liftShrink2 :: (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)]
liftShrink2 a -> [a]
shrA b -> [b]
shrB (a
x, b
y) =
[ (a
x', b
y) | a
x' <- a -> [a]
shrA a
x ]
[(a, b)] -> [(a, b)] -> [(a, b)]
forall a. [a] -> [a] -> [a]
++ [ (a
x, b
y') | b
y' <- b -> [b]
shrB b
y ]
instance (Arbitrary a) => Arbitrary1 ((,) a) where
liftArbitrary :: Gen a -> Gen (a, a)
liftArbitrary = Gen a -> Gen a -> Gen (a, a)
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
Gen a -> Gen b -> Gen (f a b)
liftArbitrary2 Gen a
forall a. Arbitrary a => Gen a
arbitrary
liftShrink :: (a -> [a]) -> (a, a) -> [(a, a)]
liftShrink = (a -> [a]) -> (a -> [a]) -> (a, a) -> [(a, a)]
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
(a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
liftShrink2 a -> [a]
forall a. Arbitrary a => a -> [a]
shrink
instance (Arbitrary a, Arbitrary b) => Arbitrary (a,b) where
arbitrary :: Gen (a, b)
arbitrary = Gen (a, b)
forall (f :: * -> * -> *) a b.
(Arbitrary2 f, Arbitrary a, Arbitrary b) =>
Gen (f a b)
arbitrary2
shrink :: (a, b) -> [(a, b)]
shrink = (a, b) -> [(a, b)]
forall (f :: * -> * -> *) a b.
(Arbitrary2 f, Arbitrary a, Arbitrary b) =>
f a b -> [f a b]
shrink2
instance (Arbitrary a, Arbitrary b, Arbitrary c)
=> Arbitrary (a,b,c)
where
arbitrary :: Gen (a, b, c)
arbitrary = (a -> b -> c -> (a, b, c))
-> Gen a -> Gen b -> Gen c -> Gen (a, b, c)
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 (,,) Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen c
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c) -> [(a, b, c)]
shrink (a
x, b
y, c
z) =
[ (a
x', b
y', c
z')
| (a
x', (b
y', c
z')) <- (a, (b, c)) -> [(a, (b, c))]
forall a. Arbitrary a => a -> [a]
shrink (a
x, (b
y, c
z)) ]
instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d)
=> Arbitrary (a,b,c,d)
where
arbitrary :: Gen (a, b, c, d)
arbitrary = (a -> b -> c -> d -> (a, b, c, d))
-> Gen a -> Gen b -> Gen c -> Gen d -> Gen (a, b, c, d)
forall (m :: * -> *) a1 a2 a3 a4 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
liftM4 (,,,) Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen c
forall a. Arbitrary a => Gen a
arbitrary Gen d
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c, d) -> [(a, b, c, d)]
shrink (a
w, b
x, c
y, d
z) =
[ (a
w', b
x', c
y', d
z')
| (a
w', (b
x', (c
y', d
z'))) <- (a, (b, (c, d))) -> [(a, (b, (c, d)))]
forall a. Arbitrary a => a -> [a]
shrink (a
w, (b
x, (c
y, d
z))) ]
instance (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e)
=> Arbitrary (a,b,c,d,e)
where
arbitrary :: Gen (a, b, c, d, e)
arbitrary = (a -> b -> c -> d -> e -> (a, b, c, d, e))
-> Gen a -> Gen b -> Gen c -> Gen d -> Gen e -> Gen (a, b, c, d, e)
forall (m :: * -> *) a1 a2 a3 a4 a5 r.
Monad m =>
(a1 -> a2 -> a3 -> a4 -> a5 -> r)
-> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
liftM5 (,,,,) Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen c
forall a. Arbitrary a => Gen a
arbitrary Gen d
forall a. Arbitrary a => Gen a
arbitrary Gen e
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c, d, e) -> [(a, b, c, d, e)]
shrink (a
v, b
w, c
x, d
y, e
z) =
[ (a
v', b
w', c
x', d
y', e
z')
| (a
v', (b
w', (c
x', (d
y', e
z')))) <- (a, (b, (c, (d, e)))) -> [(a, (b, (c, (d, e))))]
forall a. Arbitrary a => a -> [a]
shrink (a
v, (b
w, (c
x, (d
y, e
z)))) ]
instance ( Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e
, Arbitrary f
)
=> Arbitrary (a,b,c,d,e,f)
where
arbitrary :: Gen (a, b, c, d, e, f)
arbitrary = (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> Gen (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
forall (m :: * -> *) a. Monad m => a -> m a
return (,,,,,)
Gen (a -> b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> Gen a -> Gen (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen (b -> c -> d -> e -> f -> (a, b, c, d, e, f))
-> Gen b -> Gen (c -> d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen (c -> d -> e -> f -> (a, b, c, d, e, f))
-> Gen c -> Gen (d -> e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen c
forall a. Arbitrary a => Gen a
arbitrary Gen (d -> e -> f -> (a, b, c, d, e, f))
-> Gen d -> Gen (e -> f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen d
forall a. Arbitrary a => Gen a
arbitrary
Gen (e -> f -> (a, b, c, d, e, f))
-> Gen e -> Gen (f -> (a, b, c, d, e, f))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen e
forall a. Arbitrary a => Gen a
arbitrary Gen (f -> (a, b, c, d, e, f)) -> Gen f -> Gen (a, b, c, d, e, f)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen f
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c, d, e, f) -> [(a, b, c, d, e, f)]
shrink (a
u, b
v, c
w, d
x, e
y, f
z) =
[ (a
u', b
v', c
w', d
x', e
y', f
z')
| (a
u', (b
v', (c
w', (d
x', (e
y', f
z'))))) <- (a, (b, (c, (d, (e, f))))) -> [(a, (b, (c, (d, (e, f)))))]
forall a. Arbitrary a => a -> [a]
shrink (a
u, (b
v, (c
w, (d
x, (e
y, f
z))))) ]
instance ( Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e
, Arbitrary f, Arbitrary g
)
=> Arbitrary (a,b,c,d,e,f,g)
where
arbitrary :: Gen (a, b, c, d, e, f, g)
arbitrary = (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Gen (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (m :: * -> *) a. Monad m => a -> m a
return (,,,,,,)
Gen (a -> b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Gen a
-> Gen (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen (b -> c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Gen b -> Gen (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen (c -> d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Gen c -> Gen (d -> e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen c
forall a. Arbitrary a => Gen a
arbitrary Gen (d -> e -> f -> g -> (a, b, c, d, e, f, g))
-> Gen d -> Gen (e -> f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen d
forall a. Arbitrary a => Gen a
arbitrary
Gen (e -> f -> g -> (a, b, c, d, e, f, g))
-> Gen e -> Gen (f -> g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen e
forall a. Arbitrary a => Gen a
arbitrary Gen (f -> g -> (a, b, c, d, e, f, g))
-> Gen f -> Gen (g -> (a, b, c, d, e, f, g))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen f
forall a. Arbitrary a => Gen a
arbitrary Gen (g -> (a, b, c, d, e, f, g))
-> Gen g -> Gen (a, b, c, d, e, f, g)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen g
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c, d, e, f, g) -> [(a, b, c, d, e, f, g)]
shrink (a
t, b
u, c
v, d
w, e
x, f
y, g
z) =
[ (a
t', b
u', c
v', d
w', e
x', f
y', g
z')
| (a
t', (b
u', (c
v', (d
w', (e
x', (f
y', g
z')))))) <- (a, (b, (c, (d, (e, (f, g))))))
-> [(a, (b, (c, (d, (e, (f, g))))))]
forall a. Arbitrary a => a -> [a]
shrink (a
t, (b
u, (c
v, (d
w, (e
x, (f
y, g
z)))))) ]
instance ( Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e
, Arbitrary f, Arbitrary g, Arbitrary h
)
=> Arbitrary (a,b,c,d,e,f,g,h)
where
arbitrary :: Gen (a, b, c, d, e, f, g, h)
arbitrary = (a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Gen
(a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (m :: * -> *) a. Monad m => a -> m a
return (,,,,,,,)
Gen
(a -> b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Gen a
-> Gen
(b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen (b -> c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Gen b
-> Gen (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen (c -> d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Gen c -> Gen (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen c
forall a. Arbitrary a => Gen a
arbitrary Gen (d -> e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Gen d -> Gen (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen d
forall a. Arbitrary a => Gen a
arbitrary
Gen (e -> f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Gen e -> Gen (f -> g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen e
forall a. Arbitrary a => Gen a
arbitrary Gen (f -> g -> h -> (a, b, c, d, e, f, g, h))
-> Gen f -> Gen (g -> h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen f
forall a. Arbitrary a => Gen a
arbitrary Gen (g -> h -> (a, b, c, d, e, f, g, h))
-> Gen g -> Gen (h -> (a, b, c, d, e, f, g, h))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen g
forall a. Arbitrary a => Gen a
arbitrary Gen (h -> (a, b, c, d, e, f, g, h))
-> Gen h -> Gen (a, b, c, d, e, f, g, h)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen h
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c, d, e, f, g, h) -> [(a, b, c, d, e, f, g, h)]
shrink (a
s, b
t, c
u, d
v, e
w, f
x, g
y, h
z) =
[ (a
s', b
t', c
u', d
v', e
w', f
x', g
y', h
z')
| (a
s', (b
t', (c
u', (d
v', (e
w', (f
x', (g
y', h
z')))))))
<- (a, (b, (c, (d, (e, (f, (g, h)))))))
-> [(a, (b, (c, (d, (e, (f, (g, h)))))))]
forall a. Arbitrary a => a -> [a]
shrink (a
s, (b
t, (c
u, (d
v, (e
w, (f
x, (g
y, h
z))))))) ]
instance ( Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e
, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i
)
=> Arbitrary (a,b,c,d,e,f,g,h,i)
where
arbitrary :: Gen (a, b, c, d, e, f, g, h, i)
arbitrary = (a
-> b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> (a, b, c, d, e, f, g, h, i))
-> Gen
(a
-> b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> (a, b, c, d, e, f, g, h, i))
forall (m :: * -> *) a. Monad m => a -> m a
return (,,,,,,,,)
Gen
(a
-> b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> (a, b, c, d, e, f, g, h, i))
-> Gen a
-> Gen
(b
-> c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen
(b
-> c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
-> Gen b
-> Gen
(c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen
(c -> d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
-> Gen c
-> Gen (d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen c
forall a. Arbitrary a => Gen a
arbitrary Gen (d -> e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
-> Gen d
-> Gen (e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen d
forall a. Arbitrary a => Gen a
arbitrary
Gen (e -> f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
-> Gen e -> Gen (f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen e
forall a. Arbitrary a => Gen a
arbitrary Gen (f -> g -> h -> i -> (a, b, c, d, e, f, g, h, i))
-> Gen f -> Gen (g -> h -> i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen f
forall a. Arbitrary a => Gen a
arbitrary Gen (g -> h -> i -> (a, b, c, d, e, f, g, h, i))
-> Gen g -> Gen (h -> i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen g
forall a. Arbitrary a => Gen a
arbitrary Gen (h -> i -> (a, b, c, d, e, f, g, h, i))
-> Gen h -> Gen (i -> (a, b, c, d, e, f, g, h, i))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen h
forall a. Arbitrary a => Gen a
arbitrary
Gen (i -> (a, b, c, d, e, f, g, h, i))
-> Gen i -> Gen (a, b, c, d, e, f, g, h, i)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen i
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c, d, e, f, g, h, i) -> [(a, b, c, d, e, f, g, h, i)]
shrink (a
r, b
s, c
t, d
u, e
v, f
w, g
x, h
y, i
z) =
[ (a
r', b
s', c
t', d
u', e
v', f
w', g
x', h
y', i
z')
| (a
r', (b
s', (c
t', (d
u', (e
v', (f
w', (g
x', (h
y', i
z'))))))))
<- (a, (b, (c, (d, (e, (f, (g, (h, i))))))))
-> [(a, (b, (c, (d, (e, (f, (g, (h, i))))))))]
forall a. Arbitrary a => a -> [a]
shrink (a
r, (b
s, (c
t, (d
u, (e
v, (f
w, (g
x, (h
y, i
z)))))))) ]
instance ( Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d, Arbitrary e
, Arbitrary f, Arbitrary g, Arbitrary h, Arbitrary i, Arbitrary j
)
=> Arbitrary (a,b,c,d,e,f,g,h,i,j)
where
arbitrary :: Gen (a, b, c, d, e, f, g, h, i, j)
arbitrary = (a
-> b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> j
-> (a, b, c, d, e, f, g, h, i, j))
-> Gen
(a
-> b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> j
-> (a, b, c, d, e, f, g, h, i, j))
forall (m :: * -> *) a. Monad m => a -> m a
return (,,,,,,,,,)
Gen
(a
-> b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> j
-> (a, b, c, d, e, f, g, h, i, j))
-> Gen a
-> Gen
(b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> j
-> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen
(b
-> c
-> d
-> e
-> f
-> g
-> h
-> i
-> j
-> (a, b, c, d, e, f, g, h, i, j))
-> Gen b
-> Gen
(c
-> d
-> e
-> f
-> g
-> h
-> i
-> j
-> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen
(c
-> d
-> e
-> f
-> g
-> h
-> i
-> j
-> (a, b, c, d, e, f, g, h, i, j))
-> Gen c
-> Gen
(d -> e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen c
forall a. Arbitrary a => Gen a
arbitrary Gen
(d -> e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
-> Gen d
-> Gen
(e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen d
forall a. Arbitrary a => Gen a
arbitrary
Gen (e -> f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
-> Gen e
-> Gen (f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen e
forall a. Arbitrary a => Gen a
arbitrary Gen (f -> g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
-> Gen f
-> Gen (g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen f
forall a. Arbitrary a => Gen a
arbitrary Gen (g -> h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
-> Gen g -> Gen (h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen g
forall a. Arbitrary a => Gen a
arbitrary Gen (h -> i -> j -> (a, b, c, d, e, f, g, h, i, j))
-> Gen h -> Gen (i -> j -> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen h
forall a. Arbitrary a => Gen a
arbitrary
Gen (i -> j -> (a, b, c, d, e, f, g, h, i, j))
-> Gen i -> Gen (j -> (a, b, c, d, e, f, g, h, i, j))
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen i
forall a. Arbitrary a => Gen a
arbitrary Gen (j -> (a, b, c, d, e, f, g, h, i, j))
-> Gen j -> Gen (a, b, c, d, e, f, g, h, i, j)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen j
forall a. Arbitrary a => Gen a
arbitrary
shrink :: (a, b, c, d, e, f, g, h, i, j) -> [(a, b, c, d, e, f, g, h, i, j)]
shrink (a
q, b
r, c
s, d
t, e
u, f
v, g
w, h
x, i
y, j
z) =
[ (a
q', b
r', c
s', d
t', e
u', f
v', g
w', h
x', i
y', j
z')
| (a
q', (b
r', (c
s', (d
t', (e
u', (f
v', (g
w', (h
x', (i
y', j
z')))))))))
<- (a, (b, (c, (d, (e, (f, (g, (h, (i, j)))))))))
-> [(a, (b, (c, (d, (e, (f, (g, (h, (i, j)))))))))]
forall a. Arbitrary a => a -> [a]
shrink (a
q, (b
r, (c
s, (d
t, (e
u, (f
v, (g
w, (h
x, (i
y, j
z))))))))) ]
instance Arbitrary Integer where
arbitrary :: Gen Integer
arbitrary = Gen Integer
forall a. Integral a => Gen a
arbitrarySizedIntegral
shrink :: Integer -> [Integer]
shrink = Integer -> [Integer]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Int where
arbitrary :: Gen Int
arbitrary = Gen Int
forall a. Integral a => Gen a
arbitrarySizedIntegral
shrink :: Int -> [Int]
shrink = Int -> [Int]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Int8 where
arbitrary :: Gen Int8
arbitrary = Gen Int8
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Int8 -> [Int8]
shrink = Int8 -> [Int8]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Int16 where
arbitrary :: Gen Int16
arbitrary = Gen Int16
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Int16 -> [Int16]
shrink = Int16 -> [Int16]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Int32 where
arbitrary :: Gen Int32
arbitrary = Gen Int32
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Int32 -> [Int32]
shrink = Int32 -> [Int32]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Int64 where
arbitrary :: Gen Int64
arbitrary = Gen Int64
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Int64 -> [Int64]
shrink = Int64 -> [Int64]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Word where
arbitrary :: Gen Word
arbitrary = Gen Word
forall a. Integral a => Gen a
arbitrarySizedNatural
shrink :: Word -> [Word]
shrink = Word -> [Word]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Word8 where
arbitrary :: Gen Word8
arbitrary = Gen Word8
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Word8 -> [Word8]
shrink = Word8 -> [Word8]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Word16 where
arbitrary :: Gen Word16
arbitrary = Gen Word16
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Word16 -> [Word16]
shrink = Word16 -> [Word16]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Word32 where
arbitrary :: Gen Word32
arbitrary = Gen Word32
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Word32 -> [Word32]
shrink = Word32 -> [Word32]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Word64 where
arbitrary :: Gen Word64
arbitrary = Gen Word64
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: Word64 -> [Word64]
shrink = Word64 -> [Word64]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary Char where
arbitrary :: Gen Char
arbitrary =
[(Int, Gen Char)] -> Gen Char
forall a. [(Int, Gen a)] -> Gen a
frequency
[(Int
3, Gen Char
arbitraryASCIIChar),
(Int
1, Gen Char
arbitraryUnicodeChar)]
shrink :: Char -> [Char]
shrink Char
c = (Char -> Bool) -> [Char] -> [Char]
forall a. (a -> Bool) -> [a] -> [a]
filter (Char -> Char -> Bool
<. Char
c) ([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> [Char]
forall a. Eq a => [a] -> [a]
nub
([Char] -> [Char]) -> [Char] -> [Char]
forall a b. (a -> b) -> a -> b
$ [Char
'a',Char
'b',Char
'c']
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [ Char -> Char
toLower Char
c | Char -> Bool
isUpper Char
c ]
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char
'A',Char
'B',Char
'C']
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char
'1',Char
'2',Char
'3']
[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char
' ',Char
'\n']
where
Char
a <. :: Char -> Char -> Bool
<. Char
b = Char -> ((Bool, Bool, Bool), (Bool, Bool, Char))
stamp Char
a ((Bool, Bool, Bool), (Bool, Bool, Char))
-> ((Bool, Bool, Bool), (Bool, Bool, Char)) -> Bool
forall a. Ord a => a -> a -> Bool
< Char -> ((Bool, Bool, Bool), (Bool, Bool, Char))
stamp Char
b
stamp :: Char -> ((Bool, Bool, Bool), (Bool, Bool, Char))
stamp Char
a = ( (Bool -> Bool
not (Char -> Bool
isLower Char
a)
, Bool -> Bool
not (Char -> Bool
isUpper Char
a)
, Bool -> Bool
not (Char -> Bool
isDigit Char
a))
, (Bool -> Bool
not (Char
aChar -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==Char
' ')
, Bool -> Bool
not (Char -> Bool
isSpace Char
a)
, Char
a)
)
instance Arbitrary Float where
arbitrary :: Gen Float
arbitrary = Gen Float
forall a. Fractional a => Gen a
arbitrarySizedFractional
shrink :: Float -> [Float]
shrink = Float -> [Float]
forall a. RealFrac a => a -> [a]
shrinkDecimal
instance Arbitrary Double where
arbitrary :: Gen Double
arbitrary = Gen Double
forall a. Fractional a => Gen a
arbitrarySizedFractional
shrink :: Double -> [Double]
shrink = Double -> [Double]
forall a. RealFrac a => a -> [a]
shrinkDecimal
instance Arbitrary CChar where
arbitrary :: Gen CChar
arbitrary = Gen CChar
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CChar -> [CChar]
shrink = CChar -> [CChar]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CSChar where
arbitrary :: Gen CSChar
arbitrary = Gen CSChar
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CSChar -> [CSChar]
shrink = CSChar -> [CSChar]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CUChar where
arbitrary :: Gen CUChar
arbitrary = Gen CUChar
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CUChar -> [CUChar]
shrink = CUChar -> [CUChar]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CShort where
arbitrary :: Gen CShort
arbitrary = Gen CShort
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CShort -> [CShort]
shrink = CShort -> [CShort]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CUShort where
arbitrary :: Gen CUShort
arbitrary = Gen CUShort
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CUShort -> [CUShort]
shrink = CUShort -> [CUShort]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CInt where
arbitrary :: Gen CInt
arbitrary = Gen CInt
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CInt -> [CInt]
shrink = CInt -> [CInt]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CUInt where
arbitrary :: Gen CUInt
arbitrary = Gen CUInt
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CUInt -> [CUInt]
shrink = CUInt -> [CUInt]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CLong where
arbitrary :: Gen CLong
arbitrary = Gen CLong
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CLong -> [CLong]
shrink = CLong -> [CLong]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CULong where
arbitrary :: Gen CULong
arbitrary = Gen CULong
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CULong -> [CULong]
shrink = CULong -> [CULong]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CPtrdiff where
arbitrary :: Gen CPtrdiff
arbitrary = Gen CPtrdiff
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CPtrdiff -> [CPtrdiff]
shrink = CPtrdiff -> [CPtrdiff]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CSize where
arbitrary :: Gen CSize
arbitrary = Gen CSize
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CSize -> [CSize]
shrink = CSize -> [CSize]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CWchar where
arbitrary :: Gen CWchar
arbitrary = Gen CWchar
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CWchar -> [CWchar]
shrink = CWchar -> [CWchar]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CSigAtomic where
arbitrary :: Gen CSigAtomic
arbitrary = Gen CSigAtomic
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CSigAtomic -> [CSigAtomic]
shrink = CSigAtomic -> [CSigAtomic]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CLLong where
arbitrary :: Gen CLLong
arbitrary = Gen CLLong
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CLLong -> [CLLong]
shrink = CLLong -> [CLLong]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CULLong where
arbitrary :: Gen CULLong
arbitrary = Gen CULLong
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CULLong -> [CULLong]
shrink = CULLong -> [CULLong]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CIntPtr where
arbitrary :: Gen CIntPtr
arbitrary = Gen CIntPtr
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CIntPtr -> [CIntPtr]
shrink = CIntPtr -> [CIntPtr]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CUIntPtr where
arbitrary :: Gen CUIntPtr
arbitrary = Gen CUIntPtr
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CUIntPtr -> [CUIntPtr]
shrink = CUIntPtr -> [CUIntPtr]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CIntMax where
arbitrary :: Gen CIntMax
arbitrary = Gen CIntMax
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CIntMax -> [CIntMax]
shrink = CIntMax -> [CIntMax]
forall a. Integral a => a -> [a]
shrinkIntegral
instance Arbitrary CUIntMax where
arbitrary :: Gen CUIntMax
arbitrary = Gen CUIntMax
forall a. (Bounded a, Integral a) => Gen a
arbitrarySizedBoundedIntegral
shrink :: CUIntMax -> [CUIntMax]
shrink = CUIntMax -> [CUIntMax]
forall a. Integral a => a -> [a]
shrinkIntegral
#ifndef NO_CTYPES_CONSTRUCTORS
instance Arbitrary CClock where
arbitrary :: Gen CClock
arbitrary = (Int64 -> CClock) -> Gen Int64 -> Gen CClock
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int64 -> CClock
CClock Gen Int64
forall a. Arbitrary a => Gen a
arbitrary
shrink :: CClock -> [CClock]
shrink (CClock Int64
x) = (Int64 -> CClock) -> [Int64] -> [CClock]
forall a b. (a -> b) -> [a] -> [b]
map Int64 -> CClock
CClock (Int64 -> [Int64]
forall a. Arbitrary a => a -> [a]
shrink Int64
x)
instance Arbitrary CTime where
arbitrary :: Gen CTime
arbitrary = (Int64 -> CTime) -> Gen Int64 -> Gen CTime
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int64 -> CTime
CTime Gen Int64
forall a. Arbitrary a => Gen a
arbitrary
shrink :: CTime -> [CTime]
shrink (CTime Int64
x) = (Int64 -> CTime) -> [Int64] -> [CTime]
forall a b. (a -> b) -> [a] -> [b]
map Int64 -> CTime
CTime (Int64 -> [Int64]
forall a. Arbitrary a => a -> [a]
shrink Int64
x)
#ifndef NO_FOREIGN_C_USECONDS
instance Arbitrary CUSeconds where
arbitrary :: Gen CUSeconds
arbitrary = (Word32 -> CUSeconds) -> Gen Word32 -> Gen CUSeconds
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Word32 -> CUSeconds
CUSeconds Gen Word32
forall a. Arbitrary a => Gen a
arbitrary
shrink :: CUSeconds -> [CUSeconds]
shrink (CUSeconds Word32
x) = (Word32 -> CUSeconds) -> [Word32] -> [CUSeconds]
forall a b. (a -> b) -> [a] -> [b]
map Word32 -> CUSeconds
CUSeconds (Word32 -> [Word32]
forall a. Arbitrary a => a -> [a]
shrink Word32
x)
instance Arbitrary CSUSeconds where
arbitrary :: Gen CSUSeconds
arbitrary = (Int64 -> CSUSeconds) -> Gen Int64 -> Gen CSUSeconds
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int64 -> CSUSeconds
CSUSeconds Gen Int64
forall a. Arbitrary a => Gen a
arbitrary
shrink :: CSUSeconds -> [CSUSeconds]
shrink (CSUSeconds Int64
x) = (Int64 -> CSUSeconds) -> [Int64] -> [CSUSeconds]
forall a b. (a -> b) -> [a] -> [b]
map Int64 -> CSUSeconds
CSUSeconds (Int64 -> [Int64]
forall a. Arbitrary a => a -> [a]
shrink Int64
x)
#endif
#endif
instance Arbitrary CFloat where
arbitrary :: Gen CFloat
arbitrary = Gen CFloat
forall a. Fractional a => Gen a
arbitrarySizedFractional
shrink :: CFloat -> [CFloat]
shrink = CFloat -> [CFloat]
forall a. RealFrac a => a -> [a]
shrinkDecimal
instance Arbitrary CDouble where
arbitrary :: Gen CDouble
arbitrary = Gen CDouble
forall a. Fractional a => Gen a
arbitrarySizedFractional
shrink :: CDouble -> [CDouble]
shrink = CDouble -> [CDouble]
forall a. RealFrac a => a -> [a]
shrinkDecimal
instance (Ord a, Arbitrary a) => Arbitrary (Set.Set a) where
arbitrary :: Gen (Set a)
arbitrary = ([a] -> Set a) -> Gen [a] -> Gen (Set a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> Set a
forall a. Ord a => [a] -> Set a
Set.fromList Gen [a]
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Set a -> [Set a]
shrink = ([a] -> Set a) -> [[a]] -> [Set a]
forall a b. (a -> b) -> [a] -> [b]
map [a] -> Set a
forall a. Ord a => [a] -> Set a
Set.fromList ([[a]] -> [Set a]) -> (Set a -> [[a]]) -> Set a -> [Set a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> [[a]]
forall a. Arbitrary a => a -> [a]
shrink ([a] -> [[a]]) -> (Set a -> [a]) -> Set a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set a -> [a]
forall a. Set a -> [a]
Set.toList
instance (Ord k, Arbitrary k) => Arbitrary1 (Map.Map k) where
liftArbitrary :: Gen a -> Gen (Map k a)
liftArbitrary = ([(k, a)] -> Map k a) -> Gen [(k, a)] -> Gen (Map k a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(k, a)] -> Map k a
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList (Gen [(k, a)] -> Gen (Map k a))
-> (Gen a -> Gen [(k, a)]) -> Gen a -> Gen (Map k a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen (k, a) -> Gen [(k, a)]
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary (Gen (k, a) -> Gen [(k, a)])
-> (Gen a -> Gen (k, a)) -> Gen a -> Gen [(k, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen a -> Gen (k, a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: (a -> [a]) -> Map k a -> [Map k a]
liftShrink a -> [a]
shr = ([(k, a)] -> Map k a) -> [[(k, a)]] -> [Map k a]
forall a b. (a -> b) -> [a] -> [b]
map [(k, a)] -> Map k a
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([[(k, a)]] -> [Map k a])
-> (Map k a -> [[(k, a)]]) -> Map k a -> [Map k a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, a) -> [(k, a)]) -> [(k, a)] -> [[(k, a)]]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink ((a -> [a]) -> (k, a) -> [(k, a)]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
shr) ([(k, a)] -> [[(k, a)]])
-> (Map k a -> [(k, a)]) -> Map k a -> [[(k, a)]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k a -> [(k, a)]
forall k a. Map k a -> [(k, a)]
Map.toList
instance (Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map.Map k v) where
arbitrary :: Gen (Map k v)
arbitrary = Gen (Map k v)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: Map k v -> [Map k v]
shrink = Map k v -> [Map k v]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
instance Arbitrary IntSet.IntSet where
arbitrary :: Gen IntSet
arbitrary = ([Int] -> IntSet) -> Gen [Int] -> Gen IntSet
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Int] -> IntSet
IntSet.fromList Gen [Int]
forall a. Arbitrary a => Gen a
arbitrary
shrink :: IntSet -> [IntSet]
shrink = ([Int] -> IntSet) -> [[Int]] -> [IntSet]
forall a b. (a -> b) -> [a] -> [b]
map [Int] -> IntSet
IntSet.fromList ([[Int]] -> [IntSet]) -> (IntSet -> [[Int]]) -> IntSet -> [IntSet]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Int] -> [[Int]]
forall a. Arbitrary a => a -> [a]
shrink ([Int] -> [[Int]]) -> (IntSet -> [Int]) -> IntSet -> [[Int]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntSet -> [Int]
IntSet.toList
instance Arbitrary1 IntMap.IntMap where
liftArbitrary :: Gen a -> Gen (IntMap a)
liftArbitrary = ([(Int, a)] -> IntMap a) -> Gen [(Int, a)] -> Gen (IntMap a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [(Int, a)] -> IntMap a
forall a. [(Int, a)] -> IntMap a
IntMap.fromList (Gen [(Int, a)] -> Gen (IntMap a))
-> (Gen a -> Gen [(Int, a)]) -> Gen a -> Gen (IntMap a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen (Int, a) -> Gen [(Int, a)]
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary (Gen (Int, a) -> Gen [(Int, a)])
-> (Gen a -> Gen (Int, a)) -> Gen a -> Gen [(Int, a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen a -> Gen (Int, a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: (a -> [a]) -> IntMap a -> [IntMap a]
liftShrink a -> [a]
shr = ([(Int, a)] -> IntMap a) -> [[(Int, a)]] -> [IntMap a]
forall a b. (a -> b) -> [a] -> [b]
map [(Int, a)] -> IntMap a
forall a. [(Int, a)] -> IntMap a
IntMap.fromList ([[(Int, a)]] -> [IntMap a])
-> (IntMap a -> [[(Int, a)]]) -> IntMap a -> [IntMap a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Int, a) -> [(Int, a)]) -> [(Int, a)] -> [[(Int, a)]]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink ((a -> [a]) -> (Int, a) -> [(Int, a)]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
shr) ([(Int, a)] -> [[(Int, a)]])
-> (IntMap a -> [(Int, a)]) -> IntMap a -> [[(Int, a)]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntMap a -> [(Int, a)]
forall a. IntMap a -> [(Int, a)]
IntMap.toList
instance Arbitrary a => Arbitrary (IntMap.IntMap a) where
arbitrary :: Gen (IntMap a)
arbitrary = Gen (IntMap a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: IntMap a -> [IntMap a]
shrink = IntMap a -> [IntMap a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
instance Arbitrary1 Sequence.Seq where
liftArbitrary :: Gen a -> Gen (Seq a)
liftArbitrary = ([a] -> Seq a) -> Gen [a] -> Gen (Seq a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> Seq a
forall a. [a] -> Seq a
Sequence.fromList (Gen [a] -> Gen (Seq a))
-> (Gen a -> Gen [a]) -> Gen a -> Gen (Seq a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen a -> Gen [a]
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: (a -> [a]) -> Seq a -> [Seq a]
liftShrink a -> [a]
shr = ([a] -> Seq a) -> [[a]] -> [Seq a]
forall a b. (a -> b) -> [a] -> [b]
map [a] -> Seq a
forall a. [a] -> Seq a
Sequence.fromList ([[a]] -> [Seq a]) -> (Seq a -> [[a]]) -> Seq a -> [Seq a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> [a]) -> [a] -> [[a]]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
shr ([a] -> [[a]]) -> (Seq a -> [a]) -> Seq a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
instance Arbitrary a => Arbitrary (Sequence.Seq a) where
arbitrary :: Gen (Seq a)
arbitrary = Gen (Seq a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: Seq a -> [Seq a]
shrink = Seq a -> [Seq a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
instance Arbitrary1 Tree.Tree where
liftArbitrary :: Gen a -> Gen (Tree a)
liftArbitrary Gen a
arb = (Int -> Gen (Tree a)) -> Gen (Tree a)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (Tree a)) -> Gen (Tree a))
-> (Int -> Gen (Tree a)) -> Gen (Tree a)
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
Int
k <- (Int, Int) -> Gen Int
chooseInt (Int
0, Int
n)
Int -> Gen (Tree a)
go Int
k
where
go :: Int -> Gen (Tree a)
go Int
n = do
a
value <- Gen a
arb
[Int]
pars <- Int -> Gen [Int]
arbPartition (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)
[Tree a]
forest <- (Int -> Gen (Tree a)) -> [Int] -> Gen [Tree a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Int -> Gen (Tree a)
go [Int]
pars
Tree a -> Gen (Tree a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Tree a -> Gen (Tree a)) -> Tree a -> Gen (Tree a)
forall a b. (a -> b) -> a -> b
$ a -> [Tree a] -> Tree a
forall a. a -> Forest a -> Tree a
Tree.Node a
value [Tree a]
forest
arbPartition :: Int -> Gen [Int]
arbPartition :: Int -> Gen [Int]
arbPartition Int
k = case Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Int
k Int
1 of
Ordering
LT -> [Int] -> Gen [Int]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
Ordering
EQ -> [Int] -> Gen [Int]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Int
1]
Ordering
GT -> do
Int
first <- (Int, Int) -> Gen Int
chooseInt (Int
1, Int
k)
[Int]
rest <- Int -> Gen [Int]
arbPartition (Int -> Gen [Int]) -> Int -> Gen [Int]
forall a b. (a -> b) -> a -> b
$ Int
k Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
first
[Int] -> Gen [Int]
forall a. [a] -> Gen [a]
shuffle (Int
first Int -> [Int] -> [Int]
forall a. a -> [a] -> [a]
: [Int]
rest)
liftShrink :: (a -> [a]) -> Tree a -> [Tree a]
liftShrink a -> [a]
shr = Tree a -> [Tree a]
go
where
go :: Tree a -> [Tree a]
go (Tree.Node a
val [Tree a]
forest) = [Tree a]
forest [Tree a] -> [Tree a] -> [Tree a]
forall a. [a] -> [a] -> [a]
++
[ a -> [Tree a] -> Tree a
forall a. a -> Forest a -> Tree a
Tree.Node a
e [Tree a]
fs
| (a
e, [Tree a]
fs) <- (a -> [a])
-> ([Tree a] -> [[Tree a]]) -> (a, [Tree a]) -> [(a, [Tree a])]
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
(a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
liftShrink2 a -> [a]
shr ((Tree a -> [Tree a]) -> [Tree a] -> [[Tree a]]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink Tree a -> [Tree a]
go) (a
val, [Tree a]
forest)
]
instance Arbitrary a => Arbitrary (Tree.Tree a) where
arbitrary :: Gen (Tree a)
arbitrary = Gen (Tree a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: Tree a -> [Tree a]
shrink = Tree a -> [Tree a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
instance Arbitrary1 ZipList where
liftArbitrary :: Gen a -> Gen (ZipList a)
liftArbitrary = ([a] -> ZipList a) -> Gen [a] -> Gen (ZipList a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> ZipList a
forall a. [a] -> ZipList a
ZipList (Gen [a] -> Gen (ZipList a))
-> (Gen a -> Gen [a]) -> Gen a -> Gen (ZipList a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen a -> Gen [a]
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: (a -> [a]) -> ZipList a -> [ZipList a]
liftShrink a -> [a]
shr = ([a] -> ZipList a) -> [[a]] -> [ZipList a]
forall a b. (a -> b) -> [a] -> [b]
map [a] -> ZipList a
forall a. [a] -> ZipList a
ZipList ([[a]] -> [ZipList a])
-> (ZipList a -> [[a]]) -> ZipList a -> [ZipList a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> [a]) -> [a] -> [[a]]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
shr ([a] -> [[a]]) -> (ZipList a -> [a]) -> ZipList a -> [[a]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZipList a -> [a]
forall a. ZipList a -> [a]
getZipList
instance Arbitrary a => Arbitrary (ZipList a) where
arbitrary :: Gen (ZipList a)
arbitrary = Gen (ZipList a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: ZipList a -> [ZipList a]
shrink = ZipList a -> [ZipList a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
#ifndef NO_TRANSFORMERS
instance Arbitrary1 Identity where
liftArbitrary :: Gen a -> Gen (Identity a)
liftArbitrary = (a -> Identity a) -> Gen a -> Gen (Identity a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Identity a
forall a. a -> Identity a
Identity
liftShrink :: (a -> [a]) -> Identity a -> [Identity a]
liftShrink a -> [a]
shr = (a -> Identity a) -> [a] -> [Identity a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Identity a
forall a. a -> Identity a
Identity ([a] -> [Identity a])
-> (Identity a -> [a]) -> Identity a -> [Identity a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
shr (a -> [a]) -> (Identity a -> a) -> Identity a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity a -> a
forall a. Identity a -> a
runIdentity
instance Arbitrary a => Arbitrary (Identity a) where
arbitrary :: Gen (Identity a)
arbitrary = Gen (Identity a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: Identity a -> [Identity a]
shrink = Identity a -> [Identity a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
instance Arbitrary2 Constant where
liftArbitrary2 :: Gen a -> Gen b -> Gen (Constant a b)
liftArbitrary2 Gen a
arbA Gen b
_ = (a -> Constant a b) -> Gen a -> Gen (Constant a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Constant a b
forall k a (b :: k). a -> Constant a b
Constant Gen a
arbA
liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Constant a b -> [Constant a b]
liftShrink2 a -> [a]
shrA b -> [b]
_ = (a -> Constant a b) -> [a] -> [Constant a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Constant a b
forall k a (b :: k). a -> Constant a b
Constant ([a] -> [Constant a b])
-> (Constant a b -> [a]) -> Constant a b -> [Constant a b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
shrA (a -> [a]) -> (Constant a b -> a) -> Constant a b -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Constant a b -> a
forall a k (b :: k). Constant a b -> a
getConstant
instance Arbitrary a => Arbitrary1 (Constant a) where
liftArbitrary :: Gen a -> Gen (Constant a a)
liftArbitrary = Gen a -> Gen a -> Gen (Constant a a)
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
Gen a -> Gen b -> Gen (f a b)
liftArbitrary2 Gen a
forall a. Arbitrary a => Gen a
arbitrary
liftShrink :: (a -> [a]) -> Constant a a -> [Constant a a]
liftShrink = (a -> [a]) -> (a -> [a]) -> Constant a a -> [Constant a a]
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
(a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
liftShrink2 a -> [a]
forall a. Arbitrary a => a -> [a]
shrink
instance Arbitrary a => Arbitrary (Constant a b) where
arbitrary :: Gen (Constant a b)
arbitrary = (a -> Constant a b) -> Gen a -> Gen (Constant a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Constant a b
forall k a (b :: k). a -> Constant a b
Constant Gen a
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Constant a b -> [Constant a b]
shrink = (a -> Constant a b) -> [a] -> [Constant a b]
forall a b. (a -> b) -> [a] -> [b]
map a -> Constant a b
forall k a (b :: k). a -> Constant a b
Constant ([a] -> [Constant a b])
-> (Constant a b -> [a]) -> Constant a b -> [Constant a b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Arbitrary a => a -> [a]
shrink (a -> [a]) -> (Constant a b -> a) -> Constant a b -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Constant a b -> a
forall a k (b :: k). Constant a b -> a
getConstant
instance (Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Product f g) where
liftArbitrary :: Gen a -> Gen (Product f g a)
liftArbitrary Gen a
arb = (f a -> g a -> Product f g a)
-> Gen (f a) -> Gen (g a) -> Gen (Product f g a)
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 f a -> g a -> Product f g a
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair (Gen a -> Gen (f a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary Gen a
arb) (Gen a -> Gen (g a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary Gen a
arb)
liftShrink :: (a -> [a]) -> Product f g a -> [Product f g a]
liftShrink a -> [a]
shr (Pair f a
f g a
g) =
[ f a -> g a -> Product f g a
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair f a
f' g a
g | f a
f' <- (a -> [a]) -> f a -> [f a]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
shr f a
f ] [Product f g a] -> [Product f g a] -> [Product f g a]
forall a. [a] -> [a] -> [a]
++
[ f a -> g a -> Product f g a
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair f a
f g a
g' | g a
g' <- (a -> [a]) -> g a -> [g a]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
shr g a
g ]
instance (Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Product f g a) where
arbitrary :: Gen (Product f g a)
arbitrary = Gen (Product f g a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: Product f g a -> [Product f g a]
shrink = Product f g a -> [Product f g a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
instance (Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Compose f g) where
liftArbitrary :: Gen a -> Gen (Compose f g a)
liftArbitrary = (f (g a) -> Compose f g a) -> Gen (f (g a)) -> Gen (Compose f g a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f (g a) -> Compose f g a
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose (Gen (f (g a)) -> Gen (Compose f g a))
-> (Gen a -> Gen (f (g a))) -> Gen a -> Gen (Compose f g a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen (g a) -> Gen (f (g a))
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary (Gen (g a) -> Gen (f (g a)))
-> (Gen a -> Gen (g a)) -> Gen a -> Gen (f (g a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Gen a -> Gen (g a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: (a -> [a]) -> Compose f g a -> [Compose f g a]
liftShrink a -> [a]
shr = (f (g a) -> Compose f g a) -> [f (g a)] -> [Compose f g a]
forall a b. (a -> b) -> [a] -> [b]
map f (g a) -> Compose f g a
forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
f (g a) -> Compose f g a
Compose ([f (g a)] -> [Compose f g a])
-> (Compose f g a -> [f (g a)]) -> Compose f g a -> [Compose f g a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (g a -> [g a]) -> f (g a) -> [f (g a)]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink ((a -> [a]) -> g a -> [g a]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink a -> [a]
shr) (f (g a) -> [f (g a)])
-> (Compose f g a -> f (g a)) -> Compose f g a -> [f (g a)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Compose f g a -> f (g a)
forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2).
Compose f g a -> f (g a)
getCompose
instance (Arbitrary1 f, Arbitrary1 g, Arbitrary a) => Arbitrary (Compose f g a) where
arbitrary :: Gen (Compose f g a)
arbitrary = Gen (Compose f g a)
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1
shrink :: Compose f g a -> [Compose f g a]
shrink = Compose f g a -> [Compose f g a]
forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1
#endif
instance Arbitrary2 Const where
liftArbitrary2 :: Gen a -> Gen b -> Gen (Const a b)
liftArbitrary2 Gen a
arbA Gen b
_ = (a -> Const a b) -> Gen a -> Gen (Const a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Const a b
forall k a (b :: k). a -> Const a b
Const Gen a
arbA
liftShrink2 :: (a -> [a]) -> (b -> [b]) -> Const a b -> [Const a b]
liftShrink2 a -> [a]
shrA b -> [b]
_ = (a -> Const a b) -> [a] -> [Const a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Const a b
forall k a (b :: k). a -> Const a b
Const ([a] -> [Const a b])
-> (Const a b -> [a]) -> Const a b -> [Const a b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
shrA (a -> [a]) -> (Const a b -> a) -> Const a b -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const a b -> a
forall a k (b :: k). Const a b -> a
getConst
instance Arbitrary a => Arbitrary1 (Const a) where
liftArbitrary :: Gen a -> Gen (Const a a)
liftArbitrary = Gen a -> Gen a -> Gen (Const a a)
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
Gen a -> Gen b -> Gen (f a b)
liftArbitrary2 Gen a
forall a. Arbitrary a => Gen a
arbitrary
liftShrink :: (a -> [a]) -> Const a a -> [Const a a]
liftShrink = (a -> [a]) -> (a -> [a]) -> Const a a -> [Const a a]
forall (f :: * -> * -> *) a b.
Arbitrary2 f =>
(a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
liftShrink2 a -> [a]
forall a. Arbitrary a => a -> [a]
shrink
instance Arbitrary a => Arbitrary (Const a b) where
arbitrary :: Gen (Const a b)
arbitrary = (a -> Const a b) -> Gen a -> Gen (Const a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Const a b
forall k a (b :: k). a -> Const a b
Const Gen a
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Const a b -> [Const a b]
shrink = (a -> Const a b) -> [a] -> [Const a b]
forall a b. (a -> b) -> [a] -> [b]
map a -> Const a b
forall k a (b :: k). a -> Const a b
Const ([a] -> [Const a b])
-> (Const a b -> [a]) -> Const a b -> [Const a b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Arbitrary a => a -> [a]
shrink (a -> [a]) -> (Const a b -> a) -> Const a b -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const a b -> a
forall a k (b :: k). Const a b -> a
getConst
instance Arbitrary (m a) => Arbitrary (WrappedMonad m a) where
arbitrary :: Gen (WrappedMonad m a)
arbitrary = m a -> WrappedMonad m a
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m a -> WrappedMonad m a) -> Gen (m a) -> Gen (WrappedMonad m a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (m a)
forall a. Arbitrary a => Gen a
arbitrary
shrink :: WrappedMonad m a -> [WrappedMonad m a]
shrink (WrapMonad m a
a) = (m a -> WrappedMonad m a) -> [m a] -> [WrappedMonad m a]
forall a b. (a -> b) -> [a] -> [b]
map m a -> WrappedMonad m a
forall (m :: * -> *) a. m a -> WrappedMonad m a
WrapMonad (m a -> [m a]
forall a. Arbitrary a => a -> [a]
shrink m a
a)
instance Arbitrary (a b c) => Arbitrary (WrappedArrow a b c) where
arbitrary :: Gen (WrappedArrow a b c)
arbitrary = a b c -> WrappedArrow a b c
forall (a :: * -> * -> *) b c. a b c -> WrappedArrow a b c
WrapArrow (a b c -> WrappedArrow a b c)
-> Gen (a b c) -> Gen (WrappedArrow a b c)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (a b c)
forall a. Arbitrary a => Gen a
arbitrary
shrink :: WrappedArrow a b c -> [WrappedArrow a b c]
shrink (WrapArrow a b c
a) = (a b c -> WrappedArrow a b c) -> [a b c] -> [WrappedArrow a b c]
forall a b. (a -> b) -> [a] -> [b]
map a b c -> WrappedArrow a b c
forall (a :: * -> * -> *) b c. a b c -> WrappedArrow a b c
WrapArrow (a b c -> [a b c]
forall a. Arbitrary a => a -> [a]
shrink a b c
a)
instance Arbitrary a => Arbitrary (Monoid.Dual a) where
arbitrary :: Gen (Dual a)
arbitrary = (a -> Dual a) -> Gen a -> Gen (Dual a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Dual a
forall a. a -> Dual a
Monoid.Dual Gen a
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Dual a -> [Dual a]
shrink = (a -> Dual a) -> [a] -> [Dual a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Dual a
forall a. a -> Dual a
Monoid.Dual ([a] -> [Dual a]) -> (Dual a -> [a]) -> Dual a -> [Dual a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Arbitrary a => a -> [a]
shrink (a -> [a]) -> (Dual a -> a) -> Dual a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Dual a -> a
forall a. Dual a -> a
Monoid.getDual
instance (Arbitrary a, CoArbitrary a) => Arbitrary (Monoid.Endo a) where
arbitrary :: Gen (Endo a)
arbitrary = ((a -> a) -> Endo a) -> Gen (a -> a) -> Gen (Endo a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (a -> a) -> Endo a
forall a. (a -> a) -> Endo a
Monoid.Endo Gen (a -> a)
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Endo a -> [Endo a]
shrink = ((a -> a) -> Endo a) -> [a -> a] -> [Endo a]
forall a b. (a -> b) -> [a] -> [b]
map (a -> a) -> Endo a
forall a. (a -> a) -> Endo a
Monoid.Endo ([a -> a] -> [Endo a])
-> (Endo a -> [a -> a]) -> Endo a -> [Endo a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> a) -> [a -> a]
forall a. Arbitrary a => a -> [a]
shrink ((a -> a) -> [a -> a]) -> (Endo a -> a -> a) -> Endo a -> [a -> a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Endo a -> a -> a
forall a. Endo a -> a -> a
Monoid.appEndo
instance Arbitrary Monoid.All where
arbitrary :: Gen All
arbitrary = (Bool -> All) -> Gen Bool -> Gen All
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> All
Monoid.All Gen Bool
forall a. Arbitrary a => Gen a
arbitrary
shrink :: All -> [All]
shrink = (Bool -> All) -> [Bool] -> [All]
forall a b. (a -> b) -> [a] -> [b]
map Bool -> All
Monoid.All ([Bool] -> [All]) -> (All -> [Bool]) -> All -> [All]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> [Bool]
forall a. Arbitrary a => a -> [a]
shrink (Bool -> [Bool]) -> (All -> Bool) -> All -> [Bool]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. All -> Bool
Monoid.getAll
instance Arbitrary Monoid.Any where
arbitrary :: Gen Any
arbitrary = (Bool -> Any) -> Gen Bool -> Gen Any
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Bool -> Any
Monoid.Any Gen Bool
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Any -> [Any]
shrink = (Bool -> Any) -> [Bool] -> [Any]
forall a b. (a -> b) -> [a] -> [b]
map Bool -> Any
Monoid.Any ([Bool] -> [Any]) -> (Any -> [Bool]) -> Any -> [Any]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> [Bool]
forall a. Arbitrary a => a -> [a]
shrink (Bool -> [Bool]) -> (Any -> Bool) -> Any -> [Bool]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Any -> Bool
Monoid.getAny
instance Arbitrary a => Arbitrary (Monoid.Sum a) where
arbitrary :: Gen (Sum a)
arbitrary = (a -> Sum a) -> Gen a -> Gen (Sum a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Sum a
forall a. a -> Sum a
Monoid.Sum Gen a
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Sum a -> [Sum a]
shrink = (a -> Sum a) -> [a] -> [Sum a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Sum a
forall a. a -> Sum a
Monoid.Sum ([a] -> [Sum a]) -> (Sum a -> [a]) -> Sum a -> [Sum a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Arbitrary a => a -> [a]
shrink (a -> [a]) -> (Sum a -> a) -> Sum a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sum a -> a
forall a. Sum a -> a
Monoid.getSum
instance Arbitrary a => Arbitrary (Monoid.Product a) where
arbitrary :: Gen (Product a)
arbitrary = (a -> Product a) -> Gen a -> Gen (Product a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Product a
forall a. a -> Product a
Monoid.Product Gen a
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Product a -> [Product a]
shrink = (a -> Product a) -> [a] -> [Product a]
forall a b. (a -> b) -> [a] -> [b]
map a -> Product a
forall a. a -> Product a
Monoid.Product ([a] -> [Product a])
-> (Product a -> [a]) -> Product a -> [Product a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. Arbitrary a => a -> [a]
shrink (a -> [a]) -> (Product a -> a) -> Product a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Product a -> a
forall a. Product a -> a
Monoid.getProduct
#if defined(MIN_VERSION_base)
#if MIN_VERSION_base(3,0,0)
instance Arbitrary a => Arbitrary (Monoid.First a) where
arbitrary :: Gen (First a)
arbitrary = (Maybe a -> First a) -> Gen (Maybe a) -> Gen (First a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe a -> First a
forall a. Maybe a -> First a
Monoid.First Gen (Maybe a)
forall a. Arbitrary a => Gen a
arbitrary
shrink :: First a -> [First a]
shrink = (Maybe a -> First a) -> [Maybe a] -> [First a]
forall a b. (a -> b) -> [a] -> [b]
map Maybe a -> First a
forall a. Maybe a -> First a
Monoid.First ([Maybe a] -> [First a])
-> (First a -> [Maybe a]) -> First a -> [First a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe a -> [Maybe a]
forall a. Arbitrary a => a -> [a]
shrink (Maybe a -> [Maybe a])
-> (First a -> Maybe a) -> First a -> [Maybe a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. First a -> Maybe a
forall a. First a -> Maybe a
Monoid.getFirst
instance Arbitrary a => Arbitrary (Monoid.Last a) where
arbitrary :: Gen (Last a)
arbitrary = (Maybe a -> Last a) -> Gen (Maybe a) -> Gen (Last a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe a -> Last a
forall a. Maybe a -> Last a
Monoid.Last Gen (Maybe a)
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Last a -> [Last a]
shrink = (Maybe a -> Last a) -> [Maybe a] -> [Last a]
forall a b. (a -> b) -> [a] -> [b]
map Maybe a -> Last a
forall a. Maybe a -> Last a
Monoid.Last ([Maybe a] -> [Last a])
-> (Last a -> [Maybe a]) -> Last a -> [Last a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe a -> [Maybe a]
forall a. Arbitrary a => a -> [a]
shrink (Maybe a -> [Maybe a])
-> (Last a -> Maybe a) -> Last a -> [Maybe a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Last a -> Maybe a
forall a. Last a -> Maybe a
Monoid.getLast
#endif
#if MIN_VERSION_base(4,8,0)
instance Arbitrary (f a) => Arbitrary (Monoid.Alt f a) where
arbitrary :: Gen (Alt f a)
arbitrary = (f a -> Alt f a) -> Gen (f a) -> Gen (Alt f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap f a -> Alt f a
forall k (f :: k -> *) (a :: k). f a -> Alt f a
Monoid.Alt Gen (f a)
forall a. Arbitrary a => Gen a
arbitrary
shrink :: Alt f a -> [Alt f a]
shrink = (f a -> Alt f a) -> [f a] -> [Alt f a]
forall a b. (a -> b) -> [a] -> [b]
map f a -> Alt f a
forall k (f :: k -> *) (a :: k). f a -> Alt f a
Monoid.Alt ([f a] -> [Alt f a]) -> (Alt f a -> [f a]) -> Alt f a -> [Alt f a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> [f a]
forall a. Arbitrary a => a -> [a]
shrink (f a -> [f a]) -> (Alt f a -> f a) -> Alt f a -> [f a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alt f a -> f a
forall k (f :: k -> *) (a :: k). Alt f a -> f a
Monoid.getAlt
#endif
#endif
instance Arbitrary Version where
arbitrary :: Gen Version
arbitrary = (Int -> Gen Version) -> Gen Version
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen Version) -> Gen Version)
-> (Int -> Gen Version) -> Gen Version
forall a b. (a -> b) -> a -> b
$ \Int
n ->
do Int
k <- (Int, Int) -> Gen Int
chooseInt (Int
0, Int -> Int
log2 Int
n)
[Int]
xs <- Int -> Gen Int -> Gen [Int]
forall a. Int -> Gen a -> Gen [a]
vectorOf (Int
kInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) Gen Int
forall a. Integral a => Gen a
arbitrarySizedNatural
Version -> Gen Version
forall (m :: * -> *) a. Monad m => a -> m a
return ([Int] -> [[Char]] -> Version
Version [Int]
xs [])
where
log2 :: Int -> Int
log2 :: Int -> Int
log2 Int
n | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
1 = Int
0
| Bool
otherwise = Int
1 Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int -> Int
log2 (Int
n Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
2)
shrink :: Version -> [Version]
shrink (Version [Int]
xs [[Char]]
_) =
[ [Int] -> [[Char]] -> Version
Version [Int]
xs' []
| [Int]
xs' <- [Int] -> [[Int]]
forall a. Arbitrary a => a -> [a]
shrink [Int]
xs
, [Int] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Int]
xs' Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
0
, (Int -> Bool) -> [Int] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>=Int
0) [Int]
xs'
]
instance Arbitrary QCGen where
arbitrary :: Gen QCGen
arbitrary = (QCGen -> Int -> QCGen) -> Gen QCGen
forall a. (QCGen -> Int -> a) -> Gen a
MkGen (\QCGen
g Int
_ -> QCGen
g)
instance Arbitrary ExitCode where
arbitrary :: Gen ExitCode
arbitrary = [(Int, Gen ExitCode)] -> Gen ExitCode
forall a. [(Int, Gen a)] -> Gen a
frequency [(Int
1, ExitCode -> Gen ExitCode
forall (m :: * -> *) a. Monad m => a -> m a
return ExitCode
ExitSuccess), (Int
3, (Int -> ExitCode) -> Gen Int -> Gen ExitCode
forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
liftM Int -> ExitCode
ExitFailure Gen Int
forall a. Arbitrary a => Gen a
arbitrary)]
shrink :: ExitCode -> [ExitCode]
shrink (ExitFailure Int
x) = ExitCode
ExitSuccess ExitCode -> [ExitCode] -> [ExitCode]
forall a. a -> [a] -> [a]
: [ Int -> ExitCode
ExitFailure Int
x' | Int
x' <- Int -> [Int]
forall a. Arbitrary a => a -> [a]
shrink Int
x ]
shrink ExitCode
_ = []
applyArbitrary2 :: (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r
applyArbitrary2 :: (a -> b -> r) -> Gen r
applyArbitrary2 a -> b -> r
f = (a -> b -> r) -> Gen a -> Gen b -> Gen r
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> b -> r
f Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen b
forall a. Arbitrary a => Gen a
arbitrary
applyArbitrary3
:: (Arbitrary a, Arbitrary b, Arbitrary c)
=> (a -> b -> c -> r) -> Gen r
applyArbitrary3 :: (a -> b -> c -> r) -> Gen r
applyArbitrary3 a -> b -> c -> r
f = (a -> b -> c -> r) -> Gen a -> Gen b -> Gen c -> Gen r
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 a -> b -> c -> r
f Gen a
forall a. Arbitrary a => Gen a
arbitrary Gen b
forall a. Arbitrary a => Gen a
arbitrary Gen c
forall a. Arbitrary a => Gen a
arbitrary
applyArbitrary4
:: (Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d)
=> (a -> b -> c -> d -> r) -> Gen r
applyArbitrary4 :: (a -> b -> c -> d -> r) -> Gen r
applyArbitrary4 a -> b -> c -> d -> r
f = ((a, b) -> c -> d -> r) -> Gen r
forall a b c r.
(Arbitrary a, Arbitrary b, Arbitrary c) =>
(a -> b -> c -> r) -> Gen r
applyArbitrary3 ((a -> b -> c -> d -> r) -> (a, b) -> c -> d -> r
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> b -> c -> d -> r
f)
arbitrarySizedIntegral :: Integral a => Gen a
arbitrarySizedIntegral :: Gen a
arbitrarySizedIntegral =
(Int -> Gen a) -> Gen a
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen a) -> Gen a) -> (Int -> Gen a) -> Gen a
forall a b. (a -> b) -> a -> b
$ \Int
n ->
(Int -> a) -> Gen Int -> Gen a
forall a. Integral a => (Int -> a) -> Gen Int -> Gen a
inBounds Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Int, Int) -> Gen Int
chooseInt (-Int
n, Int
n))
arbitrarySizedNatural :: Integral a => Gen a
arbitrarySizedNatural :: Gen a
arbitrarySizedNatural =
(Int -> Gen a) -> Gen a
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen a) -> Gen a) -> (Int -> Gen a) -> Gen a
forall a b. (a -> b) -> a -> b
$ \Int
n ->
(Int -> a) -> Gen Int -> Gen a
forall a. Integral a => (Int -> a) -> Gen Int -> Gen a
inBounds Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral ((Int, Int) -> Gen Int
chooseInt (Int
0, Int
n))
inBounds :: Integral a => (Int -> a) -> Gen Int -> Gen a
inBounds :: (Int -> a) -> Gen Int -> Gen a
inBounds Int -> a
fi Gen Int
g = (Int -> a) -> Gen Int -> Gen a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> a
fi (Gen Int
g Gen Int -> (Int -> Bool) -> Gen Int
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` (\Int
x -> Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
x Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== a -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> a
fi Int
x)))
arbitrarySizedFractional :: Fractional a => Gen a
arbitrarySizedFractional :: Gen a
arbitrarySizedFractional =
(Int -> Gen a) -> Gen a
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen a) -> Gen a) -> (Int -> Gen a) -> Gen a
forall a b. (a -> b) -> a -> b
$ \Int
n ->
let n' :: Integer
n' = Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
n in
do Integer
b <- (Integer, Integer) -> Gen Integer
chooseInteger (Integer
1, Integer
precision)
Integer
a <- (Integer, Integer) -> Gen Integer
chooseInteger ((-Integer
n') Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
b, Integer
n' Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
b)
a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> a
forall a. Fractional a => Rational -> a
fromRational (Integer
a Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
b))
where
precision :: Integer
precision = Integer
9999999999999 :: Integer
{-# INLINE withBounds #-}
withBounds :: Bounded a => (a -> a -> Gen a) -> Gen a
withBounds :: (a -> a -> Gen a) -> Gen a
withBounds a -> a -> Gen a
k = a -> a -> Gen a
k a
forall a. Bounded a => a
minBound a
forall a. Bounded a => a
maxBound
arbitraryBoundedIntegral :: (Bounded a, Integral a) => Gen a
arbitraryBoundedIntegral :: Gen a
arbitraryBoundedIntegral = (a, a) -> Gen a
forall a. (Bounded a, Integral a) => (a, a) -> Gen a
chooseBoundedIntegral (a
forall a. Bounded a => a
minBound, a
forall a. Bounded a => a
maxBound)
arbitraryBoundedRandom :: (Bounded a, Random a) => Gen a
arbitraryBoundedRandom :: Gen a
arbitraryBoundedRandom = (a, a) -> Gen a
forall a. Random a => (a, a) -> Gen a
choose (a
forall a. Bounded a => a
minBound,a
forall a. Bounded a => a
maxBound)
arbitraryBoundedEnum :: (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum :: Gen a
arbitraryBoundedEnum = (a, a) -> Gen a
forall a. Enum a => (a, a) -> Gen a
chooseEnum (a
forall a. Bounded a => a
minBound, a
forall a. Bounded a => a
maxBound)
arbitrarySizedBoundedIntegral :: (Bounded a, Integral a) => Gen a
{-# INLINEABLE arbitrarySizedBoundedIntegral #-}
arbitrarySizedBoundedIntegral :: Gen a
arbitrarySizedBoundedIntegral =
(a -> a -> Gen a) -> Gen a
forall a. Bounded a => (a -> a -> Gen a) -> Gen a
withBounds ((a -> a -> Gen a) -> Gen a) -> (a -> a -> Gen a) -> Gen a
forall a b. (a -> b) -> a -> b
$ \a
mn a
mx ->
let ilog2 :: t -> p
ilog2 t
1 = p
0
ilog2 t
n | t
n t -> t -> Bool
forall a. Ord a => a -> a -> Bool
> t
0 = p
1 p -> p -> p
forall a. Num a => a -> a -> a
+ t -> p
ilog2 (t
n t -> t -> t
forall a. Integral a => a -> a -> a
`div` t
2)
bits :: Int
bits = Integer -> Int
forall t p. (Num p, Integral t) => t -> p
ilog2 (a -> Integer
forall a. Integral a => a -> Integer
toInteger a
mx Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- a -> Integer
forall a. Integral a => a -> Integer
toInteger a
mn Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
1) in
(Int -> Gen a) -> Gen a
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen a) -> Gen a) -> (Int -> Gen a) -> Gen a
forall a b. (a -> b) -> a -> b
$ \Int
k ->
let
power :: Int
power = ((Int
bits Int -> Int -> Int
forall a. Ord a => a -> a -> a
`max` Int
40) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
k) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
80
lo :: Integer
lo = a -> Integer
forall a. Integral a => a -> Integer
toInteger a
mn Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
`max` (-Integer
1 Integer -> Int -> Integer
forall a. Bits a => a -> Int -> a
`shiftL` (Int
power Int -> Int -> Int
forall a. Ord a => a -> a -> a
`min` Int
bits))
hi :: Integer
hi = a -> Integer
forall a. Integral a => a -> Integer
toInteger a
mx Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
`min` (Integer
1 Integer -> Int -> Integer
forall a. Bits a => a -> Int -> a
`shiftL` (Int
power Int -> Int -> Int
forall a. Ord a => a -> a -> a
`min` Int
bits)) in
(Integer -> a) -> Gen Integer -> Gen a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> a
forall a. Num a => Integer -> a
fromInteger ((Integer, Integer) -> Gen Integer
chooseInteger (Integer
lo, Integer
hi))
arbitraryUnicodeChar :: Gen Char
arbitraryUnicodeChar :: Gen Char
arbitraryUnicodeChar =
Gen Char
forall a. (Bounded a, Enum a) => Gen a
arbitraryBoundedEnum Gen Char -> (Char -> Bool) -> Gen Char
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` Char -> Bool
isValidUnicode
where
isValidUnicode :: Char -> Bool
isValidUnicode Char
c = case Char -> GeneralCategory
generalCategory Char
c of
GeneralCategory
Surrogate -> Bool
False
GeneralCategory
NotAssigned -> Bool
False
GeneralCategory
_ -> Bool
True
arbitraryASCIIChar :: Gen Char
arbitraryASCIIChar :: Gen Char
arbitraryASCIIChar = (Char, Char) -> Gen Char
forall a. Enum a => (a, a) -> Gen a
chooseEnum (Char
'\0', Char
'\127')
arbitraryPrintableChar :: Gen Char
arbitraryPrintableChar :: Gen Char
arbitraryPrintableChar = Gen Char
forall a. Arbitrary a => Gen a
arbitrary Gen Char -> (Char -> Bool) -> Gen Char
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` Char -> Bool
isPrint
shrinkNothing :: a -> [a]
shrinkNothing :: a -> [a]
shrinkNothing a
_ = []
shrinkMap :: Arbitrary a => (a -> b) -> (b -> a) -> b -> [b]
shrinkMap :: (a -> b) -> (b -> a) -> b -> [b]
shrinkMap a -> b
f b -> a
g = (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]
forall a b. (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]
shrinkMapBy a -> b
f b -> a
g a -> [a]
forall a. Arbitrary a => a -> [a]
shrink
shrinkMapBy :: (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]
shrinkMapBy :: (a -> b) -> (b -> a) -> (a -> [a]) -> b -> [b]
shrinkMapBy a -> b
f b -> a
g a -> [a]
shr = (a -> b) -> [a] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map a -> b
f ([a] -> [b]) -> (b -> [a]) -> b -> [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
shr (a -> [a]) -> (b -> a) -> b -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> a
g
shrinkIntegral :: Integral a => a -> [a]
shrinkIntegral :: a -> [a]
shrinkIntegral a
x =
[a] -> [a]
forall a. Eq a => [a] -> [a]
nub ([a] -> [a]) -> [a] -> [a]
forall a b. (a -> b) -> a -> b
$
[ -a
x
| a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0, -a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
x
] [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++
[ a
x'
| a
x' <- (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (a -> a -> Bool
forall a. (Ord a, Num a) => a -> a -> Bool
<< a
x) (a
0a -> [a] -> [a]
forall a. a -> [a] -> [a]
:[ a
x a -> a -> a
forall a. Num a => a -> a -> a
- a
i | a
i <- [a] -> [a]
forall a. [a] -> [a]
tail ((a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate (a -> a -> a
forall a. Integral a => a -> a -> a
`quot` a
2) a
x) ])
]
where
a
a << :: a -> a -> Bool
<< a
b = case (a
a a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
0, a
b a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
0) of
(Bool
True, Bool
True) -> a
a a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
b
(Bool
False, Bool
False) -> a
a a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
b
(Bool
True, Bool
False) -> a
a a -> a -> a
forall a. Num a => a -> a -> a
+ a
b a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0
(Bool
False, Bool
True) -> a
a a -> a -> a
forall a. Num a => a -> a -> a
+ a
b a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0
shrinkRealFrac :: RealFrac a => a -> [a]
shrinkRealFrac :: a -> [a]
shrinkRealFrac a
x
| Bool -> Bool
not (a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
x) = a
0 a -> [a] -> [a]
forall a. a -> [a] -> [a]
: Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take Int
10 ((a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate (a -> a -> a
forall a. Num a => a -> a -> a
*a
2) a
0)
| Bool -> Bool
not (a
2a -> a -> a
forall a. Num a => a -> a -> a
*a
xa -> a -> a
forall a. Num a => a -> a -> a
+a
1a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>a
x) = a
0 a -> [a] -> [a]
forall a. a -> [a] -> [a]
: (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<a
x) ((a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate (a -> a -> a
forall a. Num a => a -> a -> a
*a
2) a
0)
| a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
0 = a -> a
forall a. Num a => a -> a
negate a
xa -> [a] -> [a]
forall a. a -> [a] -> [a]
:(a -> a) -> [a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map a -> a
forall a. Num a => a -> a
negate (a -> [a]
forall a. RealFrac a => a -> [a]
shrinkRealFrac (a -> a
forall a. Num a => a -> a
negate a
x))
| Bool
otherwise =
(a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter (\a
y -> a -> a
forall a. Num a => a -> a
abs a
y a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a -> a
forall a. Num a => a -> a
abs a
x) ([a] -> [a]) -> [a] -> [a]
forall a b. (a -> b) -> a -> b
$
(Integer -> a) -> [Integer] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Integer -> a
forall a. Num a => Integer -> a
fromInteger (Integer -> [Integer]
forall a. Arbitrary a => a -> [a]
shrink (a -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate a
x) [Integer] -> [Integer] -> [Integer]
forall a. [a] -> [a] -> [a]
++ [a -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate a
x]) [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++
[Rational -> a
forall a. Fractional a => Rational -> a
fromRational (Integer
num' Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
denom) | Integer
num' <- Integer -> [Integer]
forall a. Arbitrary a => a -> [a]
shrink Integer
num] [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++
[Rational -> a
forall a. Fractional a => Rational -> a
fromRational (Rational -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
truncate (Integer
num Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
denom' Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
denom) Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
denom')
| Integer
denom' <- Integer -> [Integer]
forall a. Arbitrary a => a -> [a]
shrink Integer
denom, Integer
denom' Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
/= Integer
0 ]
where
num :: Integer
num = Rational -> Integer
forall a. Ratio a -> a
numerator (a -> Rational
forall a. Real a => a -> Rational
toRational a
x)
denom :: Integer
denom = Rational -> Integer
forall a. Ratio a -> a
denominator (a -> Rational
forall a. Real a => a -> Rational
toRational a
x)
shrinkDecimal :: RealFrac a => a -> [a]
shrinkDecimal :: a -> [a]
shrinkDecimal a
x
| Bool -> Bool
not (a
x a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
x) = a
0 a -> [a] -> [a]
forall a. a -> [a] -> [a]
: Int -> [a] -> [a]
forall a. Int -> [a] -> [a]
take Int
10 ((a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate (a -> a -> a
forall a. Num a => a -> a -> a
*a
2) a
0)
| Bool -> Bool
not (a
2a -> a -> a
forall a. Num a => a -> a -> a
*a -> a
forall a. Num a => a -> a
abs a
xa -> a -> a
forall a. Num a => a -> a -> a
+a
1a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>a -> a
forall a. Num a => a -> a
abs a
x) = a
0 a -> [a] -> [a]
forall a. a -> [a] -> [a]
: (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (a -> a -> Bool
forall a. Ord a => a -> a -> Bool
<a
x) ((a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate (a -> a -> a
forall a. Num a => a -> a -> a
*a
2) a
0)
| Bool
otherwise =
[ a
y
| Rational
precision <- Int -> [Rational] -> [Rational]
forall a. Int -> [a] -> [a]
take Int
6 ((Rational -> Rational) -> Rational -> [Rational]
forall a. (a -> a) -> a -> [a]
iterate (Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
*Rational
10) Rational
1),
let m :: Integer
m = Rational -> Integer
forall a b. (RealFrac a, Integral b) => a -> b
round (a -> Rational
forall a. Real a => a -> Rational
toRational a
x Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
* Rational
precision),
Rational
precision Rational -> Rational -> Bool
forall a. Eq a => a -> a -> Bool
== Rational
1 Bool -> Bool -> Bool
|| Integer
m Integer -> Integer -> Integer
forall a. Integral a => a -> a -> a
`mod` Integer
10 Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
/= Integer
0,
Integer
n <- Integer
mInteger -> [Integer] -> [Integer]
forall a. a -> [a] -> [a]
:Integer -> [Integer]
forall a. Arbitrary a => a -> [a]
shrink Integer
m,
let y :: a
y = Rational -> a
forall a. Fractional a => Rational -> a
fromRational (Integer -> Rational
forall a. Num a => Integer -> a
fromInteger Integer
n Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/ Rational
precision),
a -> a
forall a. Num a => a -> a
abs a
y a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a -> a
forall a. Num a => a -> a
abs a
x ]
#ifndef NO_GENERICS
#else
#endif
class CoArbitrary a where
coarbitrary :: a -> Gen b -> Gen b
#ifndef NO_GENERICS
default coarbitrary :: (Generic a, GCoArbitrary (Rep a)) => a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall a b.
(Generic a, GCoArbitrary (Rep a)) =>
a -> Gen b -> Gen b
genericCoarbitrary
genericCoarbitrary :: (Generic a, GCoArbitrary (Rep a)) => a -> Gen b -> Gen b
genericCoarbitrary :: a -> Gen b -> Gen b
genericCoarbitrary = Rep a Any -> Gen b -> Gen b
forall k (f :: k -> *) (a :: k) b.
GCoArbitrary f =>
f a -> Gen b -> Gen b
gCoarbitrary (Rep a Any -> Gen b -> Gen b)
-> (a -> Rep a Any) -> a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall a x. Generic a => a -> Rep a x
from
class GCoArbitrary f where
gCoarbitrary :: f a -> Gen b -> Gen b
instance GCoArbitrary U1 where
gCoarbitrary :: U1 a -> Gen b -> Gen b
gCoarbitrary U1 a
U1 = Gen b -> Gen b
forall a. a -> a
id
instance (GCoArbitrary f, GCoArbitrary g) => GCoArbitrary (f :*: g) where
gCoarbitrary :: (:*:) f g a -> Gen b -> Gen b
gCoarbitrary (f a
l :*: g a
r) = f a -> Gen b -> Gen b
forall k (f :: k -> *) (a :: k) b.
GCoArbitrary f =>
f a -> Gen b -> Gen b
gCoarbitrary f a
l (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g a -> Gen b -> Gen b
forall k (f :: k -> *) (a :: k) b.
GCoArbitrary f =>
f a -> Gen b -> Gen b
gCoarbitrary g a
r
instance (GCoArbitrary f, GCoArbitrary g) => GCoArbitrary (f :+: g) where
gCoarbitrary :: (:+:) f g a -> Gen b -> Gen b
gCoarbitrary (L1 f a
x) = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
0 (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> Gen b -> Gen b
forall k (f :: k -> *) (a :: k) b.
GCoArbitrary f =>
f a -> Gen b -> Gen b
gCoarbitrary f a
x
gCoarbitrary (R1 g a
x) = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
1 (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. g a -> Gen b -> Gen b
forall k (f :: k -> *) (a :: k) b.
GCoArbitrary f =>
f a -> Gen b -> Gen b
gCoarbitrary g a
x
instance GCoArbitrary f => GCoArbitrary (M1 i c f) where
gCoarbitrary :: M1 i c f a -> Gen b -> Gen b
gCoarbitrary (M1 f a
x) = f a -> Gen b -> Gen b
forall k (f :: k -> *) (a :: k) b.
GCoArbitrary f =>
f a -> Gen b -> Gen b
gCoarbitrary f a
x
instance CoArbitrary a => GCoArbitrary (K1 i a) where
gCoarbitrary :: K1 i a a -> Gen b -> Gen b
gCoarbitrary (K1 a
x) = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x
#endif
{-# DEPRECATED (><) "Use ordinary function composition instead" #-}
(><) :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> (Gen a -> Gen a)
>< :: (Gen a -> Gen a) -> (Gen a -> Gen a) -> Gen a -> Gen a
(><) = (Gen a -> Gen a) -> (Gen a -> Gen a) -> Gen a -> Gen a
forall b c a. (b -> c) -> (a -> b) -> a -> c
(.)
instance (Arbitrary a, CoArbitrary b) => CoArbitrary (a -> b) where
coarbitrary :: (a -> b) -> Gen b -> Gen b
coarbitrary a -> b
f Gen b
gen =
do [a]
xs <- Gen [a]
forall a. Arbitrary a => Gen a
arbitrary
[b] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ((a -> b) -> [a] -> [b]
forall a b. (a -> b) -> [a] -> [b]
map a -> b
f [a]
xs) Gen b
gen
instance CoArbitrary () where
coarbitrary :: () -> Gen b -> Gen b
coarbitrary ()
_ = Gen b -> Gen b
forall a. a -> a
id
instance CoArbitrary Bool where
coarbitrary :: Bool -> Gen b -> Gen b
coarbitrary Bool
False = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
0
coarbitrary Bool
True = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
1
instance CoArbitrary Ordering where
coarbitrary :: Ordering -> Gen b -> Gen b
coarbitrary Ordering
GT = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
0
coarbitrary Ordering
EQ = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
1
coarbitrary Ordering
LT = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
2
instance CoArbitrary a => CoArbitrary (Maybe a) where
coarbitrary :: Maybe a -> Gen b -> Gen b
coarbitrary Maybe a
Nothing = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
0
coarbitrary (Just a
x) = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
1 (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x
instance (CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b) where
coarbitrary :: Either a b -> Gen b -> Gen b
coarbitrary (Left a
x) = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
0 (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x
coarbitrary (Right b
y) = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
1 (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary b
y
instance CoArbitrary a => CoArbitrary [a] where
coarbitrary :: [a] -> Gen b -> Gen b
coarbitrary [] = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
0
coarbitrary (a
x:[a]
xs) = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
1 (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, [a]) -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a
x,[a]
xs)
instance (Integral a, CoArbitrary a) => CoArbitrary (Ratio a) where
coarbitrary :: Ratio a -> Gen b -> Gen b
coarbitrary Ratio a
r = (a, a) -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Ratio a -> a
forall a. Ratio a -> a
numerator Ratio a
r,Ratio a -> a
forall a. Ratio a -> a
denominator Ratio a
r)
#ifndef NO_FIXED
instance HasResolution a => CoArbitrary (Fixed a) where
coarbitrary :: Fixed a -> Gen b -> Gen b
coarbitrary = Fixed a -> Gen b -> Gen b
forall a b. Real a => a -> Gen b -> Gen b
coarbitraryReal
#endif
#if defined(MIN_VERSION_base) && MIN_VERSION_base(4,4,0)
instance CoArbitrary a => CoArbitrary (Complex a) where
#else
instance (RealFloat a, CoArbitrary a) => CoArbitrary (Complex a) where
#endif
coarbitrary :: Complex a -> Gen b -> Gen b
coarbitrary (a
x :+ a
y) = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
y
instance (CoArbitrary a, CoArbitrary b)
=> CoArbitrary (a,b)
where
coarbitrary :: (a, b) -> Gen b -> Gen b
coarbitrary (a
x,b
y) = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary b
y
instance (CoArbitrary a, CoArbitrary b, CoArbitrary c)
=> CoArbitrary (a,b,c)
where
coarbitrary :: (a, b, c) -> Gen b -> Gen b
coarbitrary (a
x,b
y,c
z) = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary b
y
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary c
z
instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d)
=> CoArbitrary (a,b,c,d)
where
coarbitrary :: (a, b, c, d) -> Gen b -> Gen b
coarbitrary (a
x,b
y,c
z,d
v) = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary b
y
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary c
z
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. d -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary d
v
instance (CoArbitrary a, CoArbitrary b, CoArbitrary c, CoArbitrary d, CoArbitrary e)
=> CoArbitrary (a,b,c,d,e)
where
coarbitrary :: (a, b, c, d, e) -> Gen b -> Gen b
coarbitrary (a
x,b
y,c
z,d
v,e
w) = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
x
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary b
y
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. c -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary c
z
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. d -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary d
v
(Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary e
w
instance CoArbitrary Integer where
coarbitrary :: Integer -> Gen b -> Gen b
coarbitrary = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Int where
coarbitrary :: Int -> Gen b -> Gen b
coarbitrary = Int -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Int8 where
coarbitrary :: Int8 -> Gen b -> Gen b
coarbitrary = Int8 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Int16 where
coarbitrary :: Int16 -> Gen b -> Gen b
coarbitrary = Int16 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Int32 where
coarbitrary :: Int32 -> Gen b -> Gen b
coarbitrary = Int32 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Int64 where
coarbitrary :: Int64 -> Gen b -> Gen b
coarbitrary = Int64 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Word where
coarbitrary :: Word -> Gen b -> Gen b
coarbitrary = Word -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Word8 where
coarbitrary :: Word8 -> Gen b -> Gen b
coarbitrary = Word8 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Word16 where
coarbitrary :: Word16 -> Gen b -> Gen b
coarbitrary = Word16 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Word32 where
coarbitrary :: Word32 -> Gen b -> Gen b
coarbitrary = Word32 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Word64 where
coarbitrary :: Word64 -> Gen b -> Gen b
coarbitrary = Word64 -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
coarbitraryIntegral
instance CoArbitrary Char where
coarbitrary :: Char -> Gen b -> Gen b
coarbitrary = Int -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Int -> Gen b -> Gen b) -> (Char -> Int) -> Char -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord
instance CoArbitrary Float where
coarbitrary :: Float -> Gen b -> Gen b
coarbitrary = Float -> Gen b -> Gen b
forall a b. Real a => a -> Gen b -> Gen b
coarbitraryReal
instance CoArbitrary Double where
coarbitrary :: Double -> Gen b -> Gen b
coarbitrary = Double -> Gen b -> Gen b
forall a b. Real a => a -> Gen b -> Gen b
coarbitraryReal
instance CoArbitrary a => CoArbitrary (Set.Set a) where
coarbitrary :: Set a -> Gen b -> Gen b
coarbitrary = [a] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary([a] -> Gen b -> Gen b)
-> (Set a -> [a]) -> Set a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Set a -> [a]
forall a. Set a -> [a]
Set.toList
instance (CoArbitrary k, CoArbitrary v) => CoArbitrary (Map.Map k v) where
coarbitrary :: Map k v -> Gen b -> Gen b
coarbitrary = [(k, v)] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ([(k, v)] -> Gen b -> Gen b)
-> (Map k v -> [(k, v)]) -> Map k v -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map k v -> [(k, v)]
forall k a. Map k a -> [(k, a)]
Map.toList
instance CoArbitrary IntSet.IntSet where
coarbitrary :: IntSet -> Gen b -> Gen b
coarbitrary = [Int] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ([Int] -> Gen b -> Gen b)
-> (IntSet -> [Int]) -> IntSet -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntSet -> [Int]
IntSet.toList
instance CoArbitrary a => CoArbitrary (IntMap.IntMap a) where
coarbitrary :: IntMap a -> Gen b -> Gen b
coarbitrary = [(Int, a)] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ([(Int, a)] -> Gen b -> Gen b)
-> (IntMap a -> [(Int, a)]) -> IntMap a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IntMap a -> [(Int, a)]
forall a. IntMap a -> [(Int, a)]
IntMap.toList
instance CoArbitrary a => CoArbitrary (Sequence.Seq a) where
coarbitrary :: Seq a -> Gen b -> Gen b
coarbitrary = [a] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ([a] -> Gen b -> Gen b)
-> (Seq a -> [a]) -> Seq a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
instance CoArbitrary a => CoArbitrary (Tree.Tree a) where
coarbitrary :: Tree a -> Gen b -> Gen b
coarbitrary (Tree.Node a
val Forest a
forest) = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary a
val (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Forest a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Forest a
forest
instance CoArbitrary a => CoArbitrary (ZipList a) where
coarbitrary :: ZipList a -> Gen b -> Gen b
coarbitrary = [a] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ([a] -> Gen b -> Gen b)
-> (ZipList a -> [a]) -> ZipList a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ZipList a -> [a]
forall a. ZipList a -> [a]
getZipList
#ifndef NO_TRANSFORMERS
instance CoArbitrary a => CoArbitrary (Identity a) where
coarbitrary :: Identity a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Gen b -> Gen b)
-> (Identity a -> a) -> Identity a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Identity a -> a
forall a. Identity a -> a
runIdentity
instance CoArbitrary a => CoArbitrary (Constant a b) where
coarbitrary :: Constant a b -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Gen b -> Gen b)
-> (Constant a b -> a) -> Constant a b -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Constant a b -> a
forall a k (b :: k). Constant a b -> a
getConstant
#endif
instance CoArbitrary a => CoArbitrary (Const a b) where
coarbitrary :: Const a b -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Gen b -> Gen b)
-> (Const a b -> a) -> Const a b -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Const a b -> a
forall a k (b :: k). Const a b -> a
getConst
instance CoArbitrary a => CoArbitrary (Monoid.Dual a) where
coarbitrary :: Dual a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Gen b -> Gen b) -> (Dual a -> a) -> Dual a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Dual a -> a
forall a. Dual a -> a
Monoid.getDual
instance (Arbitrary a, CoArbitrary a) => CoArbitrary (Monoid.Endo a) where
coarbitrary :: Endo a -> Gen b -> Gen b
coarbitrary = (a -> a) -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ((a -> a) -> Gen b -> Gen b)
-> (Endo a -> a -> a) -> Endo a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Endo a -> a -> a
forall a. Endo a -> a -> a
Monoid.appEndo
instance CoArbitrary Monoid.All where
coarbitrary :: All -> Gen b -> Gen b
coarbitrary = Bool -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Bool -> Gen b -> Gen b) -> (All -> Bool) -> All -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. All -> Bool
Monoid.getAll
instance CoArbitrary Monoid.Any where
coarbitrary :: Any -> Gen b -> Gen b
coarbitrary = Bool -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Bool -> Gen b -> Gen b) -> (Any -> Bool) -> Any -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Any -> Bool
Monoid.getAny
instance CoArbitrary a => CoArbitrary (Monoid.Sum a) where
coarbitrary :: Sum a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Gen b -> Gen b) -> (Sum a -> a) -> Sum a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Sum a -> a
forall a. Sum a -> a
Monoid.getSum
instance CoArbitrary a => CoArbitrary (Monoid.Product a) where
coarbitrary :: Product a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Gen b -> Gen b)
-> (Product a -> a) -> Product a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Product a -> a
forall a. Product a -> a
Monoid.getProduct
#if defined(MIN_VERSION_base)
#if MIN_VERSION_base(3,0,0)
instance CoArbitrary a => CoArbitrary (Monoid.First a) where
coarbitrary :: First a -> Gen b -> Gen b
coarbitrary = Maybe a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Maybe a -> Gen b -> Gen b)
-> (First a -> Maybe a) -> First a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. First a -> Maybe a
forall a. First a -> Maybe a
Monoid.getFirst
instance CoArbitrary a => CoArbitrary (Monoid.Last a) where
coarbitrary :: Last a -> Gen b -> Gen b
coarbitrary = Maybe a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (Maybe a -> Gen b -> Gen b)
-> (Last a -> Maybe a) -> Last a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Last a -> Maybe a
forall a. Last a -> Maybe a
Monoid.getLast
#endif
#if MIN_VERSION_base(4,8,0)
instance CoArbitrary (f a) => CoArbitrary (Monoid.Alt f a) where
coarbitrary :: Alt f a -> Gen b -> Gen b
coarbitrary = f a -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (f a -> Gen b -> Gen b)
-> (Alt f a -> f a) -> Alt f a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Alt f a -> f a
forall k (f :: k -> *) (a :: k). Alt f a -> f a
Monoid.getAlt
#endif
#endif
instance CoArbitrary Version where
coarbitrary :: Version -> Gen b -> Gen b
coarbitrary (Version [Int]
a [[Char]]
b) = ([Int], [[Char]]) -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ([Int]
a, [[Char]]
b)
coarbitraryIntegral :: Integral a => a -> Gen b -> Gen b
coarbitraryIntegral :: a -> Gen b -> Gen b
coarbitraryIntegral = a -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant
coarbitraryReal :: Real a => a -> Gen b -> Gen b
coarbitraryReal :: a -> Gen b -> Gen b
coarbitraryReal a
x = Rational -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> Rational
forall a. Real a => a -> Rational
toRational a
x)
coarbitraryShow :: Show a => a -> Gen b -> Gen b
coarbitraryShow :: a -> Gen b -> Gen b
coarbitraryShow a
x = [Char] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary (a -> [Char]
forall a. Show a => a -> [Char]
show a
x)
coarbitraryEnum :: Enum a => a -> Gen b -> Gen b
coarbitraryEnum :: a -> Gen b -> Gen b
coarbitraryEnum = Int -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant (Int -> Gen b -> Gen b) -> (a -> Int) -> a -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Int
forall a. Enum a => a -> Int
fromEnum
vector :: Arbitrary a => Int -> Gen [a]
vector :: Int -> Gen [a]
vector Int
k = Int -> Gen a -> Gen [a]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
k Gen a
forall a. Arbitrary a => Gen a
arbitrary
orderedList :: (Ord a, Arbitrary a) => Gen [a]
orderedList :: Gen [a]
orderedList = [a] -> [a]
forall a. Ord a => [a] -> [a]
sort ([a] -> [a]) -> Gen [a] -> Gen [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Gen [a]
forall a. Arbitrary a => Gen a
arbitrary
infiniteList :: Arbitrary a => Gen [a]
infiniteList :: Gen [a]
infiniteList = Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
infiniteListOf Gen a
forall a. Arbitrary a => Gen a
arbitrary