Data.GenValidity

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.

Documentation

class GenUnchecked a where

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

Minimal complete definition

Nothing

Methods

genUnchecked :: Gen a

genUnchecked :: (Generic a, GGenUnchecked (Rep a)) => Gen a

shrinkUnchecked :: a -> [a]

shrinkUnchecked :: (Generic a, GUncheckedRecursivelyShrink (Rep a), GUncheckedSubterms (Rep a) a) => a -> [a]

Instances

GenUnchecked Bool

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Bool

shrinkUnchecked :: Bool -> [Bool]

GenUnchecked Char

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Char

shrinkUnchecked :: Char -> [Char]

GenUnchecked Double

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Double

shrinkUnchecked :: Double -> [Double]

GenUnchecked Float

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Float

shrinkUnchecked :: Float -> [Float]

GenUnchecked Int

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Int

shrinkUnchecked :: Int -> [Int]

GenUnchecked Int8

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Int8

shrinkUnchecked :: Int8 -> [Int8]

GenUnchecked Int16

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Int16

shrinkUnchecked :: Int16 -> [Int16]

GenUnchecked Int32

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Int32

shrinkUnchecked :: Int32 -> [Int32]

GenUnchecked Int64

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Int64

shrinkUnchecked :: Int64 -> [Int64]

GenUnchecked Integer

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Integer

shrinkUnchecked :: Integer -> [Integer]

GenUnchecked Natural

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Natural

shrinkUnchecked :: Natural -> [Natural]

GenUnchecked Ordering

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Ordering

shrinkUnchecked :: Ordering -> [Ordering]

GenUnchecked Word

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Word

shrinkUnchecked :: Word -> [Word]

GenUnchecked Word8

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Word8

shrinkUnchecked :: Word8 -> [Word8]

GenUnchecked Word16

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Word16

shrinkUnchecked :: Word16 -> [Word16]

GenUnchecked Word32

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Word32

shrinkUnchecked :: Word32 -> [Word32]

GenUnchecked Word64

Defined in Data.GenValidity

Methods

genUnchecked :: Gen Word64

shrinkUnchecked :: Word64 -> [Word64]

GenUnchecked ()

Defined in Data.GenValidity

Methods

genUnchecked :: Gen ()

shrinkUnchecked :: () -> [()]

GenUnchecked a => GenUnchecked [a]

Defined in Data.GenValidity

Methods

genUnchecked :: Gen [a]

shrinkUnchecked :: [a] -> [[a]]

GenUnchecked a => GenUnchecked (Maybe a)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (Maybe a)

shrinkUnchecked :: Maybe a -> [Maybe a]

(Integral a, GenUnchecked a) => GenUnchecked (Ratio a)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (Ratio a)

shrinkUnchecked :: Ratio a -> [Ratio a]

HasResolution a => GenUnchecked (Fixed a)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (Fixed a)

shrinkUnchecked :: Fixed a -> [Fixed a]

GenUnchecked a => GenUnchecked (NonEmpty a)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (NonEmpty a)

shrinkUnchecked :: NonEmpty a -> [NonEmpty a]

(GenUnchecked a, GenUnchecked b) => GenUnchecked (Either a b)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (Either a b)

shrinkUnchecked :: Either a b -> [Either a b]

(GenUnchecked a, GenUnchecked b) => GenUnchecked (a, b)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (a, b)

shrinkUnchecked :: (a, b) -> [(a, b)]

(GenUnchecked a, GenUnchecked b, GenUnchecked c) => GenUnchecked (a, b, c)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (a, b, c)

shrinkUnchecked :: (a, b, c) -> [(a, b, c)]

(GenUnchecked a, GenUnchecked b, GenUnchecked c, GenUnchecked d) => GenUnchecked (a, b, c, d)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (a, b, c, d)

shrinkUnchecked :: (a, b, c, d) -> [(a, b, c, d)]

(GenUnchecked a, GenUnchecked b, GenUnchecked c, GenUnchecked d, GenUnchecked e) => GenUnchecked (a, b, c, d, e)

Defined in Data.GenValidity

Methods

genUnchecked :: Gen (a, b, c, d, e)

shrinkUnchecked :: (a, b, c, d, e) -> [(a, b, c, d, e)]

class Validity a => GenValid a where

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

Minimal complete definition

Nothing

Methods

genValid :: Gen a

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 :: GenUnchecked a => Gen a

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.

shrinkValid :: a -> [a]

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 :: GenUnchecked a => a -> [a]

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.

Instances

GenValid Bool

Defined in Data.GenValidity

Methods

genValid :: Gen Bool

shrinkValid :: Bool -> [Bool]

GenValid Char

Defined in Data.GenValidity

Methods

genValid :: Gen Char

shrinkValid :: Char -> [Char]

GenValid Double

Defined in Data.GenValidity

Methods

genValid :: Gen Double

shrinkValid :: Double -> [Double]

GenValid Float

Defined in Data.GenValidity

Methods

genValid :: Gen Float

shrinkValid :: Float -> [Float]

GenValid Int

Defined in Data.GenValidity

Methods

genValid :: Gen Int

shrinkValid :: Int -> [Int]

GenValid Int8

Defined in Data.GenValidity

Methods

genValid :: Gen Int8

shrinkValid :: Int8 -> [Int8]

GenValid Int16

Defined in Data.GenValidity

Methods

genValid :: Gen Int16

shrinkValid :: Int16 -> [Int16]

GenValid Int32

Defined in Data.GenValidity

Methods

genValid :: Gen Int32

shrinkValid :: Int32 -> [Int32]

GenValid Int64

Defined in Data.GenValidity

Methods

genValid :: Gen Int64

shrinkValid :: Int64 -> [Int64]

GenValid Integer

Defined in Data.GenValidity

Methods

genValid :: Gen Integer

shrinkValid :: Integer -> [Integer]

GenValid Natural

Defined in Data.GenValidity

Methods

genValid :: Gen Natural

shrinkValid :: Natural -> [Natural]

GenValid Ordering

Defined in Data.GenValidity

Methods

genValid :: Gen Ordering

shrinkValid :: Ordering -> [Ordering]

GenValid Word

Defined in Data.GenValidity

Methods

genValid :: Gen Word

shrinkValid :: Word -> [Word]

GenValid Word8

Defined in Data.GenValidity

Methods

genValid :: Gen Word8

shrinkValid :: Word8 -> [Word8]

GenValid Word16

Defined in Data.GenValidity

Methods

genValid :: Gen Word16

shrinkValid :: Word16 -> [Word16]

GenValid Word32

Defined in Data.GenValidity

Methods

genValid :: Gen Word32

shrinkValid :: Word32 -> [Word32]

GenValid Word64

Defined in Data.GenValidity

Methods

genValid :: Gen Word64

shrinkValid :: Word64 -> [Word64]

GenValid ()

Defined in Data.GenValidity

Methods

genValid :: Gen ()

shrinkValid :: () -> [()]

GenValid a => GenValid [a]

If we can generate values of a certain type, we can also generate lists of them.

Defined in Data.GenValidity

Methods

genValid :: Gen [a]

shrinkValid :: [a] -> [[a]]

GenValid a => GenValid (Maybe a)

Defined in Data.GenValidity

Methods

genValid :: Gen (Maybe a)

shrinkValid :: Maybe a -> [Maybe a]

(Integral a, Num a, Ord a, GenValid a) => GenValid (Ratio a)

Defined in Data.GenValidity

Methods

genValid :: Gen (Ratio a)

shrinkValid :: Ratio a -> [Ratio a]

HasResolution a => GenValid (Fixed a)

Defined in Data.GenValidity

Methods

genValid :: Gen (Fixed a)

shrinkValid :: Fixed a -> [Fixed a]

GenValid a => GenValid (NonEmpty a)

Defined in Data.GenValidity

Methods

genValid :: Gen (NonEmpty a)

shrinkValid :: NonEmpty a -> [NonEmpty a]

(GenValid a, GenValid b) => GenValid (Either a b)

Defined in Data.GenValidity

Methods

genValid :: Gen (Either a b)

shrinkValid :: Either a b -> [Either a b]

(GenValid a, GenValid b) => GenValid (a, b)

Defined in Data.GenValidity

Methods

genValid :: Gen (a, b)

shrinkValid :: (a, b) -> [(a, b)]

(GenValid a, GenValid b, GenValid c) => GenValid (a, b, c)

Defined in Data.GenValidity

Methods

genValid :: Gen (a, b, c)

shrinkValid :: (a, b, c) -> [(a, b, c)]

(GenValid a, GenValid b, GenValid c, GenValid d) => GenValid (a, b, c, d)

Defined in Data.GenValidity

Methods

genValid :: Gen (a, b, c, d)

shrinkValid :: (a, b, c, d) -> [(a, b, c, d)]

(GenValid a, GenValid b, GenValid c, GenValid d, GenValid e) => GenValid (a, b, c, d, e)

Defined in Data.GenValidity

Methods

genValid :: Gen (a, b, c, d, e)

shrinkValid :: (a, b, c, d, e) -> [(a, b, c, d, e)]

class Validity a => GenInvalid a where

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.

Minimal complete definition

Nothing

Methods

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.

genInvalid :: GenUnchecked a => 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.

shrinkInvalid :: a -> [a]

shrinkInvalid :: GenUnchecked a => a -> [a]

Instances

(GenUnchecked a, GenInvalid a) => GenInvalid [a]

This instance ensures that the generated list contains at least one element that satisfies isInvalid. The rest is unchecked.

Defined in Data.GenValidity

Methods

genInvalid :: Gen [a]

shrinkInvalid :: [a] -> [[a]]

GenInvalid a => GenInvalid (Maybe a)

Defined in Data.GenValidity

Methods

genInvalid :: Gen (Maybe a)

shrinkInvalid :: Maybe a -> [Maybe a]

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

Defined in Data.GenValidity

Methods

genInvalid :: Gen (Ratio a)

shrinkInvalid :: Ratio a -> [Ratio a]

(GenUnchecked a, GenInvalid a) => GenInvalid (NonEmpty a)

Defined in Data.GenValidity

Methods

genInvalid :: Gen (NonEmpty a)

shrinkInvalid :: NonEmpty a -> [NonEmpty a]

(GenInvalid a, GenInvalid b) => GenInvalid (Either a b)

This instance ensures that the generated tupse contains at least one invalid element. The other element is unchecked.

Defined in Data.GenValidity

Methods

genInvalid :: Gen (Either a b)

shrinkInvalid :: Either a b -> [Either a b]

(GenUnchecked a, GenInvalid a, GenUnchecked b, GenInvalid b) => GenInvalid (a, b)

Defined in Data.GenValidity

Methods

genInvalid :: Gen (a, b)

shrinkInvalid :: (a, b) -> [(a, b)]

(GenUnchecked a, GenUnchecked b, GenUnchecked c, GenInvalid a, GenInvalid b, GenInvalid c) => GenInvalid (a, b, c)

This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.

Defined in Data.GenValidity

Methods

genInvalid :: Gen (a, b, c)

shrinkInvalid :: (a, b, c) -> [(a, b, c)]

(GenUnchecked a, GenUnchecked b, GenUnchecked c, GenUnchecked d, GenInvalid a, GenInvalid b, GenInvalid c, GenInvalid d) => GenInvalid (a, b, c, d)

This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.

Defined in Data.GenValidity

Methods

genInvalid :: Gen (a, b, c, d)

shrinkInvalid :: (a, b, c, d) -> [(a, b, c, d)]

(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)

This instance ensures that the generated triple contains at least one invalid element. The other two are unchecked.

Defined in Data.GenValidity

Methods

genInvalid :: Gen (a, b, c, d, e)

shrinkInvalid :: (a, b, c, d, e) -> [(a, b, c, d, e)]

Helper functions

genValidStructurally :: (Validity a, Generic a, GGenValid (Rep a)) => Gen a

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.

genValidStructurallyWithoutExtraChecking :: (Generic a, GGenValid (Rep a)) => Gen a

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.

shrinkValidStructurally :: (Validity a, Generic a, GValidRecursivelyShrink (Rep a), GValidSubterms (Rep a) a) => a -> [a]

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.

shrinkValidStructurallyWithoutExtraFiltering :: (Generic a, GValidRecursivelyShrink (Rep a), GValidSubterms (Rep a) a) => a -> [a]

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.

module Data.GenValidity.Utils

Strange, possibly useful functions

genUtf16SurrogateCodePoint :: Gen Char

Re-exports

module Data.Validity

The Generics magic

genericGenUnchecked :: (Generic a, GGenUnchecked (Rep a)) => Gen a

class GGenUnchecked f where

Methods

gGenUnchecked :: Gen (f a)

Instances

GGenUnchecked (U1 :: Type -> Type)

Defined in Data.GenValidity

Methods

gGenUnchecked :: Gen (U1 a)

GenUnchecked a => GGenUnchecked (K1 i a :: Type -> Type)

Defined in Data.GenValidity

Methods

gGenUnchecked :: Gen (K1 i a a0)

(GGenUnchecked a, GGenUnchecked b) => GGenUnchecked (a :+: b)

Defined in Data.GenValidity

Methods

gGenUnchecked :: Gen ((a :+: b) a0)

(GGenUnchecked a, GGenUnchecked b) => GGenUnchecked (a :*: b)

Defined in Data.GenValidity

Methods

gGenUnchecked :: Gen ((a :*: b) a0)

GGenUnchecked a => GGenUnchecked (M1 i c a)

Defined in Data.GenValidity

Methods

gGenUnchecked :: Gen (M1 i c a a0)

genericShrinkUnchecked :: (Generic a, GUncheckedRecursivelyShrink (Rep a), GUncheckedSubterms (Rep a) a) => a -> [a]

Shrink a term to any of its immediate subterms, and also recursively shrink all subterms.

uncheckedRecursivelyShrink :: (Generic a, GUncheckedRecursivelyShrink (Rep a)) => a -> [a]

Recursively shrink all immediate uncheckedSubterms.

class GUncheckedRecursivelyShrink f where

Methods

gUncheckedRecursivelyShrink :: f a -> [f a]

Instances

GUncheckedRecursivelyShrink (V1 :: Type -> Type)

Defined in Data.GenValidity

Methods

gUncheckedRecursivelyShrink :: V1 a -> [V1 a]

GUncheckedRecursivelyShrink (U1 :: Type -> Type)

Defined in Data.GenValidity

Methods

gUncheckedRecursivelyShrink :: U1 a -> [U1 a]

GenUnchecked a => GUncheckedRecursivelyShrink (K1 i a :: Type -> Type)

Defined in Data.GenValidity

Methods

gUncheckedRecursivelyShrink :: K1 i a a0 -> [K1 i a a0]

(GUncheckedRecursivelyShrink f, GUncheckedRecursivelyShrink g) => GUncheckedRecursivelyShrink (f :+: g)

Defined in Data.GenValidity

Methods

gUncheckedRecursivelyShrink :: (f :+: g) a -> [(f :+: g) a]

(GUncheckedRecursivelyShrink f, GUncheckedRecursivelyShrink g) => GUncheckedRecursivelyShrink (f :*: g)

Defined in Data.GenValidity

Methods

gUncheckedRecursivelyShrink :: (f :*: g) a -> [(f :*: g) a]

GUncheckedRecursivelyShrink f => GUncheckedRecursivelyShrink (M1 i c f)

Defined in Data.GenValidity

Methods

gUncheckedRecursivelyShrink :: M1 i c f a -> [M1 i c f a]

uncheckedSubterms :: (Generic a, GUncheckedSubterms (Rep a) a) => a -> [a]

All immediate uncheckedSubterms of a term.

class GUncheckedSubterms f a where

Methods

gUncheckedSubterms :: f a -> [a]

Instances

GUncheckedSubterms (V1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gUncheckedSubterms :: V1 a -> [a]

GUncheckedSubterms (U1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gUncheckedSubterms :: U1 a -> [a]

GUncheckedSubterms (K1 i a :: Type -> Type) b

Defined in Data.GenValidity

Methods

gUncheckedSubterms :: K1 i a b -> [b]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubterms (f :+: g) a

Defined in Data.GenValidity

Methods

gUncheckedSubterms :: (f :+: g) a -> [a]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubterms (f :*: g) a

Defined in Data.GenValidity

Methods

gUncheckedSubterms :: (f :*: g) a -> [a]

GUncheckedSubterms f a => GUncheckedSubterms (M1 i c f) a

Defined in Data.GenValidity

Methods

gUncheckedSubterms :: M1 i c f a -> [a]

class GUncheckedSubtermsIncl f a where

Methods

gUncheckedSubtermsIncl :: f a -> [a]

Instances

GUncheckedSubtermsIncl (V1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gUncheckedSubtermsIncl :: V1 a -> [a]

GUncheckedSubtermsIncl (U1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gUncheckedSubtermsIncl :: U1 a -> [a]

GUncheckedSubtermsIncl (K1 i a :: Type -> Type) b

Defined in Data.GenValidity

Methods

gUncheckedSubtermsIncl :: K1 i a b -> [b]

GUncheckedSubtermsIncl (K1 i a :: Type -> Type) a

Defined in Data.GenValidity

Methods

gUncheckedSubtermsIncl :: K1 i a a -> [a]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubtermsIncl (f :+: g) a

Defined in Data.GenValidity

Methods

gUncheckedSubtermsIncl :: (f :+: g) a -> [a]

(GUncheckedSubtermsIncl f a, GUncheckedSubtermsIncl g a) => GUncheckedSubtermsIncl (f :*: g) a

Defined in Data.GenValidity

Methods

gUncheckedSubtermsIncl :: (f :*: g) a -> [a]

GUncheckedSubtermsIncl f a => GUncheckedSubtermsIncl (M1 i c f) a

Defined in Data.GenValidity

Methods

gUncheckedSubtermsIncl :: M1 i c f a -> [a]

class GGenValid f where

Methods

gGenValid :: Gen (f a)

Instances

GGenValid (U1 :: Type -> Type)

Defined in Data.GenValidity

Methods

gGenValid :: Gen (U1 a)

GenValid a => GGenValid (K1 i a :: Type -> Type)

Defined in Data.GenValidity

Methods

gGenValid :: Gen (K1 i a a0)

(GGenValid a, GGenValid b) => GGenValid (a :+: b)

Defined in Data.GenValidity

Methods

gGenValid :: Gen ((a :+: b) a0)

(GGenValid a, GGenValid b) => GGenValid (a :*: b)

Defined in Data.GenValidity

Methods

gGenValid :: Gen ((a :*: b) a0)

GGenValid a => GGenValid (M1 i c a)

Defined in Data.GenValidity

Methods

gGenValid :: Gen (M1 i c a a0)

class GValidRecursivelyShrink f where

Methods

gValidRecursivelyShrink :: f a -> [f a]

Instances

GValidRecursivelyShrink (V1 :: Type -> Type)

Defined in Data.GenValidity

Methods

gValidRecursivelyShrink :: V1 a -> [V1 a]

GValidRecursivelyShrink (U1 :: Type -> Type)

Defined in Data.GenValidity

Methods

gValidRecursivelyShrink :: U1 a -> [U1 a]

GenValid a => GValidRecursivelyShrink (K1 i a :: Type -> Type)

Defined in Data.GenValidity

Methods

gValidRecursivelyShrink :: K1 i a a0 -> [K1 i a a0]

(GValidRecursivelyShrink f, GValidRecursivelyShrink g) => GValidRecursivelyShrink (f :+: g)

Defined in Data.GenValidity

Methods

gValidRecursivelyShrink :: (f :+: g) a -> [(f :+: g) a]

(GValidRecursivelyShrink f, GValidRecursivelyShrink g) => GValidRecursivelyShrink (f :*: g)

Defined in Data.GenValidity

Methods

gValidRecursivelyShrink :: (f :*: g) a -> [(f :*: g) a]

GValidRecursivelyShrink f => GValidRecursivelyShrink (M1 i c f)

Defined in Data.GenValidity

Methods

gValidRecursivelyShrink :: M1 i c f a -> [M1 i c f a]

structurallyValidSubterms :: (Generic a, GValidSubterms (Rep a) a) => a -> [a]

All immediate validSubterms of a term.

class GValidSubterms f a where

Methods

gValidSubterms :: f a -> [a]

Instances

GValidSubterms (V1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gValidSubterms :: V1 a -> [a]

GValidSubterms (U1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gValidSubterms :: U1 a -> [a]

GValidSubterms (K1 i a :: Type -> Type) b

Defined in Data.GenValidity

Methods

gValidSubterms :: K1 i a b -> [b]

(GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubterms (f :+: g) a

Defined in Data.GenValidity

Methods

gValidSubterms :: (f :+: g) a -> [a]

(GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubterms (f :*: g) a

Defined in Data.GenValidity

Methods

gValidSubterms :: (f :*: g) a -> [a]

GValidSubterms f a => GValidSubterms (M1 i c f) a

Defined in Data.GenValidity

Methods

gValidSubterms :: M1 i c f a -> [a]

class GValidSubtermsIncl f a where

Methods

gValidSubtermsIncl :: f a -> [a]

Instances

GValidSubtermsIncl (V1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gValidSubtermsIncl :: V1 a -> [a]

GValidSubtermsIncl (U1 :: Type -> Type) a

Defined in Data.GenValidity

Methods

gValidSubtermsIncl :: U1 a -> [a]

GValidSubtermsIncl (K1 i a :: Type -> Type) b

Defined in Data.GenValidity

Methods

gValidSubtermsIncl :: K1 i a b -> [b]

GValidSubtermsIncl (K1 i a :: Type -> Type) a

Defined in Data.GenValidity

Methods

gValidSubtermsIncl :: K1 i a a -> [a]

(GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubtermsIncl (f :+: g) a

Defined in Data.GenValidity

Methods

gValidSubtermsIncl :: (f :+: g) a -> [a]

(GValidSubtermsIncl f a, GValidSubtermsIncl g a) => GValidSubtermsIncl (f :*: g) a

Defined in Data.GenValidity

Methods

gValidSubtermsIncl :: (f :*: g) a -> [a]

GValidSubtermsIncl f a => GValidSubtermsIncl (M1 i c f) a

Defined in Data.GenValidity

Methods

gValidSubtermsIncl :: M1 i c f a -> [a]