{-# 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
, shrinkBoundedEnum
, 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 (..))
#if defined(MIN_VERSION_base)
#if MIN_VERSION_base(4,2,0)
import System.IO
( Newline(..)
, NewlineMode(..)
)
#endif
#endif
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.IntSet as IntSet
#if MIN_VERSION_containers(0,5,0)
import qualified Data.Map.Strict as Map
import qualified Data.IntMap.Strict as IntMap
#else
import qualified Data.Map as Map
import qualified Data.IntMap as IntMap
#endif
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 :: forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => Gen (f a)
arbitrary1 = Gen a -> Gen (f a)
forall a. 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 :: forall (f :: * -> *) a. (Arbitrary1 f, Arbitrary a) => f a -> [f a]
shrink1 = (a -> [a]) -> f a -> [f a]
forall a. (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 :: forall (f :: * -> * -> *) a b.
(Arbitrary2 f, Arbitrary a, Arbitrary b) =>
Gen (f a b)
arbitrary2 = Gen a -> Gen b -> Gen (f a b)
forall a b. 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 :: forall (f :: * -> * -> *) a b.
(Arbitrary2 f, Arbitrary a, Arbitrary b) =>
f a b -> [f a b]
shrink2 = (a -> [a]) -> (b -> [b]) -> f a b -> [f a b]
forall a b. (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 :: forall a.
(Generic a, RecursivelyShrink (Rep a), GSubterms (Rep a) a) =>
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 :: forall a. (Generic a, RecursivelyShrink (Rep a)) => 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
forall x. 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 a. Rep a a -> [Rep a a]
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 x. a -> Rep a x
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 :: forall (a :: k). (:*:) 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 (a :: k). 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 (a :: k). 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 :: forall (a :: k). (:+:) 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 (a :: k). 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 (a :: k). 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 :: forall (a :: k). 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 (a :: k). 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 :: forall (a :: k). 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 :: forall (a :: k). U1 a -> [U1 a]
grecursivelyShrink U1 a
U1 = []
instance RecursivelyShrink V1 where
grecursivelyShrink :: forall (a :: k). V1 a -> [V1 a]
grecursivelyShrink V1 a
_ = []
subterms :: (Generic a, GSubterms (Rep a) a) => a -> [a]
subterms :: forall a. (Generic a, GSubterms (Rep a) a) => 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 x. a -> Rep a x
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 GSubtermsIncl (K1 i a) b where
gSubtermsIncl :: K1 i a b -> [b]
gSubtermsIncl (K1 a
_) = []
#endif
instance (CoArbitrary a) => Arbitrary1 ((->) a) where
liftArbitrary :: forall a. 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 b. a -> Gen b -> Gen b
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 a. a -> Gen a
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. HasCallStack => [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 :: forall a. Gen a -> Gen (Maybe a)
liftArbitrary Gen a
arb = [(Int, Gen (Maybe a))] -> Gen (Maybe a)
forall a. HasCallStack => [(Int, Gen a)] -> Gen a
frequency [(Int
1, Maybe a -> Gen (Maybe a)
forall a. a -> Gen 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 :: forall a. (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 :: forall a b. 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. HasCallStack => [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 :: forall a b. (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 :: forall a. Gen a -> Gen (Either a a)
liftArbitrary = Gen a -> Gen a -> Gen (Either a a)
forall a b. Gen a -> Gen b -> Gen (Either 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
liftShrink :: forall a. (a -> [a]) -> Either a a -> [Either a a]
liftShrink = (a -> [a]) -> (a -> [a]) -> Either a a -> [Either a a]
forall a b. (a -> [a]) -> (b -> [b]) -> Either a b -> [Either 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
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 :: forall a. Gen a -> Gen [a]
liftArbitrary = Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
listOf
liftShrink :: forall a. (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 :: forall a. (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 a. [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 a. [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 = (Int -> Gen (Ratio a)) -> Gen (Ratio a)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (Ratio a)) -> Gen (Ratio a))
-> (Int -> Gen (Ratio a)) -> Gen (Ratio a)
forall a b. (a -> b) -> a -> b
$ \ Int
n -> do
Int
denom <- (Int, Int) -> Gen Int
chooseInt (Int
1, Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 Int
n)
let lb :: Int
lb | (Int -> a) -> Bool
forall a. Enum a => (Int -> a) -> Bool
isNonNegativeType Int -> a
fromI = Int
0
| Bool
otherwise = (-Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
denom)
fromI :: Int -> a
fromI = Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral
Int
numer <- (Int, Int) -> Gen Int
chooseInt (Int
lb, Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
denom)
Ratio a -> Gen (Ratio a)
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Ratio a -> Gen (Ratio a)) -> Ratio a -> Gen (Ratio a)
forall a b. (a -> b) -> a -> b
$ Int -> a
fromI Int
numer a -> a -> Ratio a
forall a. Integral a => a -> a -> Ratio a
% Int -> a
fromI Int
denom
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 :: forall a b. 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 :: forall a b. (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 :: forall a. Gen a -> Gen (a, a)
liftArbitrary = Gen a -> Gen a -> Gen (a, a)
forall a b. Gen a -> Gen b -> Gen (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
liftShrink :: forall a. (a -> [a]) -> (a, a) -> [(a, a)]
liftShrink = (a -> [a]) -> (a -> [a]) -> (a, a) -> [(a, a)]
forall a b. (a -> [a]) -> (b -> [b]) -> (a, b) -> [(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
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 a. a -> Gen a
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a. a -> Gen a
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a. a -> Gen a
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a. a -> Gen a
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a. a -> Gen a
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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 a b. Gen (a -> b) -> Gen a -> Gen b
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. HasCallStack => [(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] -> Gen Float
forall a. HasCallStack => [Gen a] -> Gen a
oneof
[ Gen Float
genFloat
, Int -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Float) -> Gen Int -> Gen Float
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Gen Int
forall a. Arbitrary a => Gen a
arbitrary :: Gen Int)
, Gen Float
smallDenominators
, Gen Float
uniform
, Gen Float
forall a. Fractional a => Gen a
arbitrarySizedFractional
]
where
smallDenominators :: Gen Float
smallDenominators = (Int -> Gen Float) -> Gen Float
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen Float) -> Gen Float)
-> (Int -> Gen Float) -> Gen Float
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
Int
i <- (Int, Int) -> Gen Int
chooseInt (Int
0, Int
n)
Float -> Gen Float
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Rational -> Float
forall a. Fractional a => Rational -> a
fromRational (Int -> Stream Rational -> Rational
forall a. Int -> Stream a -> a
streamNth Int
i Stream Rational
rationalUniverse))
uniform :: Gen Float
uniform = (Int -> Gen Float) -> Gen Float
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen Float) -> Gen Float)
-> (Int -> Gen Float) -> Gen Float
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
let n' :: Integer
n' = Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
n
Integer
b <- (Integer, Integer) -> Gen Integer
chooseInteger (Integer
1, Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
max Integer
1 Integer
n')
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)
Float -> Gen Float
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Float
forall a. Fractional a => Rational -> a
fromRational (Integer
a Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
b))
shrink :: Float -> [Float]
shrink = Float -> [Float]
forall a. RealFrac a => a -> [a]
shrinkDecimal
instance Arbitrary Double where
arbitrary :: Gen Double
arbitrary = [Gen Double] -> Gen Double
forall a. HasCallStack => [Gen a] -> Gen a
oneof
[ Gen Double
genDouble
, Int -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Double) -> Gen Int -> Gen Double
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Gen Int
forall a. Arbitrary a => Gen a
arbitrary :: Gen Int)
, Gen Double
smallDenominators
, Gen Double
uniform
, Gen Double
forall a. Fractional a => Gen a
arbitrarySizedFractional
]
where
smallDenominators :: Gen Double
smallDenominators = (Int -> Gen Double) -> Gen Double
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen Double) -> Gen Double)
-> (Int -> Gen Double) -> Gen Double
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
Int
i <- (Int, Int) -> Gen Int
chooseInt (Int
0, Int
n)
Double -> Gen Double
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Int -> Stream Rational -> Rational
forall a. Int -> Stream a -> a
streamNth Int
i Stream Rational
rationalUniverse))
uniform :: Gen Double
uniform = (Int -> Gen Double) -> Gen Double
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen Double) -> Gen Double)
-> (Int -> Gen Double) -> Gen Double
forall a b. (a -> b) -> a -> b
$ \Int
n -> do
let n' :: Integer
n' = Int -> Integer
forall a. Integral a => a -> Integer
toInteger Int
n
Integer
b <- (Integer, Integer) -> Gen Integer
chooseInteger (Integer
1, Integer -> Integer -> Integer
forall a. Ord a => a -> a -> a
max Integer
1 Integer
n')
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)
Double -> Gen Double
forall a. a -> Gen a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Double
forall a. Fractional a => Rational -> a
fromRational (Integer
a Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
b))
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 :: forall a. Gen a -> Gen (Map k a)
liftArbitrary = ([(k, a)] -> Map k a) -> Gen [(k, a)] -> Gen (Map k a)
forall a b. (a -> b) -> Gen a -> Gen b
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 a. Gen a -> Gen [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 a. Gen a -> Gen (k, a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: forall a. (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 a. (a -> [a]) -> [a] -> [[a]]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink ((a -> [a]) -> (k, a) -> [(k, a)]
forall a. (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 a b. (a -> b) -> Gen a -> Gen b
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 :: forall a. Gen a -> Gen (IntMap a)
liftArbitrary = ([(Int, a)] -> IntMap a) -> Gen [(Int, a)] -> Gen (IntMap a)
forall a b. (a -> b) -> Gen a -> Gen b
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 a. Gen a -> Gen [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 a. Gen a -> Gen (Int, a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: forall a. (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 a. (a -> [a]) -> [a] -> [[a]]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink ((a -> [a]) -> (Int, a) -> [(Int, a)]
forall a. (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 :: forall a. Gen a -> Gen (Seq a)
liftArbitrary = ([a] -> Seq a) -> Gen [a] -> Gen (Seq a)
forall a b. (a -> b) -> Gen a -> Gen b
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 a. Gen a -> Gen [a]
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: forall a. (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 a. (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 a. 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 :: forall a. 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)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Int -> Gen (Tree a)
go [Int]
pars
Tree a -> Gen (Tree a)
forall a. a -> Gen 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 -> [Tree 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 a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
Ordering
EQ -> [Int] -> Gen [Int]
forall a. a -> Gen a
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 :: forall a. (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 -> [Tree 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 a b. (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)]
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 a. (a -> [a]) -> [a] -> [[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 :: forall a. Gen a -> Gen (ZipList a)
liftArbitrary = ([a] -> ZipList a) -> Gen [a] -> Gen (ZipList a)
forall a b. (a -> b) -> Gen a -> Gen b
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 a. Gen a -> Gen [a]
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: forall a. (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 a. (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 :: forall a. Gen a -> Gen (Identity a)
liftArbitrary = (a -> Identity a) -> Gen a -> Gen (Identity a)
forall a b. (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Identity a
forall a. a -> Identity a
Identity
liftShrink :: forall a. (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 :: forall a b. 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 a b. (a -> b) -> Gen a -> Gen 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 :: forall a b.
(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 a b. (a -> b) -> [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 {k} a (b :: k). Constant a b -> a
getConstant
instance Arbitrary a => Arbitrary1 (Constant a) where
liftArbitrary :: forall a. Gen a -> Gen (Constant a a)
liftArbitrary = Gen a -> Gen a -> Gen (Constant a a)
forall a b. Gen a -> Gen b -> Gen (Constant 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
liftShrink :: forall a. (a -> [a]) -> Constant a a -> [Constant a a]
liftShrink = (a -> [a]) -> (a -> [a]) -> Constant a a -> [Constant a a]
forall a b.
(a -> [a]) -> (b -> [b]) -> Constant a b -> [Constant 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
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 a b. (a -> b) -> Gen a -> Gen 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 {k} a (b :: k). Constant a b -> a
getConstant
instance (Arbitrary1 f, Arbitrary1 g) => Arbitrary1 (Product f g) where
liftArbitrary :: forall a. 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 a. 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 a. Gen a -> Gen (g a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary Gen a
arb)
liftShrink :: forall a. (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 a. (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 a. (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 :: forall a. 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 a b. (a -> b) -> Gen a -> Gen b
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 a. Gen a -> Gen (f 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 a. Gen a -> Gen (g a)
forall (f :: * -> *) a. Arbitrary1 f => Gen a -> Gen (f a)
liftArbitrary
liftShrink :: forall a. (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 a. (a -> [a]) -> f a -> [f a]
forall (f :: * -> *) a. Arbitrary1 f => (a -> [a]) -> f a -> [f a]
liftShrink ((a -> [a]) -> g a -> [g a]
forall a. (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} {k2} (f :: k1 -> *) (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 :: forall a b. 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 a b. (a -> b) -> Gen a -> Gen 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 :: forall a b. (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 a b. (a -> b) -> [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 {k} a (b :: k). Const a b -> a
getConst
instance Arbitrary a => Arbitrary1 (Const a) where
liftArbitrary :: forall a. Gen a -> Gen (Const a a)
liftArbitrary = Gen a -> Gen a -> Gen (Const a a)
forall a b. Gen a -> Gen b -> Gen (Const 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
liftShrink :: forall a. (a -> [a]) -> Const a a -> [Const a a]
liftShrink = (a -> [a]) -> (a -> [a]) -> Const a a -> [Const a a]
forall a b. (a -> [a]) -> (b -> [b]) -> Const a b -> [Const 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
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 a b. (a -> b) -> Gen a -> Gen 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 {k} a (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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a b. (a -> b) -> Gen a -> Gen b
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 a. a -> Gen a
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 a. [a] -> 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. HasCallStack => [(Int, Gen a)] -> Gen a
frequency [(Int
1, ExitCode -> Gen ExitCode
forall a. a -> Gen a
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
_ = []
#if defined(MIN_VERSION_base)
#if MIN_VERSION_base(4,2,0)
instance Arbitrary Newline where
arbitrary :: Gen Newline
arbitrary = [Newline] -> Gen Newline
forall a. HasCallStack => [a] -> Gen a
elements [Newline
LF, Newline
CRLF]
shrink :: Newline -> [Newline]
shrink Newline
LF = []
shrink Newline
CRLF = [Newline
LF]
instance Arbitrary NewlineMode where
arbitrary :: Gen NewlineMode
arbitrary = Newline -> Newline -> NewlineMode
NewlineMode (Newline -> Newline -> NewlineMode)
-> Gen Newline -> Gen (Newline -> NewlineMode)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Newline
forall a. Arbitrary a => Gen a
arbitrary Gen (Newline -> NewlineMode) -> Gen Newline -> Gen NewlineMode
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Newline
forall a. Arbitrary a => Gen a
arbitrary
shrink :: NewlineMode -> [NewlineMode]
shrink (NewlineMode Newline
inNL Newline
outNL) = [Newline -> Newline -> NewlineMode
NewlineMode Newline
inNL' Newline
outNL' | (Newline
inNL', Newline
outNL') <- (Newline, Newline) -> [(Newline, Newline)]
forall a. Arbitrary a => a -> [a]
shrink (Newline
inNL, Newline
outNL)]
#endif
#endif
applyArbitrary2 :: (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r
applyArbitrary2 :: forall a b r. (Arbitrary a, Arbitrary b) => (a -> b -> r) -> Gen r
applyArbitrary2 a -> b -> r
f = (a -> b -> r) -> Gen a -> Gen b -> Gen r
forall a b c. (a -> b -> c) -> Gen a -> Gen b -> Gen c
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 :: forall a b c r.
(Arbitrary a, Arbitrary b, Arbitrary c) =>
(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 :: forall a b c d r.
(Arbitrary a, Arbitrary b, Arbitrary c, Arbitrary d) =>
(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 :: forall a. Integral a => Gen a
arbitrarySizedIntegral
| (Int -> a) -> Bool
forall a. Enum a => (Int -> a) -> Bool
isNonNegativeType Int -> a
fromI = Gen a
forall a. Integral a => Gen a
arbitrarySizedNatural
| Bool
otherwise = (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
fromI ((Int, Int) -> Gen Int
chooseInt (-Int
n, Int
n))
where
fromI :: Int -> a
fromI = Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral
isNonNegativeType :: Enum a => (Int -> a) -> Bool
isNonNegativeType :: forall a. Enum a => (Int -> a) -> Bool
isNonNegativeType Int -> a
fromI =
case a -> a -> [a]
forall a. Enum a => a -> a -> [a]
enumFromThen (Int -> a
fromI Int
1) (Int -> a
fromI Int
0) of
[a
_, a
_] -> Bool
True
[a]
_ -> Bool
False
arbitrarySizedNatural :: Integral a => Gen a
arbitrarySizedNatural :: forall a. Integral a => 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 :: forall a. Integral a => (Int -> a) -> Gen Int -> Gen a
inBounds Int -> a
fi Gen Int
g = (Int -> a) -> Gen Int -> Gen a
forall a b. (a -> b) -> Gen a -> Gen b
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 :: forall a. Fractional a => 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 -> do
Int
denom <- (Int, Int) -> Gen Int
chooseInt (Int
1, Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
1 Int
n)
Int
numer <- (Int, Int) -> Gen Int
chooseInt (-Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
denom, Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
*Int
denom)
a -> Gen a
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (a -> Gen a) -> a -> Gen a
forall a b. (a -> b) -> a -> b
$ Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
numer a -> a -> a
forall a. Fractional a => a -> a -> a
/ Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
denom
{-# INLINE withBounds #-}
withBounds :: Bounded a => (a -> a -> Gen a) -> Gen a
withBounds :: forall a. Bounded a => (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 :: forall a. (Bounded a, Integral a) => 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 :: forall a. (Bounded a, Random a) => 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 :: forall a. (Bounded a, Enum a) => 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 :: forall a. (Bounded a, Integral a) => 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 -> a
ilog2 t
1 = a
0
ilog2 t
n | t
n t -> t -> Bool
forall a. Ord a => a -> a -> Bool
> t
0 = a
1 a -> a -> a
forall a. Num a => a -> a -> a
+ t -> a
ilog2 (t
n t -> t -> t
forall a. Integral a => a -> a -> a
`div` t
2)
bits :: Int
bits = Integer -> Int
forall {t} {a}. (Num a, Integral t) => t -> a
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 a b. (a -> b) -> Gen a -> Gen b
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 :: forall a. a -> [a]
shrinkNothing a
_ = []
shrinkMap :: Arbitrary a => (a -> b) -> (b -> a) -> b -> [b]
shrinkMap :: forall a b. Arbitrary a => (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 :: forall a b. (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 :: forall a. Integral a => 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. HasCallStack => [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
shrinkBoundedEnum :: (Bounded a, Enum a, Eq a) => a -> [a]
shrinkBoundedEnum :: forall a. (Bounded a, Enum a, Eq a) => a -> [a]
shrinkBoundedEnum a
a
| a
a a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
forall a. Bounded a => a
minBound =
[]
| Bool
otherwise =
Int -> a
forall a. Enum a => Int -> a
toEnum (Int -> a) -> [Int] -> [a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> Bool) -> [Int] -> [Int]
forall a. (a -> Bool) -> [a] -> [a]
filter (Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
minBoundInt) (Int -> [Int]
forall a. Integral a => a -> [a]
shrinkIntegral (Int -> [Int]) -> Int -> [Int]
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a. Enum a => a -> Int
fromEnum a
a)
where
minBoundInt :: Int
minBoundInt :: Int
minBoundInt = a -> Int
forall a. Enum a => a -> Int
fromEnum (a
forall a. Bounded a => a
minBound a -> a -> a
forall a. a -> a -> a
`asTypeOf` a
a)
shrinkRealFrac :: RealFrac a => a -> [a]
shrinkRealFrac :: forall a. RealFrac a => 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]
: (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
1000) [a]
numbers
| a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0 Bool -> Bool -> Bool
&& 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]
numbers
| 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 b. Integral b => a -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate a
x) [Integer] -> [Integer] -> [Integer]
forall a. [a] -> [a] -> [a]
++ [a -> Integer
forall b. Integral b => a -> b
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 b. Integral b => Rational -> b
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)
numbers :: [a]
numbers = (a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate (a -> a -> a
forall a. Num a => a -> a -> a
*a
2) a
1
shrinkDecimal :: RealFrac a => a -> [a]
shrinkDecimal :: forall a. RealFrac a => 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]
: (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
takeWhile (a -> a -> Bool
forall a. Ord a => a -> a -> Bool
< a
1000) [a]
numbers
| 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]
numbers
| 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]
shrinkDecimal (a -> a
forall a. Num a => a -> a
negate a
x))
| 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 b. Integral b => Rational -> b
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 ]
where
numbers :: [a]
numbers = [[a]] -> [a]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[a]] -> [a]) -> [[a]] -> [a]
forall a b. (a -> b) -> a -> b
$ ([a] -> [a]) -> [a] -> [[a]]
forall a. (a -> a) -> a -> [a]
iterate ((a -> a) -> [a] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map (a -> a -> a
forall a. Num a => a -> a -> a
*a
10)) ((Integer -> a) -> [Integer] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Integer -> a
forall a. Num a => Integer -> a
fromInteger [Integer
1..Integer
9])
#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 :: forall a b.
(Generic a, GCoArbitrary (Rep a)) =>
a -> Gen b -> Gen b
genericCoarbitrary = Rep a Any -> Gen b -> Gen b
forall a b. Rep a a -> 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 x. a -> Rep a x
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 :: forall (a :: k) b. 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 :: forall (a :: k) b. (:*:) f g a -> Gen b -> Gen b
gCoarbitrary (f a
l :*: g a
r) = f a -> Gen b -> Gen b
forall (a :: k) b. 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 (a :: k) b. 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 :: forall (a :: k) b. (:+:) 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 (a :: k) b. 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 (a :: k) b. 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 :: forall (a :: k) b. M1 i c f a -> Gen b -> Gen b
gCoarbitrary (M1 f a
x) = f a -> Gen b -> Gen b
forall (a :: k) b. 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 :: forall (a :: k) b. K1 i a a -> Gen b -> Gen b
gCoarbitrary (K1 a
x) = a -> Gen b -> Gen b
forall b. 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)
>< :: forall 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 :: forall b. (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 b. [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 :: forall b. () -> Gen b -> Gen b
coarbitrary ()
_ = Gen b -> Gen b
forall a. a -> a
id
instance CoArbitrary Bool where
coarbitrary :: forall b. 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 :: forall b. 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 :: forall b. 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 b. 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 :: forall b. 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 b. 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 b. 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 :: forall b. [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 b. (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 :: forall b. Ratio a -> Gen b -> Gen b
coarbitrary Ratio a
r = (a, a) -> Gen b -> Gen b
forall b. (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 :: forall b. 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 :: forall b. Complex a -> Gen b -> Gen b
coarbitrary (a
x :+ a
y) = a -> Gen b -> Gen b
forall b. 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 b. 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 :: forall b. (a, b) -> Gen b -> Gen b
coarbitrary (a
x,b
y) = a -> Gen b -> Gen b
forall b. 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 b. 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 :: forall b. (a, b, c) -> Gen b -> Gen b
coarbitrary (a
x,b
y,c
z) = a -> Gen b -> Gen b
forall b. 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 b. 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 b. 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 :: forall b. (a, b, c, d) -> Gen b -> Gen b
coarbitrary (a
x,b
y,c
z,d
v) = a -> Gen b -> Gen b
forall b. 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 b. 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 b. 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 b. 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 :: forall b. (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 b. 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 b. 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 b. 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 b. 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 b. e -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary e
w
instance CoArbitrary Integer where
coarbitrary :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. Char -> Gen b -> Gen b
coarbitrary = Int -> Gen b -> Gen b
forall b. 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 :: forall b. 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 :: forall b. 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 :: forall b. Set a -> Gen b -> Gen b
coarbitrary = [a] -> Gen b -> Gen b
forall b. [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 :: forall b. Map k v -> Gen b -> Gen b
coarbitrary = [(k, v)] -> Gen b -> Gen b
forall b. [(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 :: forall b. IntSet -> Gen b -> Gen b
coarbitrary = [Int] -> Gen b -> Gen b
forall b. [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 :: forall b. IntMap a -> Gen b -> Gen b
coarbitrary = [(Int, a)] -> Gen b -> Gen b
forall b. [(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 :: forall b. Seq a -> Gen b -> Gen b
coarbitrary = [a] -> Gen b -> Gen b
forall b. [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 a. Seq a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList
instance CoArbitrary a => CoArbitrary (Tree.Tree a) where
coarbitrary :: forall b. Tree a -> Gen b -> Gen b
coarbitrary (Tree.Node a
val [Tree a]
forest) = a -> Gen b -> Gen b
forall b. 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
. [Tree a] -> Gen b -> Gen b
forall b. [Tree a] -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary [Tree a]
forest
instance CoArbitrary a => CoArbitrary (ZipList a) where
coarbitrary :: forall b. ZipList a -> Gen b -> Gen b
coarbitrary = [a] -> Gen b -> Gen b
forall b. [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 :: forall b. Identity a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall b. 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 :: forall b. Constant a b -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall b. 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 {k} a (b :: k). Constant a b -> a
getConstant
#endif
instance CoArbitrary a => CoArbitrary (Const a b) where
coarbitrary :: forall b. Const a b -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall b. 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 {k} a (b :: k). Const a b -> a
getConst
instance CoArbitrary a => CoArbitrary (Monoid.Dual a) where
coarbitrary :: forall b. Dual a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall b. 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 :: forall b. Endo a -> Gen b -> Gen b
coarbitrary = (a -> a) -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
forall b. (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 :: forall b. All -> Gen b -> Gen b
coarbitrary = Bool -> Gen b -> Gen b
forall b. 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 :: forall b. Any -> Gen b -> Gen b
coarbitrary = Bool -> Gen b -> Gen b
forall b. 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 :: forall b. Sum a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall b. 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 :: forall b. Product a -> Gen b -> Gen b
coarbitrary = a -> Gen b -> Gen b
forall b. 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 :: forall b. First a -> Gen b -> Gen b
coarbitrary = Maybe a -> Gen b -> Gen b
forall b. 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 :: forall b. Last a -> Gen b -> Gen b
coarbitrary = Maybe a -> Gen b -> Gen b
forall b. 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 :: forall b. Alt f a -> Gen b -> Gen b
coarbitrary = f a -> Gen b -> Gen b
forall b. 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 :: forall b. Version -> Gen b -> Gen b
coarbitrary (Version [Int]
a [[Char]]
b) = ([Int], [[Char]]) -> Gen b -> Gen b
forall b. ([Int], [[Char]]) -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary ([Int]
a, [[Char]]
b)
#if defined(MIN_VERSION_base)
#if MIN_VERSION_base(4,2,0)
instance CoArbitrary Newline where
coarbitrary :: forall b. Newline -> Gen b -> Gen b
coarbitrary Newline
LF = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
0
coarbitrary Newline
CRLF = Integer -> Gen b -> Gen b
forall n a. Integral n => n -> Gen a -> Gen a
variant Integer
1
instance CoArbitrary NewlineMode where
coarbitrary :: forall b. NewlineMode -> Gen b -> Gen b
coarbitrary (NewlineMode Newline
inNL Newline
outNL) = Newline -> Gen b -> Gen b
forall b. Newline -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Newline
inNL (Gen b -> Gen b) -> (Gen b -> Gen b) -> Gen b -> Gen b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Newline -> Gen b -> Gen b
forall b. Newline -> Gen b -> Gen b
forall a b. CoArbitrary a => a -> Gen b -> Gen b
coarbitrary Newline
outNL
#endif
#endif
coarbitraryIntegral :: Integral a => a -> Gen b -> Gen b
coarbitraryIntegral :: forall n a. Integral n => n -> Gen a -> Gen a
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 :: forall a b. Real a => a -> Gen b -> Gen b
coarbitraryReal a
x = Rational -> Gen b -> Gen b
forall b. 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 :: forall a b. Show a => a -> Gen b -> Gen b
coarbitraryShow a
x = [Char] -> Gen b -> Gen b
forall b. [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 :: forall a b. Enum a => 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 :: forall a. Arbitrary a => 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 :: forall a. (Ord a, Arbitrary a) => Gen [a]
orderedList = [a] -> [a]
forall a. Ord a => [a] -> [a]
sort ([a] -> [a]) -> Gen [a] -> Gen [a]
forall a b. (a -> b) -> Gen a -> Gen b
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 :: forall a. Arbitrary a => Gen [a]
infiniteList = Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
infiniteListOf Gen a
forall a. Arbitrary a => Gen a
arbitrary
infixr 5 :<
data Stream a = !a :< Stream a
streamNth :: Int -> Stream a -> a
streamNth :: forall a. Int -> Stream a -> a
streamNth Int
n (a
x :< Stream a
xs) | Int
n Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
<= Int
0 = a
x
| Bool
otherwise = Int -> Stream a -> a
forall a. Int -> Stream a -> a
streamNth (Int
n Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) Stream a
xs
rationalUniverse :: Stream Rational
rationalUniverse :: Stream Rational
rationalUniverse = Rational
0 Rational -> Stream Rational -> Stream Rational
forall a. a -> Stream a -> Stream a
:< Rational
1 Rational -> Stream Rational -> Stream Rational
forall a. a -> Stream a -> Stream a
:< (-Rational
1) Rational -> Stream Rational -> Stream Rational
forall a. a -> Stream a -> Stream a
:< Stream Rational -> Stream Rational
forall {a}. Fractional a => Stream a -> Stream a
go Stream Rational
leftSideStream
where
go :: Stream a -> Stream a
go (a
x :< Stream a
xs) =
let nx :: a
nx = -a
x
rx :: a
rx = a -> a
forall a. Fractional a => a -> a
recip a
x
nrx :: a
nrx = -a
rx
in a
nx a -> Stream a -> Stream a
forall a b. a -> b -> b
`seq` a
rx a -> Stream a -> Stream a
forall a b. a -> b -> b
`seq` a
nrx a -> Stream a -> Stream a
forall a b. a -> b -> b
`seq` (a
x a -> Stream a -> Stream a
forall a. a -> Stream a -> Stream a
:< a
rx a -> Stream a -> Stream a
forall a. a -> Stream a -> Stream a
:< a
nx a -> Stream a -> Stream a
forall a. a -> Stream a -> Stream a
:< a
nrx a -> Stream a -> Stream a
forall a. a -> Stream a -> Stream a
:< Stream a -> Stream a
go Stream a
xs)
leftSideStream :: Stream Rational
leftSideStream :: Stream Rational
leftSideStream = (Integer
1 Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
2) Rational -> Stream Rational -> Stream Rational
forall a. a -> Stream a -> Stream a
:< Stream Rational -> Stream Rational
forall {a}. Integral a => Stream (Ratio a) -> Stream (Ratio a)
go Stream Rational
leftSideStream
where
go :: Stream (Ratio a) -> Stream (Ratio a)
go (Ratio a
x :< Stream (Ratio a)
xs) =
Ratio a
lChild Ratio a -> Stream (Ratio a) -> Stream (Ratio a)
forall a b. a -> b -> b
`seq` Ratio a
rChild Ratio a -> Stream (Ratio a) -> Stream (Ratio a)
forall a b. a -> b -> b
`seq`
(Ratio a
lChild Ratio a -> Stream (Ratio a) -> Stream (Ratio a)
forall a. a -> Stream a -> Stream a
:< Ratio a
rChild Ratio a -> Stream (Ratio a) -> Stream (Ratio a)
forall a. a -> Stream a -> Stream a
:< Stream (Ratio a) -> Stream (Ratio a)
go Stream (Ratio a)
xs)
where
nd :: a
nd = Ratio a -> a
forall a. Ratio a -> a
numerator Ratio a
x a -> a -> a
forall a. Num a => a -> a -> a
+ Ratio a -> a
forall a. Ratio a -> a
denominator Ratio a
x
lChild :: Ratio a
lChild = Ratio a -> a
forall a. Ratio a -> a
numerator Ratio a
x a -> a -> Ratio a
forall a. Integral a => a -> a -> Ratio a
% a
nd
rChild :: Ratio a
rChild = a
nd a -> a -> Ratio a
forall a. Integral a => a -> a -> Ratio a
% Ratio a -> a
forall a. Ratio a -> a
denominator Ratio a
x