{-|

    @GenValidity@ exists to make tests involving @Validity@ types easier and speed
    up the generation of data for them.

    Let's use the example from @Data.Validity@ again: A datatype that represents
    primes.
    To implement tests for this datatype, we would have to be able to generate
    both primes and non-primes. We could do this with
    @(Prime <$> arbitrary) `suchThat` isValid@
    but this is tedious and inefficient.

    The @GenValid@ type class allows you to specify how to (efficiently)
    generate valid data of the given type to allow for easier and quicker testing.
    Just instantiating @GenUnchecked@ already gives you access to a default instance
    of @GenValid@ and @GenInvalid@ but writing custom implementations of these functions
    may speed up the generation of data.

    For example, to generate primes, we don't have to consider even numbers other
    than 2. A more efficient implementation could then look as follows:

    > instance GenUnchecked Prime where
    >     genUnchecked = Prime <$> arbitrary

    > instance GenValid Prime where
    >     genValid = Prime <$>
    >        (oneof
    >          [ pure 2
    >          , ((\y -> 2 * abs y + 1) <$> arbitrary) `suchThat` isPrime)
    >          ])


    Typical examples of tests involving validity could look as follows:

    > it "succeeds when given valid input" $ do
    >     forAllValid $ \input ->
    >         myFunction input `shouldSatisfy` isRight

    > it "produces valid output when it succeeds" $ do
    >     forAllUnchecked $ \input ->
    >         case myFunction input of
    >             Nothing -> return () -- Can happen
    >             Just output -> output `shouldSatisfy` isValid

    Definitely also look at the genvalidity-property and genvalidity-hspec packages
    for more info on how to use this package.
    -}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE CPP #-}
#if __GLASGOW_HASKELL__ >= 710
#define OVERLAPPING_ {-# OVERLAPPING #-}
#else
{-# LANGUAGE OverlappingInstances  #-}
#define OVERLAPPING_
#endif
#if MIN_VERSION_base(4,9,0)
{-# OPTIONS_GHC -fno-warn-redundant-constraints #-}
#endif

module Data.GenValidity
    ( GenUnchecked(..)
    , GenValid(..)
    , GenInvalid(..)

    -- * Helper functions
    , genValidStructurally
    , genValidStructurallyWithoutExtraChecking
    , shrinkValidStructurally
    , shrinkValidStructurallyWithoutExtraFiltering
    , module Data.GenValidity.Utils

    -- * Strange, possibly useful functions
    , genUtf16SurrogateCodePoint

    -- * Re-exports
    , module Data.Validity

    -- * The Generics magic
    , genericGenUnchecked
    , GGenUnchecked(..)
    , genericShrinkUnchecked
    , uncheckedRecursivelyShrink
    , GUncheckedRecursivelyShrink(..)
    , uncheckedSubterms
    , GUncheckedSubterms(..)
    , GUncheckedSubtermsIncl(..)
    , GGenValid(..)
    , GValidRecursivelyShrink(..)
    , structurallyValidSubterms
    , GValidSubterms(..)
    , GValidSubtermsIncl(..)
    ) where

import Data.Validity

import Data.Fixed (Fixed(..), HasResolution)
#if MIN_VERSION_base(4,9,0)
import Data.List.NonEmpty (NonEmpty((:|)))
#endif
#if MIN_VERSION_base(4,8,0)
import Data.Word (Word64)
import GHC.Word (Word8(..), Word16(..), Word32(..), Word(..))
#else
import Data.Word (Word, Word64)
import GHC.Word (Word8(..), Word16(..), Word32(..), Word(..))
#endif
import Data.Int (Int64)
import GHC.Int (Int8(..), Int16(..), Int32(..), Int(..))
import Data.Char (chr)
import Data.Ratio ((%))
import GHC.Generics
import GHC.Real (Ratio(..))
import Control.Monad (guard)

import Test.QuickCheck hiding (Fixed)

#if MIN_VERSION_base(4,8,0)
import GHC.Natural
#else
import Control.Applicative ((<*>), (<$>), pure)
#endif

import Data.GenValidity.Utils

{-# ANN module "HLint: ignore Reduce duplication" #-}

-- | A class of types for which truly arbitrary values can be generated.
--
-- === How to instantiate 'GenUnchecked'
--
-- __Step 1__: Try to instantiate 'GenUnchecked' via 'Generic'.
--         __this is probably what you want__
--
-- An instance of this class can be made automatically if the type in question
-- has a 'Generic' instance. This instance will try to use 'genUnchecked' to
-- generate all structural sub-parts of the value that is being generated.
--
-- Example:
--
-- > {-# LANGUAGE DeriveGeneric #-}
-- >
-- > data MyType = MyType Rational String
-- >     deriving (Show, Eq, Generic)
-- >
-- > instance GenUnchecked MyType
--
-- generates something like:
--
-- > instance GenUnchecked MyType where
-- >     genUnchecked = MyType <$> genUnchecked <*> genUnchecked
--
-- If this is not possible because there is no 'GenUnchecked' instance available for one of the
-- sub-parts of your type, __then do not instantiate 'GenUnchecked' for your type__.
-- Just continue with 'GenValid' instead.
--
-- __Step 2__: If an instatiation via 'Generic' is not possible, then you should emulate what
--         'genericGenUnchecked' does.
--         This means that all sub-parts should be  generated using 'genUnchecked'.
--         Make sure to generate any possible value, valid or not, that can exist at runtime
--         even when taking the existence of 'Unsafe.Coerce.unsafeCoerce' into account.
--
-- === Warning: Invalid values can be funky
--
-- Some types have serious validity constraints. See 'Rational' for example.
-- These can behave very strangely when they are not valid.
-- In that case, __do not override 'GenUnchecked' such that 'genUnchecked' only generates valid values__.
-- In that case, do not override 'genUnchecked' at all.
-- Instead, use 'genValid' from 'GenValid' (see below) instead and consider not instantiating 'GenUnchecked' at all.
class GenUnchecked a where
    genUnchecked :: Gen a
    default genUnchecked :: (Generic a, GGenUnchecked (Rep a)) =>
        Gen a
    genUnchecked = Gen a
forall a. (Generic a, GGenUnchecked (Rep a)) => Gen a
genericGenUnchecked

    shrinkUnchecked :: a -> [a]
    default shrinkUnchecked ::
        (Generic a, GUncheckedRecursivelyShrink (Rep a), GUncheckedSubterms (Rep a) a) =>
        a -> [a]
    shrinkUnchecked = a -> [a]
forall a.
(Generic a, GUncheckedRecursivelyShrink (Rep a),
 GUncheckedSubterms (Rep a) a) =>
a -> [a]
genericShrinkUnchecked

-- | A class of types for which valid values can be generated.
--
-- === How to instantiate 'GenValid'
--
-- __Step 1__: Try to instantiate 'GenValid' without overriding any functions.
--             This is only possible if your type has a 'GenUnchecked' instance.
--             If it doesn't, go to step 2.
--             It is possible that, if few values are valid or if validity
--             checking is expensive, that the resulting generator is too slow.
--             In that case, go to Step 2.
--
-- __Step 2__: Try to instantiate 'GenValid' using the helper functions via 'Generic'
--             This involves using 'genValidStructurally' to override 'genValid' and
--             using 'shrinkValidStructurally' to override 'shrinkValid'.
--             __Every time you override 'genValid', you should also override 'shrinkValid'__
--
-- __Step 3__: If the above is not possible due to lack of a 'Generic' instance,
--             then you should emulate what 'genValidStructurally' does.
--             This means that all sub-parts should be generated using 'genValid'.
--             Make sure to generate any possible valid value, but only valid values.
--
-- === A note about 'Arbitrary'
--
-- If you also write @Arbitrary@ instances for @GenValid@ types, it may be
-- best to simply use
--
-- > arbitrary = genValid
-- > shrink = shrinkValid
class Validity a => GenValid a where
    -- | Generate a valid datum, this should cover all possible valid values in
    -- the type
    --
    -- The default implementation is as follows:
    --
    -- >  genValid = genUnchecked `suchThat` isValid
    --
    -- To speed up testing, it may be a good idea to implement this yourself.
    -- If you do, make sure that it is possible to generate all possible valid
    -- data, otherwise your testing may not cover all cases.
    genValid :: Gen a
    default genValid :: GenUnchecked a => Gen a
    genValid = Gen a
forall a. GenUnchecked a => Gen a
genUnchecked Gen a -> (a -> Bool) -> Gen a
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` a -> Bool
forall a. Validity a => a -> Bool
isValid

    -- | Shrink a valid value.
    --
    -- The default implementation is as follows:
    --
    -- >  shrinkValid = filter isValid . shrinkUnchecked
    --
    -- It is important that this shrinking function only shrinks values to valid values.
    -- If `shrinkValid` ever shrinks a value to an invalid value, the test that is being shrunk for
    -- might fail for a different reason than for the reason that it originally failed.
    -- This would lead to very confusing error messages.
    shrinkValid :: a -> [a]
    default shrinkValid :: GenUnchecked a => a -> [a]
    shrinkValid = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter a -> Bool
forall a. Validity a => a -> Bool
isValid ([a] -> [a]) -> (a -> [a]) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

-- | A class of types for which invalid values can be generated.
--
-- === How to instantiate 'GenInvalid'
--
-- __Step 1__: Realise that you probably do not want to.
--             It makes no sense, and serves no purpose, to instantiate 'GenInvalid' for types
--             which contain no invalid values. (In fact, the default implementation will go into
--             an infinite loop for such types.)
--             You should only instantiate 'GenInvalid' if you explicitly want to use it
--             to write tests that deal with invalid values, or if you are writing a container
--             for parametric values.
--
-- __Step 2__: Instantiate 'GenInvalid' without overriding any functions.
class Validity a => GenInvalid a where
    genInvalid :: Gen a
    -- | Generate an invalid datum, this should cover all possible invalid
    -- values
    --
    -- > genInvalid = genUnchecked `suchThat` isInvalid
    --
    -- To speed up testing, it may be a good idea to implement this yourself.
    -- If you do, make sure that it is possible to generate all possible
    -- invalid data, otherwise your testing may not cover all cases.
    default genInvalid :: GenUnchecked a => Gen a
    genInvalid = Gen a
forall a. GenUnchecked a => Gen a
genUnchecked Gen a -> (a -> Bool) -> Gen a
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` a -> Bool
forall a. Validity a => a -> Bool
isInvalid

    shrinkInvalid :: a -> [a]
    default shrinkInvalid :: GenUnchecked a => a -> [a]
    shrinkInvalid = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter a -> Bool
forall a. Validity a => a -> Bool
isInvalid ([a] -> [a]) -> (a -> [a]) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance (GenUnchecked a, GenUnchecked b) => GenUnchecked (a, b) where
    genUnchecked :: Gen (a, b)
genUnchecked =
        (Int -> Gen (a, b)) -> Gen (a, b)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b)) -> Gen (a, b))
-> (Int -> Gen (a, b)) -> Gen (a, b)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s) <- Int -> Gen (Int, Int)
genSplit Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
            (a, b) -> Gen (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b)
    shrinkUnchecked :: (a, b) -> [(a, b)]
shrinkUnchecked (a :: a
a, b :: b
b) = ((,) (a -> b -> (a, b)) -> [a] -> [b -> (a, b)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [a]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked a
a [b -> (a, b)] -> [b] -> [(a, b)]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> b -> [b]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked b
b)
      [(a, b)] -> [(a, b)] -> [(a, b)]
forall a. [a] -> [a] -> [a]
++ [ (a
a', b
b) | a
a' <- a -> [a]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked a
a ]
      [(a, b)] -> [(a, b)] -> [(a, b)]
forall a. [a] -> [a] -> [a]
++ [ (a
a, b
b') | b
b' <- b -> [b]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked b
b ]

instance (GenValid a, GenValid b) => GenValid (a, b) where
    genValid :: Gen (a, b)
genValid =
        (Int -> Gen (a, b)) -> Gen (a, b)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b)) -> Gen (a, b))
-> (Int -> Gen (a, b)) -> Gen (a, b)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s) <- Int -> Gen (Int, Int)
genSplit Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenValid a => Gen a
genValid
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenValid a => Gen a
genValid
            (a, b) -> Gen (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b)
    shrinkValid :: (a, b) -> [(a, b)]
shrinkValid = (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)]
forall a b. (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)]
shrinkTuple a -> [a]
forall a. GenValid a => a -> [a]
shrinkValid b -> [b]
forall a. GenValid a => a -> [a]
shrinkValid

instance (GenUnchecked a, GenInvalid a, GenUnchecked b, GenInvalid b) => GenInvalid (a, b) where
    genInvalid :: Gen (a, b)
genInvalid =
        (Int -> Gen (a, b)) -> Gen (a, b)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b)) -> Gen (a, b))
-> (Int -> Gen (a, b)) -> Gen (a, b)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s) <- Int -> Gen (Int, Int)
genSplit Int
n
            [Gen (a, b)] -> Gen (a, b)
forall a. [Gen a] -> Gen a
oneof
                [ do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenInvalid a => Gen a
genInvalid
                     (a, b) -> Gen (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenInvalid a => Gen a
genInvalid
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b) -> Gen (a, b)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b)
                ]

instance (GenUnchecked a, GenUnchecked b) => GenUnchecked (Either a b) where
    genUnchecked :: Gen (Either a b)
genUnchecked = [Gen (Either a b)] -> Gen (Either a b)
forall a. [Gen a] -> Gen a
oneof [a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> Gen a -> Gen (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenUnchecked a => Gen a
genUnchecked, b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> Gen b -> Gen (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen b
forall a. GenUnchecked a => Gen a
genUnchecked]
    shrinkUnchecked :: Either a b -> [Either a b]
shrinkUnchecked (Left a :: a
a) = a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> [a] -> [Either a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [a]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked a
a
    shrinkUnchecked (Right b :: b
b) = b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> [b] -> [Either a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> [b]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked b
b

instance (GenValid a, GenValid b) => GenValid (Either a b) where
    genValid :: Gen (Either a b)
genValid = [Gen (Either a b)] -> Gen (Either a b)
forall a. [Gen a] -> Gen a
oneof [a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> Gen a -> Gen (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenValid a => Gen a
genValid, b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> Gen b -> Gen (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen b
forall a. GenValid a => Gen a
genValid]
    shrinkValid :: Either a b -> [Either a b]
shrinkValid (Left a :: a
a) = a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> [a] -> [Either a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [a]
forall a. GenValid a => a -> [a]
shrinkValid a
a
    shrinkValid (Right b :: b
b) = b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> [b] -> [Either a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> [b]
forall a. GenValid a => a -> [a]
shrinkValid b
b

-- | This instance ensures that the generated tupse contains at least one invalid element. The other element is unchecked.
instance (GenInvalid a, GenInvalid b) => GenInvalid (Either a b) where
    genInvalid :: Gen (Either a b)
genInvalid = [Gen (Either a b)] -> Gen (Either a b)
forall a. [Gen a] -> Gen a
oneof [a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> Gen a -> Gen (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenInvalid a => Gen a
genInvalid, b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> Gen b -> Gen (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen b
forall a. GenInvalid a => Gen a
genInvalid]
    shrinkInvalid :: Either a b -> [Either a b]
shrinkInvalid (Left v :: a
v) = a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> [a] -> [Either a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [a]
forall a. GenInvalid a => a -> [a]
shrinkInvalid a
v
    shrinkInvalid (Right v :: b
v) = b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> [b] -> [Either a b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> [b]
forall a. GenInvalid a => a -> [a]
shrinkInvalid b
v

instance (GenUnchecked a, GenUnchecked b, GenUnchecked c) =>
         GenUnchecked (a, b, c) where
    genUnchecked :: Gen (a, b, c)
genUnchecked =
        (Int -> Gen (a, b, c)) -> Gen (a, b, c)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c)) -> Gen (a, b, c))
-> (Int -> Gen (a, b, c)) -> Gen (a, b, c)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t) <- Int -> Gen (Int, Int, Int)
genSplit3 Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
            c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
            (a, b, c) -> Gen (a, b, c)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c)
    shrinkUnchecked :: (a, b, c) -> [(a, b, c)]
shrinkUnchecked (a :: a
a, b :: b
b, c :: c
c) =
        [ (a
a', b
b', c
c')
        | (a' :: a
a', (b' :: b
b', c' :: c
c')) <- (a, (b, c)) -> [(a, (b, c))]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked (a
a, (b
b, c
c))
        ]

instance (GenValid a, GenValid b, GenValid c) => GenValid (a, b, c) where
    genValid :: Gen (a, b, c)
genValid =
        (Int -> Gen (a, b, c)) -> Gen (a, b, c)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c)) -> Gen (a, b, c))
-> (Int -> Gen (a, b, c)) -> Gen (a, b, c)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t) <- Int -> Gen (Int, Int, Int)
genSplit3 Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenValid a => Gen a
genValid
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenValid a => Gen a
genValid
            c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenValid a => Gen a
genValid
            (a, b, c) -> Gen (a, b, c)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c)
    shrinkValid :: (a, b, c) -> [(a, b, c)]
shrinkValid (a :: a
a, b :: b
b, c :: c
c) =
        [ (a
a', b
b', c
c')
        | (a' :: a
a', (b' :: b
b', c' :: c
c')) <- (a, (b, c)) -> [(a, (b, c))]
forall a. GenValid a => a -> [a]
shrinkValid (a
a, (b
b, c
c))
        ]

-- | This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.
instance ( GenUnchecked a, GenUnchecked b, GenUnchecked c
         , GenInvalid a, GenInvalid b, GenInvalid c) =>
         GenInvalid (a, b, c) where
    genInvalid :: Gen (a, b, c)
genInvalid =
        (Int -> Gen (a, b, c)) -> Gen (a, b, c)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c)) -> Gen (a, b, c))
-> (Int -> Gen (a, b, c)) -> Gen (a, b, c)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t) <- Int -> Gen (Int, Int, Int)
genSplit3 Int
n
            [Gen (a, b, c)] -> Gen (a, b, c)
forall a. [Gen a] -> Gen a
oneof
                [ do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenInvalid a => Gen a
genInvalid
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c) -> Gen (a, b, c)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenInvalid a => Gen a
genInvalid
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c) -> Gen (a, b, c)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenInvalid a => Gen a
genInvalid
                     (a, b, c) -> Gen (a, b, c)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c)
                ]

instance (GenUnchecked a, GenUnchecked b, GenUnchecked c, GenUnchecked d) =>
         GenUnchecked (a, b, c, d) where
    genUnchecked :: Gen (a, b, c, d)
genUnchecked =
        (Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d))
-> (Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t, u :: Int
u) <- Int -> Gen (Int, Int, Int, Int)
genSplit4 Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
            c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
            d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
            (a, b, c, d) -> Gen (a, b, c, d)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d)
    shrinkUnchecked :: (a, b, c, d) -> [(a, b, c, d)]
shrinkUnchecked (a :: a
a, b :: b
b, c :: c
c, d :: d
d) =
        [ (a
a', b
b', c
c', d
d')
        | (a' :: a
a', (b' :: b
b', (c' :: c
c', d' :: d
d'))) <- (a, (b, (c, d))) -> [(a, (b, (c, d)))]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked (a
a, (b
b, (c
c, d
d)))
        ]

instance (GenValid a, GenValid b, GenValid c, GenValid d) =>
         GenValid (a, b, c, d) where
    genValid :: Gen (a, b, c, d)
genValid =
        (Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d))
-> (Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t, u :: Int
u) <- Int -> Gen (Int, Int, Int, Int)
genSplit4 Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenValid a => Gen a
genValid
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenValid a => Gen a
genValid
            c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenValid a => Gen a
genValid
            d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenValid a => Gen a
genValid
            (a, b, c, d) -> Gen (a, b, c, d)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d)
    shrinkValid :: (a, b, c, d) -> [(a, b, c, d)]
shrinkValid (a :: a
a, b :: b
b, c :: c
c, d :: d
d) =
        [ (a
a', b
b', c
c', d
d')
        | (a' :: a
a', (b' :: b
b', (c' :: c
c', d' :: d
d'))) <- (a, (b, (c, d))) -> [(a, (b, (c, d)))]
forall a. GenValid a => a -> [a]
shrinkValid (a
a, (b
b, (c
c, d
d)))
        ]

-- | This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.
instance ( GenUnchecked a, GenUnchecked b, GenUnchecked c, GenUnchecked d
         , GenInvalid a, GenInvalid b, GenInvalid c, GenInvalid d) =>
         GenInvalid (a, b, c, d) where
    genInvalid :: Gen (a, b, c, d)
genInvalid =
        (Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d))
-> (Int -> Gen (a, b, c, d)) -> Gen (a, b, c, d)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t, u :: Int
u) <- Int -> Gen (Int, Int, Int, Int)
genSplit4 Int
n
            [Gen (a, b, c, d)] -> Gen (a, b, c, d)
forall a. [Gen a] -> Gen a
oneof
                [ do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenInvalid a => Gen a
genInvalid
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c, d) -> Gen (a, b, c, d)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenInvalid a => Gen a
genInvalid
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c, d) -> Gen (a, b, c, d)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenInvalid a => Gen a
genInvalid
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c, d) -> Gen (a, b, c, d)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenInvalid a => Gen a
genInvalid
                     (a, b, c, d) -> Gen (a, b, c, d)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d)
                ]

instance (GenUnchecked a, GenUnchecked b, GenUnchecked c, GenUnchecked d, GenUnchecked e) =>
         GenUnchecked (a, b, c, d, e) where
    genUnchecked :: Gen (a, b, c, d, e)
genUnchecked =
        (Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e))
-> (Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t, u :: Int
u, v :: Int
v) <- Int -> Gen (Int, Int, Int, Int, Int)
genSplit5 Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
            c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
            d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
            e
e <- Int -> Gen e -> Gen e
forall a. Int -> Gen a -> Gen a
resize Int
v Gen e
forall a. GenUnchecked a => Gen a
genUnchecked
            (a, b, c, d, e) -> Gen (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d, e
e)
    shrinkUnchecked :: (a, b, c, d, e) -> [(a, b, c, d, e)]
shrinkUnchecked (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e) =
        [ (a
a', b
b', c
c', d
d', e
e')
        | (a' :: a
a', (b' :: b
b', (c' :: c
c', (d' :: d
d', e' :: e
e')))) <- (a, (b, (c, (d, e)))) -> [(a, (b, (c, (d, e))))]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked (a
a, (b
b, (c
c, (d
d, e
e))))
        ]

instance (GenValid a, GenValid b, GenValid c, GenValid d, GenValid e) =>
         GenValid (a, b, c, d, e) where
    genValid :: Gen (a, b, c, d, e)
genValid =
        (Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e))
-> (Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t, u :: Int
u, v :: Int
v) <- Int -> Gen (Int, Int, Int, Int, Int)
genSplit5 Int
n
            a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenValid a => Gen a
genValid
            b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenValid a => Gen a
genValid
            c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenValid a => Gen a
genValid
            d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenValid a => Gen a
genValid
            e
e <- Int -> Gen e -> Gen e
forall a. Int -> Gen a -> Gen a
resize Int
v Gen e
forall a. GenValid a => Gen a
genValid
            (a, b, c, d, e) -> Gen (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d, e
e)
    shrinkValid :: (a, b, c, d, e) -> [(a, b, c, d, e)]
shrinkValid (a :: a
a, b :: b
b, c :: c
c, d :: d
d, e :: e
e) =
        [ (a
a', b
b', c
c', d
d', e
e')
        | (a' :: a
a', (b' :: b
b', (c' :: c
c', (d' :: d
d', e' :: e
e')))) <- (a, (b, (c, (d, e)))) -> [(a, (b, (c, (d, e))))]
forall a. GenValid a => a -> [a]
shrinkValid (a
a, (b
b, (c
c, (d
d, e
e))))
        ]

-- | This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.
instance ( GenUnchecked a, GenUnchecked b, GenUnchecked c, GenUnchecked d, GenUnchecked e
         , GenInvalid a, GenInvalid b, GenInvalid c, GenInvalid d, GenInvalid e) =>
         GenInvalid (a, b, c, d, e) where
    genInvalid :: Gen (a, b, c, d, e)
genInvalid =
        (Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e)
forall a. (Int -> Gen a) -> Gen a
sized ((Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e))
-> (Int -> Gen (a, b, c, d, e)) -> Gen (a, b, c, d, e)
forall a b. (a -> b) -> a -> b
$ \n :: Int
n -> do
            (r :: Int
r, s :: Int
s, t :: Int
t, u :: Int
u, v :: Int
v) <- Int -> Gen (Int, Int, Int, Int, Int)
genSplit5 Int
n
            [Gen (a, b, c, d, e)] -> Gen (a, b, c, d, e)
forall a. [Gen a] -> Gen a
oneof
                [ do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenInvalid a => Gen a
genInvalid
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
                     e
e <- Int -> Gen e -> Gen e
forall a. Int -> Gen a -> Gen a
resize Int
v Gen e
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c, d, e) -> Gen (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d, e
e)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenInvalid a => Gen a
genInvalid
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
                     e
e <- Int -> Gen e -> Gen e
forall a. Int -> Gen a -> Gen a
resize Int
v Gen e
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c, d, e) -> Gen (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d, e
e)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenInvalid a => Gen a
genInvalid
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
                     e
e <- Int -> Gen e -> Gen e
forall a. Int -> Gen a -> Gen a
resize Int
v Gen e
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c, d, e) -> Gen (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d, e
e)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenInvalid a => Gen a
genInvalid
                     e
e <- Int -> Gen e -> Gen e
forall a. Int -> Gen a -> Gen a
resize Int
v Gen e
forall a. GenUnchecked a => Gen a
genUnchecked
                     (a, b, c, d, e) -> Gen (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d, e
e)
                , do a
a <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
r Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
                     b
b <- Int -> Gen b -> Gen b
forall a. Int -> Gen a -> Gen a
resize Int
s Gen b
forall a. GenUnchecked a => Gen a
genUnchecked
                     c
c <- Int -> Gen c -> Gen c
forall a. Int -> Gen a -> Gen a
resize Int
t Gen c
forall a. GenUnchecked a => Gen a
genUnchecked
                     d
d <- Int -> Gen d -> Gen d
forall a. Int -> Gen a -> Gen a
resize Int
u Gen d
forall a. GenUnchecked a => Gen a
genUnchecked
                     e
e <- Int -> Gen e -> Gen e
forall a. Int -> Gen a -> Gen a
resize Int
v Gen e
forall a. GenInvalid a => Gen a
genInvalid
                     (a, b, c, d, e) -> Gen (a, b, c, d, e)
forall (m :: * -> *) a. Monad m => a -> m a
return (a
a, b
b, c
c, d
d, e
e)
                ]

instance GenUnchecked a => GenUnchecked (Maybe a) where
    genUnchecked :: Gen (Maybe a)
genUnchecked = [Gen (Maybe a)] -> Gen (Maybe a)
forall a. [Gen a] -> Gen a
oneof [Maybe a -> Gen (Maybe a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing, a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> Gen a -> Gen (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenUnchecked a => Gen a
genUnchecked]
    shrinkUnchecked :: Maybe a -> [Maybe a]
shrinkUnchecked Nothing = []
    shrinkUnchecked (Just a :: a
a) = 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 -> Maybe a) -> [a] -> [Maybe a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [a]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked a
a)


instance GenValid a => GenValid (Maybe a) where
    genValid :: Gen (Maybe a)
genValid = [Gen (Maybe a)] -> Gen (Maybe a)
forall a. [Gen a] -> Gen a
oneof [Maybe a -> Gen (Maybe a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing, a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> Gen a -> Gen (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenValid a => Gen a
genValid]
    shrinkValid :: Maybe a -> [Maybe a]
shrinkValid Nothing = []
    shrinkValid (Just a :: a
a) = 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 -> Maybe a) -> [a] -> [Maybe a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [a]
forall a. GenValid a => a -> [a]
shrinkValid a
a)

instance GenInvalid a => GenInvalid (Maybe a) where
    genInvalid :: Gen (Maybe a)
genInvalid = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> Gen a -> Gen (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenInvalid a => Gen a
genInvalid
    shrinkInvalid :: Maybe a -> [Maybe a]
shrinkInvalid Nothing = [] -- Should not happen
    shrinkInvalid (Just a :: a
a) = a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> [a] -> [Maybe a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> [a]
forall a. GenInvalid a => a -> [a]
shrinkInvalid a
a

#if MIN_VERSION_base(4,9,0)
instance GenUnchecked a => GenUnchecked (NonEmpty a) where
    genUnchecked :: Gen (NonEmpty a)
genUnchecked = Gen a -> Gen (NonEmpty a)
forall a. Gen a -> Gen (NonEmpty a)
genNonEmptyOf Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkUnchecked :: NonEmpty a -> [NonEmpty a]
shrinkUnchecked (v :: a
v :| vs :: [a]
vs) = [ a
e a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
es | (e :: a
e, es :: [a]
es) <- (a, [a]) -> [(a, [a])]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked (a
v, [a]
vs)]

instance GenValid a => GenValid (NonEmpty a) where
    genValid :: Gen (NonEmpty a)
genValid = Gen a -> Gen (NonEmpty a)
forall a. Gen a -> Gen (NonEmpty a)
genNonEmptyOf Gen a
forall a. GenValid a => Gen a
genValid
    shrinkValid :: NonEmpty a -> [NonEmpty a]
shrinkValid (v :: a
v :| vs :: [a]
vs) = [ a
e a -> [a] -> NonEmpty a
forall a. a -> [a] -> NonEmpty a
:| [a]
es | (e :: a
e, es :: [a]
es) <- (a, [a]) -> [(a, [a])]
forall a. GenValid a => a -> [a]
shrinkValid (a
v, [a]
vs)]

instance (GenUnchecked a, GenInvalid a) => GenInvalid (NonEmpty a) where
    genInvalid :: Gen (NonEmpty a)
genInvalid = Gen a -> Gen (NonEmpty a)
forall a. Gen a -> Gen (NonEmpty a)
genNonEmptyOf Gen a
forall a. GenInvalid a => Gen a
genInvalid
#endif

instance GenUnchecked a => GenUnchecked [a] where
    genUnchecked :: Gen [a]
genUnchecked = Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
genListOf Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkUnchecked :: [a] -> [[a]]
shrinkUnchecked = (a -> [a]) -> [a] -> [[a]]
forall a. (a -> [a]) -> [a] -> [[a]]
shrinkList a -> [a]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

-- | If we can generate values of a certain type, we can also generate lists of
-- them.
instance GenValid a => GenValid [a] where
    genValid :: Gen [a]
genValid = Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
genListOf Gen a
forall a. GenValid a => Gen a
genValid
    shrinkValid :: [a] -> [[a]]
shrinkValid = (a -> [a]) -> [a] -> [[a]]
forall a. (a -> [a]) -> [a] -> [[a]]
shrinkList a -> [a]
forall a. GenValid a => a -> [a]
shrinkValid

-- | This instance ensures that the generated list contains at least one element
-- that satisfies 'isInvalid'. The rest is unchecked.
instance (GenUnchecked a, GenInvalid a) => GenInvalid [a] where
    genInvalid :: Gen [a]
genInvalid =
        (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
$ \n :: Int
n -> do
            (x :: Int
x, y :: Int
y, z :: Int
z) <- Int -> Gen (Int, Int, Int)
genSplit3 Int
n
            [a]
before <- Int -> Gen [a] -> Gen [a]
forall a. Int -> Gen a -> Gen a
resize Int
x (Gen [a] -> Gen [a]) -> Gen [a] -> Gen [a]
forall a b. (a -> b) -> a -> b
$ Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
genListOf Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
            a
middle <- Int -> Gen a -> Gen a
forall a. Int -> Gen a -> Gen a
resize Int
y Gen a
forall a. GenInvalid a => Gen a
genInvalid
            [a]
after <- Int -> Gen [a] -> Gen [a]
forall a. Int -> Gen a -> Gen a
resize Int
z (Gen [a] -> Gen [a]) -> Gen [a] -> Gen [a]
forall a b. (a -> b) -> a -> b
$ Gen a -> Gen [a]
forall a. Gen a -> Gen [a]
genListOf Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
            [a] -> Gen [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([a] -> Gen [a]) -> [a] -> Gen [a]
forall a b. (a -> b) -> a -> b
$ [a]
before [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a
middle] [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a]
after

instance GenUnchecked () where
    genUnchecked :: Gen ()
genUnchecked = Gen ()
forall a. Arbitrary a => Gen a
arbitrary
    shrinkUnchecked :: () -> [()]
shrinkUnchecked = () -> [()]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid () where
    genValid :: Gen ()
genValid = Gen ()
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: () -> [()]
shrinkValid = () -> [()]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Bool where
    genUnchecked :: Gen Bool
genUnchecked = Gen Bool
forall a. Arbitrary a => Gen a
arbitrary
    shrinkUnchecked :: Bool -> [Bool]
shrinkUnchecked = Bool -> [Bool]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid Bool where
    genValid :: Gen Bool
genValid = Gen Bool
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Bool -> [Bool]
shrinkValid = Bool -> [Bool]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Ordering where
    genUnchecked :: Gen Ordering
genUnchecked = Gen Ordering
forall a. Arbitrary a => Gen a
arbitrary
    shrinkUnchecked :: Ordering -> [Ordering]
shrinkUnchecked = Ordering -> [Ordering]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid Ordering where
    genValid :: Gen Ordering
genValid = Gen Ordering
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Ordering -> [Ordering]
shrinkValid = Ordering -> [Ordering]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Char where
    genUnchecked :: Gen Char
genUnchecked = [(Int, Gen Char)] -> Gen Char
forall a. [(Int, Gen a)] -> Gen a
frequency [(9, (Char, Char) -> Gen Char
forall a. Random a => (a, a) -> Gen a
choose (Char
forall a. Bounded a => a
minBound, Char
forall a. Bounded a => a
maxBound)), (1, Gen Char
genUtf16SurrogateCodePoint)]
    shrinkUnchecked :: Char -> [Char]
shrinkUnchecked = Char -> [Char]
forall a. Arbitrary a => a -> [a]
shrink

genUtf16SurrogateCodePoint :: Gen Char
genUtf16SurrogateCodePoint :: Gen Char
genUtf16SurrogateCodePoint = Int -> Char
chr (Int -> Char) -> Gen Int -> Gen Char
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Gen Int] -> Gen Int
forall a. [Gen a] -> Gen a
oneof [(Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (0xD800, 0xDBFF), (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (0xDC00, 0xDFFF)]

instance GenValid Char where
    genValid :: Gen Char
genValid = Gen Char
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Char -> [Char]
shrinkValid = Char -> [Char]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Int where
    genUnchecked :: Gen Int
genUnchecked = Gen Int
forall a. (Integral a, Bounded a, Random a) => Gen a
genIntX
    shrinkUnchecked :: Int -> [Int]
shrinkUnchecked = Int -> [Int]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid Int where
    genValid :: Gen Int
genValid = Gen Int
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Int -> [Int]
shrinkValid = Int -> [Int]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Int8 where
    genUnchecked :: Gen Int8
genUnchecked = (Int# -> Int8) -> Gen Int8
forall a. (Int# -> a) -> Gen a
genUncheckedInt (Int# -> Int8
I8#)
    shrinkUnchecked :: Int8 -> [Int8]
shrinkUnchecked = (Int -> Int8) -> (Int8 -> Int) -> Int8 -> [Int8]
forall a. (Int -> a) -> (a -> Int) -> a -> [a]
shrinkUncheckedInt (\(I# i# :: Int#
i#) -> Int# -> Int8
I8# Int#
i#) (\(I8# i# :: Int#
i#) -> Int# -> Int
I# Int#
i#)

instance GenValid Int8 where
    genValid :: Gen Int8
genValid = Gen Int8
forall a. (Integral a, Bounded a, Random a) => Gen a
genIntX
    shrinkValid :: Int8 -> [Int8]
shrinkValid = Int8 -> [Int8]
forall a. Arbitrary a => a -> [a]
shrink

instance GenUnchecked Int16 where
    genUnchecked :: Gen Int16
genUnchecked = (Int# -> Int16) -> Gen Int16
forall a. (Int# -> a) -> Gen a
genUncheckedInt (Int# -> Int16
I16#)
    shrinkUnchecked :: Int16 -> [Int16]
shrinkUnchecked = (Int -> Int16) -> (Int16 -> Int) -> Int16 -> [Int16]
forall a. (Int -> a) -> (a -> Int) -> a -> [a]
shrinkUncheckedInt (\(I# i# :: Int#
i#) -> Int# -> Int16
I16# Int#
i#) (\(I16# i# :: Int#
i#) -> Int# -> Int
I# Int#
i#)

instance GenValid Int16 where
    genValid :: Gen Int16
genValid = Gen Int16
forall a. (Integral a, Bounded a, Random a) => Gen a
genIntX
    shrinkValid :: Int16 -> [Int16]
shrinkValid = Int16 -> [Int16]
forall a. Arbitrary a => a -> [a]
shrink

instance GenUnchecked Int32 where
    genUnchecked :: Gen Int32
genUnchecked = (Int# -> Int32) -> Gen Int32
forall a. (Int# -> a) -> Gen a
genUncheckedInt (Int# -> Int32
I32#)
    shrinkUnchecked :: Int32 -> [Int32]
shrinkUnchecked = (Int -> Int32) -> (Int32 -> Int) -> Int32 -> [Int32]
forall a. (Int -> a) -> (a -> Int) -> a -> [a]
shrinkUncheckedInt (\(I# i# :: Int#
i#) -> Int# -> Int32
I32# Int#
i#) (\(I32# i# :: Int#
i#) -> Int# -> Int
I# Int#
i#)

instance GenValid Int32 where
    genValid :: Gen Int32
genValid = Gen Int32
forall a. (Integral a, Bounded a, Random a) => Gen a
genIntX
    shrinkValid :: Int32 -> [Int32]
shrinkValid = Int32 -> [Int32]
forall a. Arbitrary a => a -> [a]
shrink

instance GenUnchecked Int64 where
    genUnchecked :: Gen Int64
genUnchecked = Gen Int64
forall a. (Integral a, Bounded a, Random a) => Gen a
genIntX
    shrinkUnchecked :: Int64 -> [Int64]
shrinkUnchecked = Int64 -> [Int64]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid Int64 where
    genValid :: Gen Int64
genValid = Gen Int64
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Int64 -> [Int64]
shrinkValid = Int64 -> [Int64]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Word where
    genUnchecked :: Gen Word
genUnchecked = Gen Word
forall a. (Integral a, Bounded a, Random a) => Gen a
genWordX
    shrinkUnchecked :: Word -> [Word]
shrinkUnchecked = Word -> [Word]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid Word where
    genValid :: Gen Word
genValid = Gen Word
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Word -> [Word]
shrinkValid = Word -> [Word]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Word8 where
    genUnchecked :: Gen Word8
genUnchecked = (Word# -> Word8) -> Gen Word8
forall a. (Word# -> a) -> Gen a
genUncheckedWord (Word# -> Word8
W8#)
    shrinkUnchecked :: Word8 -> [Word8]
shrinkUnchecked = (Word -> Word8) -> (Word8 -> Word) -> Word8 -> [Word8]
forall a. (Word -> a) -> (a -> Word) -> a -> [a]
shrinkUncheckedWord (\(W# w# :: Word#
w#) -> Word# -> Word8
W8# Word#
w#) (\(W8# w# :: Word#
w#) -> Word# -> Word
W# Word#
w#)

instance GenValid Word8 where
    genValid :: Gen Word8
genValid = Gen Word8
forall a. (Integral a, Bounded a, Random a) => Gen a
genWordX
    shrinkValid :: Word8 -> [Word8]
shrinkValid = Word8 -> [Word8]
forall a. Arbitrary a => a -> [a]
shrink

instance GenUnchecked Word16 where
    genUnchecked :: Gen Word16
genUnchecked = (Word# -> Word16) -> Gen Word16
forall a. (Word# -> a) -> Gen a
genUncheckedWord (Word# -> Word16
W16#)
    shrinkUnchecked :: Word16 -> [Word16]
shrinkUnchecked = (Word -> Word16) -> (Word16 -> Word) -> Word16 -> [Word16]
forall a. (Word -> a) -> (a -> Word) -> a -> [a]
shrinkUncheckedWord (\(W# w# :: Word#
w#) -> Word# -> Word16
W16# Word#
w#) (\(W16# w# :: Word#
w#) -> Word# -> Word
W# Word#
w#)

instance GenValid Word16 where
    genValid :: Gen Word16
genValid = Gen Word16
forall a. (Integral a, Bounded a, Random a) => Gen a
genWordX
    shrinkValid :: Word16 -> [Word16]
shrinkValid = Word16 -> [Word16]
forall a. Arbitrary a => a -> [a]
shrink

instance GenUnchecked Word32 where
    genUnchecked :: Gen Word32
genUnchecked = (Word# -> Word32) -> Gen Word32
forall a. (Word# -> a) -> Gen a
genUncheckedWord (Word# -> Word32
W32#)
    shrinkUnchecked :: Word32 -> [Word32]
shrinkUnchecked = (Word -> Word32) -> (Word32 -> Word) -> Word32 -> [Word32]
forall a. (Word -> a) -> (a -> Word) -> a -> [a]
shrinkUncheckedWord (\(W# w# :: Word#
w#) -> Word# -> Word32
W32# Word#
w#) (\(W32# w# :: Word#
w#) -> Word# -> Word
W# Word#
w#)

instance GenValid Word32 where
    genValid :: Gen Word32
genValid = Gen Word32
forall a. (Integral a, Bounded a, Random a) => Gen a
genWordX
    shrinkValid :: Word32 -> [Word32]
shrinkValid = Word32 -> [Word32]
forall a. Arbitrary a => a -> [a]
shrink

instance GenUnchecked Word64 where
    genUnchecked :: Gen Word64
genUnchecked = Gen Word64
forall a. (Integral a, Bounded a, Random a) => Gen a
genWordX
    shrinkUnchecked :: Word64 -> [Word64]
shrinkUnchecked = Word64 -> [Word64]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid Word64 where
    genValid :: Gen Word64
genValid = Gen Word64
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Word64 -> [Word64]
shrinkValid = Word64 -> [Word64]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Float where
    genUnchecked :: Gen Float
genUnchecked = Gen Float
genFloat
#if MIN_VERSION_QuickCheck(2,9,2)
    shrinkUnchecked :: Float -> [Float]
shrinkUnchecked f :: Float
f = if
      | Float -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Float
f -> []
      | Float -> Bool
forall a. RealFloat a => a -> Bool
isNaN Float
f -> []
      | Bool
otherwise -> Float -> [Float]
forall a. Arbitrary a => a -> [a]
shrink Float
f
#else
    shrinkUnchecked _ = []
#endif

instance GenValid Float where
    genValid :: Gen Float
genValid = Gen Float
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Float -> [Float]
shrinkValid = Float -> [Float]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Double where
    genUnchecked :: Gen Double
genUnchecked = Gen Double
genDouble
#if MIN_VERSION_QuickCheck(2,9,2)
    shrinkUnchecked :: Double -> [Double]
shrinkUnchecked d :: Double
d = if
      | Double -> Bool
forall a. RealFloat a => a -> Bool
isInfinite Double
d -> []
      | Double -> Bool
forall a. RealFloat a => a -> Bool
isNaN Double
d -> []
      | Bool
otherwise -> Double -> [Double]
forall a. Arbitrary a => a -> [a]
shrink Double
d
#else
    shrinkUnchecked _ = []
#endif

instance GenValid Double where
    genValid :: Gen Double
genValid = Gen Double
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkValid :: Double -> [Double]
shrinkValid = Double -> [Double]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked

instance GenUnchecked Integer where
    genUnchecked :: Gen Integer
genUnchecked = Gen Integer
genInteger
    shrinkUnchecked :: Integer -> [Integer]
shrinkUnchecked = Integer -> [Integer]
forall a. Arbitrary a => a -> [a]
shrink

instance GenValid Integer

#if MIN_VERSION_base(4,8,0)
instance GenUnchecked Natural where
    genUnchecked :: Gen Natural
genUnchecked = Integer -> Natural
forall a. Num a => Integer -> a
fromInteger (Integer -> Natural) -> (Integer -> Integer) -> Integer -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Num a => a -> a
abs (Integer -> Natural) -> Gen Integer -> Gen Natural
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Integer
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkUnchecked :: Natural -> [Natural]
shrinkUnchecked = (Integer -> Natural) -> [Integer] -> [Natural]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Integer -> Natural
forall a. Num a => Integer -> a
fromInteger (Integer -> Natural) -> (Integer -> Integer) -> Integer -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Num a => a -> a
abs) ([Integer] -> [Natural])
-> (Natural -> [Integer]) -> Natural -> [Natural]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> [Integer]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked (Integer -> [Integer])
-> (Natural -> Integer) -> Natural -> [Integer]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Integer
forall a. Integral a => a -> Integer
toInteger

instance GenValid Natural where
    genValid :: Gen Natural
genValid = Integer -> Natural
forall a. Num a => Integer -> a
fromInteger (Integer -> Natural) -> (Integer -> Integer) -> Integer -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
forall a. Num a => a -> a
abs (Integer -> Natural) -> Gen Integer -> Gen Natural
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Integer
forall a. GenValid a => Gen a
genValid
#endif

instance (Integral a, GenUnchecked a) => GenUnchecked (Ratio a) where
    genUnchecked :: Gen (Ratio a)
genUnchecked = a -> a -> Ratio a
forall a. a -> a -> Ratio a
(:%) (a -> a -> Ratio a) -> Gen a -> Gen (a -> Ratio a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenUnchecked a => Gen a
genUnchecked Gen (a -> Ratio a) -> Gen a -> Gen (Ratio a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen a
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkUnchecked :: Ratio a -> [Ratio a]
shrinkUnchecked (n :: a
n :% d :: a
d) = [a
n' a -> a -> Ratio a
forall a. a -> a -> Ratio a
:% a
d' | (n' :: a
n', d' :: a
d') <- (a, a) -> [(a, a)]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked (a
n, a
d)]

instance (Integral a, Num a, Ord a, GenValid a) => GenValid (Ratio a) where
    genValid :: Gen (Ratio a)
genValid = (do
      a
n <- Gen a
forall a. GenValid a => Gen a
genValid
      a
d <- (Gen a
forall a. GenValid a => Gen a
genValid Gen a -> (a -> Bool) -> Gen a
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` (a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> 0))
      Ratio a -> Gen (Ratio 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
$ a
n a -> a -> Ratio a
forall a. a -> a -> Ratio a
:% a
d) Gen (Ratio a) -> (Ratio a -> Bool) -> Gen (Ratio a)
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` Ratio a -> Bool
forall a. Validity a => a -> Bool
isValid
    shrinkValid :: Ratio a -> [Ratio a]
shrinkValid (n :: a
n :% d :: a
d) = do
      (n' :: a
n', d' :: a
d') <- (a, a) -> [(a, a)]
forall a. GenValid a => a -> [a]
shrinkValid (a
n, a
d)
      Bool -> [()]
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> [()]) -> Bool -> [()]
forall a b. (a -> b) -> a -> b
$ a
d' a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> 0
      let candidate :: Ratio a
candidate = a
n' a -> a -> Ratio a
forall a. a -> a -> Ratio a
:% a
d'
      Bool -> [()]
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> [()]) -> Bool -> [()]
forall a b. (a -> b) -> a -> b
$ Ratio a -> Bool
forall a. Validity a => a -> Bool
isValid Ratio a
candidate
      Ratio a -> [Ratio a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Ratio a -> [Ratio a]) -> Ratio a -> [Ratio a]
forall a b. (a -> b) -> a -> b
$ a
n' a -> a -> Ratio a
forall a. Integral a => a -> a -> Ratio a
% a
d'

instance (Integral a, Num a, Ord a, Validity a, GenUnchecked a) => GenInvalid (Ratio a)

instance HasResolution a => GenUnchecked (Fixed a) where
    genUnchecked :: Gen (Fixed a)
genUnchecked = Integer -> Fixed a
forall a. Integer -> Fixed a
MkFixed (Integer -> Fixed a) -> Gen Integer -> Gen (Fixed a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Integer
forall a. GenUnchecked a => Gen a
genUnchecked
    shrinkUnchecked :: Fixed a -> [Fixed a]
shrinkUnchecked (MkFixed i :: Integer
i) = Integer -> Fixed a
forall a. Integer -> Fixed a
MkFixed (Integer -> Fixed a) -> [Integer] -> [Fixed a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Integer -> [Integer]
forall a. GenUnchecked a => a -> [a]
shrinkUnchecked Integer
i

instance HasResolution a => GenValid (Fixed a)

genericGenUnchecked :: (Generic a, GGenUnchecked (Rep a)) => Gen a
genericGenUnchecked :: Gen a
genericGenUnchecked = Rep a Any -> a
forall a x. Generic a => Rep a x -> a
to (Rep a Any -> a) -> Gen (Rep a Any) -> Gen a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Rep a Any)
forall (f :: * -> *) a. GGenUnchecked f => Gen (f a)
gGenUnchecked

class GGenUnchecked f where
    gGenUnchecked :: Gen (f a)

instance GGenUnchecked U1 where
    gGenUnchecked :: Gen (U1 a)
gGenUnchecked = U1 a -> Gen (U1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1

instance (GGenUnchecked a, GGenUnchecked b) => GGenUnchecked (a :*: b) where
    gGenUnchecked :: Gen ((:*:) a b a)
gGenUnchecked = a a -> b a -> (:*:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (a a -> b a -> (:*:) a b a)
-> Gen (a a) -> Gen (b a -> (:*:) a b a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (a a)
forall (f :: * -> *) a. GGenUnchecked f => Gen (f a)
gGenUnchecked Gen (b a -> (:*:) a b a) -> Gen (b a) -> Gen ((:*:) a b a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (b a)
forall (f :: * -> *) a. GGenUnchecked f => Gen (f a)
gGenUnchecked

instance (GGenUnchecked a, GGenUnchecked b) => GGenUnchecked (a :+: b) where
    gGenUnchecked :: Gen ((:+:) a b a)
gGenUnchecked = [Gen ((:+:) a b a)] -> Gen ((:+:) a b a)
forall a. [Gen a] -> Gen a
oneof [a a -> (:+:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (a a -> (:+:) a b a) -> Gen (a a) -> Gen ((:+:) a b a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (a a)
forall (f :: * -> *) a. GGenUnchecked f => Gen (f a)
gGenUnchecked, b a -> (:+:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (b a -> (:+:) a b a) -> Gen (b a) -> Gen ((:+:) a b a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (b a)
forall (f :: * -> *) a. GGenUnchecked f => Gen (f a)
gGenUnchecked]

instance (GGenUnchecked a) => GGenUnchecked (M1 i c a) where
    gGenUnchecked :: Gen (M1 i c a a)
gGenUnchecked = a a -> M1 i c a a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (a a -> M1 i c a a) -> Gen (a a) -> Gen (M1 i c a a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (a a)
forall (f :: * -> *) a. GGenUnchecked f => Gen (f a)
gGenUnchecked

instance (GenUnchecked a) => GGenUnchecked (K1 i a) where
    gGenUnchecked :: Gen (K1 i a a)
gGenUnchecked = a -> K1 i a a
forall k i c (p :: k). c -> K1 i c p
K1 (a -> K1 i a a) -> Gen a -> Gen (K1 i a a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenUnchecked a => Gen a
genUnchecked


-- | Shrink a term to any of its immediate subterms,
-- and also recursively shrink all subterms.
genericShrinkUnchecked :: (Generic a, GUncheckedRecursivelyShrink (Rep a), GUncheckedSubterms (Rep a) a) => a -> [a]
genericShrinkUnchecked :: a -> [a]
genericShrinkUnchecked x :: a
x = a -> [a]
forall a. (Generic a, GUncheckedSubterms (Rep a) a) => a -> [a]
uncheckedSubterms a
x [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a -> [a]
forall a.
(Generic a, GUncheckedRecursivelyShrink (Rep a)) =>
a -> [a]
uncheckedRecursivelyShrink a
x

-- | Recursively shrink all immediate uncheckedSubterms.
uncheckedRecursivelyShrink :: (Generic a, GUncheckedRecursivelyShrink (Rep a)) => a -> [a]
uncheckedRecursivelyShrink :: a -> [a]
uncheckedRecursivelyShrink = (Rep a Any -> a) -> [Rep a Any] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Rep a Any -> a
forall a x. Generic a => Rep a x -> a
to ([Rep a Any] -> [a]) -> (a -> [Rep a Any]) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a Any -> [Rep a Any]
forall (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink (Rep a Any -> [Rep a Any]) -> (a -> Rep a Any) -> a -> [Rep a Any]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall a x. Generic a => a -> Rep a x
from

class GUncheckedRecursivelyShrink f where
  gUncheckedRecursivelyShrink :: f a -> [f a]

instance (GUncheckedRecursivelyShrink f, GUncheckedRecursivelyShrink g) => GUncheckedRecursivelyShrink (f :*: g) where
  gUncheckedRecursivelyShrink :: (:*:) f g a -> [(:*:) f g a]
gUncheckedRecursivelyShrink (x :: f a
x :*: y :: g a
y) =
    (f a -> g a -> (:*:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (f a -> g a -> (:*:) f g a) -> [f a] -> [g a -> (:*:) f g a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a -> [f a]
forall (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink f a
x [g a -> (:*:) f g a] -> [g a] -> [(:*:) f g a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> g a -> [g a]
forall (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink g a
y)
      [(:*:) 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 | f a
x' <- f a -> [f a]
forall (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink 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 (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink g a
y ]

instance (GUncheckedRecursivelyShrink f, GUncheckedRecursivelyShrink g) => GUncheckedRecursivelyShrink (f :+: g) where
  gUncheckedRecursivelyShrink :: (:+:) f g a -> [(:+:) f g a]
gUncheckedRecursivelyShrink (L1 x :: 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 (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink f a
x)
  gUncheckedRecursivelyShrink (R1 x :: 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 (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink g a
x)

instance GUncheckedRecursivelyShrink f => GUncheckedRecursivelyShrink (M1 i c f) where
  gUncheckedRecursivelyShrink :: M1 i c f a -> [M1 i c f a]
gUncheckedRecursivelyShrink (M1 x :: 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 (f :: * -> *) a.
GUncheckedRecursivelyShrink f =>
f a -> [f a]
gUncheckedRecursivelyShrink f a
x)

instance GenUnchecked a => GUncheckedRecursivelyShrink (K1 i a) where
  gUncheckedRecursivelyShrink :: K1 i a a -> [K1 i a a]
gUncheckedRecursivelyShrink (K1 x :: 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. GenUnchecked a => a -> [a]
shrinkUnchecked a
x)

instance GUncheckedRecursivelyShrink U1 where
  gUncheckedRecursivelyShrink :: U1 a -> [U1 a]
gUncheckedRecursivelyShrink U1 = []

instance GUncheckedRecursivelyShrink V1 where
  -- The empty type can't be shrunk to anything.
  gUncheckedRecursivelyShrink :: V1 a -> [V1 a]
gUncheckedRecursivelyShrink _ = []


-- | All immediate uncheckedSubterms of a term.
uncheckedSubterms :: (Generic a, GUncheckedSubterms (Rep a) a) => a -> [a]
uncheckedSubterms :: a -> [a]
uncheckedSubterms = Rep a a -> [a]
forall (f :: * -> *) a. GUncheckedSubterms f a => f a -> [a]
gUncheckedSubterms (Rep a a -> [a]) -> (a -> Rep a a) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a a
forall a x. Generic a => a -> Rep a x
from


class GUncheckedSubterms f a where
  gUncheckedSubterms :: f a -> [a]

instance GUncheckedSubterms V1 a where
  gUncheckedSubterms :: V1 a -> [a]
gUncheckedSubterms _ = []

instance GUncheckedSubterms U1 a where
  gUncheckedSubterms :: U1 a -> [a]
gUncheckedSubterms U1 = []

instance (GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubterms (f :*: g) a where
  gUncheckedSubterms :: (:*:) f g a -> [a]
gUncheckedSubterms (l :: f a
l :*: r :: g a
r) = f a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl f a
l [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ g a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl g a
r

instance (GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubterms (f :+: g) a where
  gUncheckedSubterms :: (:+:) f g a -> [a]
gUncheckedSubterms (L1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl f a
x
  gUncheckedSubterms (R1 x :: g a
x) = g a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl g a
x

instance GUncheckedSubterms f a => GUncheckedSubterms (M1 i c f) a where
  gUncheckedSubterms :: M1 i c f a -> [a]
gUncheckedSubterms (M1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GUncheckedSubterms f a => f a -> [a]
gUncheckedSubterms f a
x

instance GUncheckedSubterms (K1 i a) b where
  gUncheckedSubterms :: K1 i a b -> [b]
gUncheckedSubterms (K1 _) = []


class GUncheckedSubtermsIncl f a where
  gUncheckedSubtermsIncl :: f a -> [a]

instance GUncheckedSubtermsIncl V1 a where
  gUncheckedSubtermsIncl :: V1 a -> [a]
gUncheckedSubtermsIncl _ = []

instance GUncheckedSubtermsIncl U1 a where
  gUncheckedSubtermsIncl :: U1 a -> [a]
gUncheckedSubtermsIncl U1 = []

instance (GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubtermsIncl (f :*: g) a where
  gUncheckedSubtermsIncl :: (:*:) f g a -> [a]
gUncheckedSubtermsIncl (l :: f a
l :*: r :: g a
r) = f a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl f a
l [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ g a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl g a
r

instance (GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubtermsIncl (f :+: g) a where
  gUncheckedSubtermsIncl :: (:+:) f g a -> [a]
gUncheckedSubtermsIncl (L1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl f a
x
  gUncheckedSubtermsIncl (R1 x :: g a
x) = g a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl g a
x

instance GUncheckedSubtermsIncl f a => GUncheckedSubtermsIncl (M1 i c f) a where
  gUncheckedSubtermsIncl :: M1 i c f a -> [a]
gUncheckedSubtermsIncl (M1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GUncheckedSubtermsIncl f a => f a -> [a]
gUncheckedSubtermsIncl f a
x

-- This is the important case: We've found a term of the same type.
instance OVERLAPPING_ GUncheckedSubtermsIncl (K1 i a) a where
  gUncheckedSubtermsIncl :: K1 i a a -> [a]
gUncheckedSubtermsIncl (K1 x :: a
x) = [a
x]

instance OVERLAPPING_ GUncheckedSubtermsIncl (K1 i a) b where
  gUncheckedSubtermsIncl :: K1 i a b -> [b]
gUncheckedSubtermsIncl (K1 _) = []


-- | Generate a valid value by generating all the sub parts using the 'Generic' instance,
-- and trying that until a valid value has been generated
--
-- > genValidStructurally = genValidStructurallyWithoutExtraChecking `suchThat` isValid
--
-- This is probably the function that you are looking for.
-- If you do use this function to override `genValid`, you probably also want to use
-- 'shrinkValidStructurally' to override 'shrinkValid'.
genValidStructurally :: (Validity a, Generic a, GGenValid (Rep a)) => Gen a
genValidStructurally :: Gen a
genValidStructurally = Gen a
forall a. (Generic a, GGenValid (Rep a)) => Gen a
genValidStructurallyWithoutExtraChecking Gen a -> (a -> Bool) -> Gen a
forall a. Gen a -> (a -> Bool) -> Gen a
`suchThat` a -> Bool
forall a. Validity a => a -> Bool
isValid

-- | Generate a valid value by generating all the sub parts using the 'Generic' instance,
--
-- This generator is _not_ guaranteed to generate a valid value.
--
-- This is probably _not_ the function that you are looking for when overriding
-- `genValid` _unless_ the type in question has no _extra_ validity constraints on top of
-- the validity of its sub parts.
genValidStructurallyWithoutExtraChecking :: (Generic a, GGenValid (Rep a)) => Gen a
genValidStructurallyWithoutExtraChecking :: Gen a
genValidStructurallyWithoutExtraChecking = Rep a Any -> a
forall a x. Generic a => Rep a x -> a
to (Rep a Any -> a) -> Gen (Rep a Any) -> Gen a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Rep a Any)
forall (f :: * -> *) a. GGenValid f => Gen (f a)
gGenValid

class GGenValid f where
    gGenValid :: Gen (f a)

instance GGenValid U1 where
    gGenValid :: Gen (U1 a)
gGenValid = U1 a -> Gen (U1 a)
forall (f :: * -> *) a. Applicative f => a -> f a
pure U1 a
forall k (p :: k). U1 p
U1

instance (GGenValid a, GGenValid b) => GGenValid (a :*: b) where
    gGenValid :: Gen ((:*:) a b a)
gGenValid = a a -> b a -> (:*:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (a a -> b a -> (:*:) a b a)
-> Gen (a a) -> Gen (b a -> (:*:) a b a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (a a)
forall (f :: * -> *) a. GGenValid f => Gen (f a)
gGenValid Gen (b a -> (:*:) a b a) -> Gen (b a) -> Gen ((:*:) a b a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen (b a)
forall (f :: * -> *) a. GGenValid f => Gen (f a)
gGenValid

instance (GGenValid a, GGenValid b) => GGenValid (a :+: b) where
    gGenValid :: Gen ((:+:) a b a)
gGenValid = [Gen ((:+:) a b a)] -> Gen ((:+:) a b a)
forall a. [Gen a] -> Gen a
oneof [a a -> (:+:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 (a a -> (:+:) a b a) -> Gen (a a) -> Gen ((:+:) a b a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (a a)
forall (f :: * -> *) a. GGenValid f => Gen (f a)
gGenValid, b a -> (:+:) a b a
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (b a -> (:+:) a b a) -> Gen (b a) -> Gen ((:+:) a b a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (b a)
forall (f :: * -> *) a. GGenValid f => Gen (f a)
gGenValid]

instance (GGenValid a) => GGenValid (M1 i c a) where
    gGenValid :: Gen (M1 i c a a)
gGenValid = a a -> M1 i c a a
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 (a a -> M1 i c a a) -> Gen (a a) -> Gen (M1 i c a a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (a a)
forall (f :: * -> *) a. GGenValid f => Gen (f a)
gGenValid

instance (GenValid a) => GGenValid (K1 i a) where
    gGenValid :: Gen (K1 i a a)
gGenValid = a -> K1 i a a
forall k i c (p :: k). c -> K1 i c p
K1 (a -> K1 i a a) -> Gen a -> Gen (K1 i a a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen a
forall a. GenValid a => Gen a
genValid


-- | Shrink a term to any of its immediate valid subterms,
-- and also recursively shrink all subterms, and then filtering out the results that are not valid.
--
-- > shrinkValidStructurally = filter isValid . shrinkValidStructurallyWithoutExtraFiltering
--
-- This is probably the function that you are looking for.
shrinkValidStructurally :: (Validity a, Generic a, GValidRecursivelyShrink (Rep a), GValidSubterms (Rep a) a) => a -> [a]
shrinkValidStructurally :: a -> [a]
shrinkValidStructurally = (a -> Bool) -> [a] -> [a]
forall a. (a -> Bool) -> [a] -> [a]
filter a -> Bool
forall a. Validity a => a -> Bool
isValid ([a] -> [a]) -> (a -> [a]) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> [a]
forall a.
(Generic a, GValidRecursivelyShrink (Rep a),
 GValidSubterms (Rep a) a) =>
a -> [a]
shrinkValidStructurallyWithoutExtraFiltering

-- | Shrink a term to any of its immediate valid subterms,
-- and also recursively shrink all subterms.
--
-- This shrinking function is _not_ guaranteed to shrink to valid values.
--
-- This is probably _not_ the function that you are looking for when overriding
-- `shrinkValid` _unless_ the type in question has no _extra_ validity constraints on top of
-- the validity of its sub parts.
shrinkValidStructurallyWithoutExtraFiltering :: (Generic a, GValidRecursivelyShrink (Rep a), GValidSubterms (Rep a) a) => a -> [a]
shrinkValidStructurallyWithoutExtraFiltering :: a -> [a]
shrinkValidStructurallyWithoutExtraFiltering x :: a
x = a -> [a]
forall a. (Generic a, GValidSubterms (Rep a) a) => a -> [a]
structurallyValidSubterms a
x [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ a -> [a]
forall a. (Generic a, GValidRecursivelyShrink (Rep a)) => a -> [a]
structurallyValidRecursivelyShrink a
x

-- | Recursively shrink all immediate structurally valid subterms.
structurallyValidRecursivelyShrink :: (Generic a, GValidRecursivelyShrink (Rep a)) => a -> [a]
structurallyValidRecursivelyShrink :: a -> [a]
structurallyValidRecursivelyShrink = (Rep a Any -> a) -> [Rep a Any] -> [a]
forall a b. (a -> b) -> [a] -> [b]
map Rep a Any -> a
forall a x. Generic a => Rep a x -> a
to ([Rep a Any] -> [a]) -> (a -> [Rep a Any]) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Rep a Any -> [Rep a Any]
forall (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink (Rep a Any -> [Rep a Any]) -> (a -> Rep a Any) -> a -> [Rep a Any]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a Any
forall a x. Generic a => a -> Rep a x
from

class GValidRecursivelyShrink f where
  gValidRecursivelyShrink :: f a -> [f a]

instance (GValidRecursivelyShrink f, GValidRecursivelyShrink g) => GValidRecursivelyShrink (f :*: g) where
  gValidRecursivelyShrink :: (:*:) f g a -> [(:*:) f g a]
gValidRecursivelyShrink (x :: f a
x :*: y :: g a
y) =
    (f a -> g a -> (:*:) f g a
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
(:*:) (f a -> g a -> (:*:) f g a) -> [f a] -> [g a -> (:*:) f g a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a -> [f a]
forall (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink f a
x [g a -> (:*:) f g a] -> [g a] -> [(:*:) f g a]
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> g a -> [g a]
forall (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink g a
y)
      [(:*:) 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 | f a
x' <- f a -> [f a]
forall (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink 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 (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink g a
y ]

instance (GValidRecursivelyShrink f, GValidRecursivelyShrink g) => GValidRecursivelyShrink (f :+: g) where
  gValidRecursivelyShrink :: (:+:) f g a -> [(:+:) f g a]
gValidRecursivelyShrink (L1 x :: 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 (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink f a
x)
  gValidRecursivelyShrink (R1 x :: 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 (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink g a
x)

instance GValidRecursivelyShrink f => GValidRecursivelyShrink (M1 i c f) where
  gValidRecursivelyShrink :: M1 i c f a -> [M1 i c f a]
gValidRecursivelyShrink (M1 x :: 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 (f :: * -> *) a. GValidRecursivelyShrink f => f a -> [f a]
gValidRecursivelyShrink f a
x)

instance GenValid a => GValidRecursivelyShrink (K1 i a) where
  gValidRecursivelyShrink :: K1 i a a -> [K1 i a a]
gValidRecursivelyShrink (K1 x :: 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. GenValid a => a -> [a]
shrinkValid a
x)

instance GValidRecursivelyShrink U1 where
  gValidRecursivelyShrink :: U1 a -> [U1 a]
gValidRecursivelyShrink U1 = []

instance GValidRecursivelyShrink V1 where
  -- The empty type can't be shrunk to anything.
  gValidRecursivelyShrink :: V1 a -> [V1 a]
gValidRecursivelyShrink _ = []


-- | All immediate validSubterms of a term.
structurallyValidSubterms :: (Generic a, GValidSubterms (Rep a) a) => a -> [a]
structurallyValidSubterms :: a -> [a]
structurallyValidSubterms = Rep a a -> [a]
forall (f :: * -> *) a. GValidSubterms f a => f a -> [a]
gValidSubterms (Rep a a -> [a]) -> (a -> Rep a a) -> a -> [a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Rep a a
forall a x. Generic a => a -> Rep a x
from


class GValidSubterms f a where
  gValidSubterms :: f a -> [a]

instance GValidSubterms V1 a where
  gValidSubterms :: V1 a -> [a]
gValidSubterms _ = []

instance GValidSubterms U1 a where
  gValidSubterms :: U1 a -> [a]
gValidSubterms U1 = []

instance (GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubterms (f :*: g) a where
  gValidSubterms :: (:*:) f g a -> [a]
gValidSubterms (l :: f a
l :*: r :: g a
r) = f a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl f a
l [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ g a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl g a
r

instance (GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubterms (f :+: g) a where
  gValidSubterms :: (:+:) f g a -> [a]
gValidSubterms (L1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl f a
x
  gValidSubterms (R1 x :: g a
x) = g a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl g a
x

instance GValidSubterms f a => GValidSubterms (M1 i c f) a where
  gValidSubterms :: M1 i c f a -> [a]
gValidSubterms (M1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GValidSubterms f a => f a -> [a]
gValidSubterms f a
x

instance GValidSubterms (K1 i a) b where
  gValidSubterms :: K1 i a b -> [b]
gValidSubterms (K1 _) = []


class GValidSubtermsIncl f a where
  gValidSubtermsIncl :: f a -> [a]

instance GValidSubtermsIncl V1 a where
  gValidSubtermsIncl :: V1 a -> [a]
gValidSubtermsIncl _ = []

instance GValidSubtermsIncl U1 a where
  gValidSubtermsIncl :: U1 a -> [a]
gValidSubtermsIncl U1 = []

instance (GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubtermsIncl (f :*: g) a where
  gValidSubtermsIncl :: (:*:) f g a -> [a]
gValidSubtermsIncl (l :: f a
l :*: r :: g a
r) = f a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl f a
l [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ g a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl g a
r

instance (GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubtermsIncl (f :+: g) a where
  gValidSubtermsIncl :: (:+:) f g a -> [a]
gValidSubtermsIncl (L1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl f a
x
  gValidSubtermsIncl (R1 x :: g a
x) = g a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl g a
x

instance GValidSubtermsIncl f a => GValidSubtermsIncl (M1 i c f) a where
  gValidSubtermsIncl :: M1 i c f a -> [a]
gValidSubtermsIncl (M1 x :: f a
x) = f a -> [a]
forall (f :: * -> *) a. GValidSubtermsIncl f a => f a -> [a]
gValidSubtermsIncl f a
x

-- This is the important case: We've found a term of the same type.
instance OVERLAPPING_ GValidSubtermsIncl (K1 i a) a where
  gValidSubtermsIncl :: K1 i a a -> [a]
gValidSubtermsIncl (K1 x :: a
x) = [a
x]

instance OVERLAPPING_ GValidSubtermsIncl (K1 i a) b where
  gValidSubtermsIncl :: K1 i a b -> [b]
gValidSubtermsIncl (K1 _) = []