-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Testing utilities for the validity library
--   
--   Note: There are companion instance packages for this library:
--   
--   <ul>
--   <li><a>genvalidity-aeson</a></li>
--   <li><a>genvalidity-bytestring</a></li>
--   <li><a>genvalidity-containers</a></li>
--   <li><a>genvalidity-path</a></li>
--   <li><a>genvalidity-scientific</a></li>
--   <li><a>genvalidity-text</a></li>
--   <li><a>genvalidity-time</a></li>
--   <li><a>genvalidity-unordered-containers</a></li>
--   <li><a>genvalidity-uuid</a></li>
--   <li><a>genvalidity-vector</a></li>
--   </ul>
@package genvalidity
@version 0.9.0.0


-- | <tt>GenValidity</tt> exists to make tests involving <tt>Validity</tt>
--   types easier and speed up the generation of data for them.
--   
--   Let's use the example from <tt>Data.Validity</tt> 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 <tt>(Prime <a>$</a> arbitrary) <a>suchThat</a> isValid</tt>
--   but this is tedious and inefficient.
--   
--   The <tt>GenValid</tt> 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 <tt>GenUnchecked</tt>
--   already gives you access to a default instance of <tt>GenValid</tt>
--   and <tt>GenInvalid</tt> 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:
--   
--   <pre>
--   instance GenUnchecked Prime where
--       genUnchecked = Prime &lt;$&gt; arbitrary
--   </pre>
--   
--   <pre>
--   instance GenValid Prime where
--       genValid = Prime &lt;$&gt;
--          (oneof
--            [ pure 2
--            , ((\y -&gt; 2 * abs y + 1) &lt;$&gt; arbitrary) `suchThat` isPrime)
--            ])
--   </pre>
--   
--   Typical examples of tests involving validity could look as follows:
--   
--   <pre>
--   it "succeeds when given valid input" $ do
--       forAllValid $ \input -&gt;
--           myFunction input `shouldSatisfy` isRight
--   </pre>
--   
--   <pre>
--   it "produces valid output when it succeeds" $ do
--       forAllUnchecked $ \input -&gt;
--           case myFunction input of
--               Nothing -&gt; return () -- Can happen
--               Just output -&gt; output `shouldSatisfy` isValid
--   </pre>
--   
--   Definitely also look at the genvalidity-property and genvalidity-hspec
--   packages for more info on how to use this package.
module Data.GenValidity

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

-- | A class of types for which valid values can be generated.
--   
--   <h3>How to instantiate <a>GenValid</a></h3>
--   
--   <b>Step 1</b>: Try to instantiate <a>GenValid</a> without overriding
--   any functions. This is only possible if your type has a
--   <a>GenUnchecked</a> 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.
--   
--   <b>Step 2</b>: Try to instantiate <a>GenValid</a> using the helper
--   functions via <a>Generic</a> This involves using
--   <a>genValidStructurally</a> to override <a>genValid</a> and using
--   <a>shrinkValidStructurally</a> to override <a>shrinkValid</a>.
--   <b>Every time you override <a>genValid</a>, you should also override
--   <a>shrinkValid</a></b>
--   
--   <b>Step 3</b>: If the above is not possible due to lack of a
--   <a>Generic</a> instance, then you should emulate what
--   <a>genValidStructurally</a> does. This means that all sub-parts should
--   be generated using <a>genValid</a>. Make sure to generate any possible
--   valid value, but only valid values.
--   
--   <h3>A note about <a>Arbitrary</a></h3>
--   
--   If you also write <tt>Arbitrary</tt> instances for <tt>GenValid</tt>
--   types, it may be best to simply use
--   
--   <pre>
--   arbitrary = genValid
--   shrink = shrinkValid
--   </pre>
class Validity a => GenValid a

-- | Generate a valid datum, this should cover all possible valid values in
--   the type
--   
--   The default implementation is as follows:
--   
--   <pre>
--   genValid = genUnchecked `suchThat` isValid
--   </pre>
--   
--   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 :: GenValid a => Gen a

-- | Generate a valid datum, this should cover all possible valid values in
--   the type
--   
--   The default implementation is as follows:
--   
--   <pre>
--   genValid = genUnchecked `suchThat` isValid
--   </pre>
--   
--   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 :: (GenValid a, GenUnchecked a) => Gen a

-- | Shrink a valid value.
--   
--   The default implementation is as follows:
--   
--   <pre>
--   shrinkValid = filter isValid . shrinkUnchecked
--   </pre>
--   
--   It is important that this shrinking function only shrinks values to
--   valid values. If <a>shrinkValid</a> 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 :: GenValid a => a -> [a]

-- | Shrink a valid value.
--   
--   The default implementation is as follows:
--   
--   <pre>
--   shrinkValid = filter isValid . shrinkUnchecked
--   </pre>
--   
--   It is important that this shrinking function only shrinks values to
--   valid values. If <a>shrinkValid</a> 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 :: (GenValid a, GenUnchecked a) => a -> [a]

-- | A class of types for which invalid values can be generated.
--   
--   <h3>How to instantiate <a>GenInvalid</a></h3>
--   
--   <b>Step 1</b>: Realise that you probably do not want to. It makes no
--   sense, and serves no purpose, to instantiate <a>GenInvalid</a> 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 <a>GenInvalid</a> 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.
--   
--   <b>Step 2</b>: Instantiate <a>GenInvalid</a> without overriding any
--   functions.
class Validity a => GenInvalid a

-- | Generate an invalid datum, this should cover all possible invalid
--   values
--   
--   <pre>
--   genInvalid = genUnchecked `suchThat` isInvalid
--   </pre>
--   
--   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 :: GenInvalid a => Gen a

-- | Generate an invalid datum, this should cover all possible invalid
--   values
--   
--   <pre>
--   genInvalid = genUnchecked `suchThat` isInvalid
--   </pre>
--   
--   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 :: (GenInvalid a, GenUnchecked a) => Gen a
shrinkInvalid :: GenInvalid a => a -> [a]
shrinkInvalid :: (GenInvalid a, GenUnchecked a) => a -> [a]

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

-- | Generate a valid value by generating all the sub parts using the
--   <a>Generic</a> instance,
--   
--   This generator is _not_ guaranteed to generate a valid value.
--   
--   This is probably _not_ the function that you are looking for when
--   overriding <a>genValid</a> _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

-- | 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.
--   
--   <pre>
--   shrinkValidStructurally = filter isValid . shrinkValidStructurallyWithoutExtraFiltering
--   </pre>
--   
--   This is probably the function that you are looking for.
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.
--   
--   This shrinking function is _not_ guaranteed to shrink to valid values.
--   
--   This is probably _not_ the function that you are looking for when
--   overriding <a>shrinkValid</a> _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]

-- | <a>upTo</a> generates an integer between 0 (inclusive) and <tt>n</tt>.
upTo :: Int -> Gen Int

-- | 'genSplit a' generates a tuple '(b, c)' such that 'b + c' equals
--   <tt>a</tt>.
genSplit :: Int -> Gen (Int, Int)

-- | 'genSplit3 a' generates a triple '(b, c, d)' such that 'b + c + d'
--   equals <tt>a</tt>.
genSplit3 :: Int -> Gen (Int, Int, Int)

-- | 'genSplit4 a' generates a quadruple '(b, c, d, e)' such that 'b + c +
--   d + e' equals <tt>a</tt>.
genSplit4 :: Int -> Gen (Int, Int, Int, Int)

-- | 'genSplit5 a' generates a quintuple '(b, c, d, e, f)' such that 'b + c
--   + d + e + f' equals <tt>a</tt>.
genSplit5 :: Int -> Gen (Int, Int, Int, Int, Int)

-- | 'arbPartition n' generates a list <tt>ls</tt> such that 'sum ls'
--   equals <tt>n</tt>.
arbPartition :: Int -> Gen [Int]

-- | Generates a random permutation of the given list.
shuffle :: () => [a] -> Gen [a]

-- | A version of <tt>listOf</tt> that takes size into account more
--   accurately.
--   
--   This generator distributes the size that is is given among the values
--   in the list that it generates.
genListOf :: Gen a -> Gen [a]
shrinkTuple :: (a -> [a]) -> (b -> [b]) -> (a, b) -> [(a, b)]

-- | Turn a shrinking function into a function that shrinks tuples.
shrinkT2 :: (a -> [a]) -> (a, a) -> [(a, a)]

-- | Turn a shrinking function into a function that shrinks triples.
shrinkT3 :: (a -> [a]) -> (a, a, a) -> [(a, a, a)]

-- | Turn a shrinking function into a function that shrinks quadruples.
shrinkT4 :: (a -> [a]) -> (a, a, a, a) -> [(a, a, a, a)]
genUtf16SurrogateCodePoint :: Gen Char
genericGenUnchecked :: (Generic a, GGenUnchecked (Rep a)) => Gen a
class GGenUnchecked f
gGenUnchecked :: GGenUnchecked f => Gen (f a)

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

-- | Recursively shrink all immediate uncheckedSubterms.
uncheckedRecursivelyShrink :: (Generic a, GUncheckedRecursivelyShrink (Rep a)) => a -> [a]
class GUncheckedRecursivelyShrink f
gUncheckedRecursivelyShrink :: GUncheckedRecursivelyShrink f => f a -> [f a]

-- | All immediate uncheckedSubterms of a term.
uncheckedSubterms :: (Generic a, GUncheckedSubterms (Rep a) a) => a -> [a]
class GUncheckedSubterms f a
gUncheckedSubterms :: GUncheckedSubterms f a => f a -> [a]
class GUncheckedSubtermsIncl f a
gUncheckedSubtermsIncl :: GUncheckedSubtermsIncl f a => f a -> [a]
class GGenValid f
gGenValid :: GGenValid f => Gen (f a)
class GValidRecursivelyShrink f
gValidRecursivelyShrink :: GValidRecursivelyShrink f => f a -> [f a]

-- | All immediate validSubterms of a term.
structurallyValidSubterms :: (Generic a, GValidSubterms (Rep a) a) => a -> [a]
class GValidSubterms f a
gValidSubterms :: GValidSubterms f a => f a -> [a]
class GValidSubtermsIncl f a
gValidSubtermsIncl :: GValidSubtermsIncl f a => f a -> [a]
instance (Data.GenValidity.GValidSubtermsIncl f a, Data.GenValidity.GValidSubtermsIncl g a) => Data.GenValidity.GValidSubterms (f GHC.Generics.:*: g) a
instance (Data.GenValidity.GValidSubtermsIncl f a, Data.GenValidity.GValidSubtermsIncl g a) => Data.GenValidity.GValidSubterms (f GHC.Generics.:+: g) a
instance Data.GenValidity.GValidSubtermsIncl GHC.Generics.V1 a
instance Data.GenValidity.GValidSubtermsIncl GHC.Generics.U1 a
instance (Data.GenValidity.GValidSubtermsIncl f a, Data.GenValidity.GValidSubtermsIncl g a) => Data.GenValidity.GValidSubtermsIncl (f GHC.Generics.:*: g) a
instance (Data.GenValidity.GValidSubtermsIncl f a, Data.GenValidity.GValidSubtermsIncl g a) => Data.GenValidity.GValidSubtermsIncl (f GHC.Generics.:+: g) a
instance Data.GenValidity.GValidSubtermsIncl f a => Data.GenValidity.GValidSubtermsIncl (GHC.Generics.M1 i c f) a
instance Data.GenValidity.GValidSubtermsIncl (GHC.Generics.K1 i a) a
instance Data.GenValidity.GValidSubtermsIncl (GHC.Generics.K1 i a) b
instance Data.GenValidity.GValidSubterms GHC.Generics.V1 a
instance Data.GenValidity.GValidSubterms GHC.Generics.U1 a
instance Data.GenValidity.GValidSubterms f a => Data.GenValidity.GValidSubterms (GHC.Generics.M1 i c f) a
instance Data.GenValidity.GValidSubterms (GHC.Generics.K1 i a) b
instance (Data.GenValidity.GValidRecursivelyShrink f, Data.GenValidity.GValidRecursivelyShrink g) => Data.GenValidity.GValidRecursivelyShrink (f GHC.Generics.:*: g)
instance (Data.GenValidity.GValidRecursivelyShrink f, Data.GenValidity.GValidRecursivelyShrink g) => Data.GenValidity.GValidRecursivelyShrink (f GHC.Generics.:+: g)
instance Data.GenValidity.GValidRecursivelyShrink f => Data.GenValidity.GValidRecursivelyShrink (GHC.Generics.M1 i c f)
instance Data.GenValidity.GenValid a => Data.GenValidity.GValidRecursivelyShrink (GHC.Generics.K1 i a)
instance Data.GenValidity.GValidRecursivelyShrink GHC.Generics.U1
instance Data.GenValidity.GValidRecursivelyShrink GHC.Generics.V1
instance Data.GenValidity.GGenValid GHC.Generics.U1
instance (Data.GenValidity.GGenValid a, Data.GenValidity.GGenValid b) => Data.GenValidity.GGenValid (a GHC.Generics.:*: b)
instance (Data.GenValidity.GGenValid a, Data.GenValidity.GGenValid b) => Data.GenValidity.GGenValid (a GHC.Generics.:+: b)
instance Data.GenValidity.GGenValid a => Data.GenValidity.GGenValid (GHC.Generics.M1 i c a)
instance Data.GenValidity.GenValid a => Data.GenValidity.GGenValid (GHC.Generics.K1 i a)
instance (Data.GenValidity.GUncheckedSubtermsIncl f a, Data.GenValidity.GUncheckedSubtermsIncl g a) => Data.GenValidity.GUncheckedSubterms (f GHC.Generics.:*: g) a
instance (Data.GenValidity.GUncheckedSubtermsIncl f a, Data.GenValidity.GUncheckedSubtermsIncl g a) => Data.GenValidity.GUncheckedSubterms (f GHC.Generics.:+: g) a
instance Data.GenValidity.GUncheckedSubtermsIncl GHC.Generics.V1 a
instance Data.GenValidity.GUncheckedSubtermsIncl GHC.Generics.U1 a
instance (Data.GenValidity.GUncheckedSubtermsIncl f a, Data.GenValidity.GUncheckedSubtermsIncl g a) => Data.GenValidity.GUncheckedSubtermsIncl (f GHC.Generics.:*: g) a
instance (Data.GenValidity.GUncheckedSubtermsIncl f a, Data.GenValidity.GUncheckedSubtermsIncl g a) => Data.GenValidity.GUncheckedSubtermsIncl (f GHC.Generics.:+: g) a
instance Data.GenValidity.GUncheckedSubtermsIncl f a => Data.GenValidity.GUncheckedSubtermsIncl (GHC.Generics.M1 i c f) a
instance Data.GenValidity.GUncheckedSubtermsIncl (GHC.Generics.K1 i a) a
instance Data.GenValidity.GUncheckedSubtermsIncl (GHC.Generics.K1 i a) b
instance (Data.GenValidity.GenValid a, Data.GenValidity.GenValid b) => Data.GenValidity.GenValid (a, b)
instance (Data.GenValidity.GenValid a, Data.GenValidity.GenValid b) => Data.GenValidity.GenValid (Data.Either.Either a b)
instance (Data.GenValidity.GenValid a, Data.GenValidity.GenValid b, Data.GenValidity.GenValid c) => Data.GenValidity.GenValid (a, b, c)
instance (Data.GenValidity.GenValid a, Data.GenValidity.GenValid b, Data.GenValidity.GenValid c, Data.GenValidity.GenValid d) => Data.GenValidity.GenValid (a, b, c, d)
instance (Data.GenValidity.GenValid a, Data.GenValidity.GenValid b, Data.GenValidity.GenValid c, Data.GenValidity.GenValid d, Data.GenValidity.GenValid e) => Data.GenValidity.GenValid (a, b, c, d, e)
instance Data.GenValidity.GenValid a => Data.GenValidity.GenValid (GHC.Maybe.Maybe a)
instance Data.GenValidity.GenValid a => Data.GenValidity.GenValid (GHC.Base.NonEmpty a)
instance Data.GenValidity.GenValid a => Data.GenValidity.GenValid [a]
instance Data.GenValidity.GenValid ()
instance Data.GenValidity.GenValid GHC.Types.Bool
instance Data.GenValidity.GenValid GHC.Types.Ordering
instance Data.GenValidity.GenValid GHC.Types.Char
instance Data.GenValidity.GenValid GHC.Types.Int
instance Data.GenValidity.GenValid GHC.Int.Int8
instance Data.GenValidity.GenValid GHC.Int.Int16
instance Data.GenValidity.GenValid GHC.Int.Int32
instance Data.GenValidity.GenValid GHC.Int.Int64
instance Data.GenValidity.GenValid GHC.Types.Word
instance Data.GenValidity.GenValid GHC.Word.Word8
instance Data.GenValidity.GenValid GHC.Word.Word16
instance Data.GenValidity.GenValid GHC.Word.Word32
instance Data.GenValidity.GenValid GHC.Word.Word64
instance Data.GenValidity.GenValid GHC.Types.Float
instance Data.GenValidity.GenValid GHC.Types.Double
instance Data.GenValidity.GenValid GHC.Integer.Type.Integer
instance Data.GenValidity.GenValid GHC.Natural.Natural
instance (GHC.Real.Integral a, GHC.Num.Num a, GHC.Classes.Ord a, Data.GenValidity.GenValid a) => Data.GenValidity.GenValid (GHC.Real.Ratio a)
instance Data.Fixed.HasResolution a => Data.GenValidity.GenValid (Data.Fixed.Fixed a)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenInvalid a, Data.GenValidity.GenUnchecked b, Data.GenValidity.GenInvalid b) => Data.GenValidity.GenInvalid (a, b)
instance (Data.GenValidity.GenInvalid a, Data.GenValidity.GenInvalid b) => Data.GenValidity.GenInvalid (Data.Either.Either a b)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b, Data.GenValidity.GenUnchecked c, Data.GenValidity.GenInvalid a, Data.GenValidity.GenInvalid b, Data.GenValidity.GenInvalid c) => Data.GenValidity.GenInvalid (a, b, c)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b, Data.GenValidity.GenUnchecked c, Data.GenValidity.GenUnchecked d, Data.GenValidity.GenInvalid a, Data.GenValidity.GenInvalid b, Data.GenValidity.GenInvalid c, Data.GenValidity.GenInvalid d) => Data.GenValidity.GenInvalid (a, b, c, d)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b, Data.GenValidity.GenUnchecked c, Data.GenValidity.GenUnchecked d, Data.GenValidity.GenUnchecked e, Data.GenValidity.GenInvalid a, Data.GenValidity.GenInvalid b, Data.GenValidity.GenInvalid c, Data.GenValidity.GenInvalid d, Data.GenValidity.GenInvalid e) => Data.GenValidity.GenInvalid (a, b, c, d, e)
instance Data.GenValidity.GenInvalid a => Data.GenValidity.GenInvalid (GHC.Maybe.Maybe a)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenInvalid a) => Data.GenValidity.GenInvalid (GHC.Base.NonEmpty a)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenInvalid a) => Data.GenValidity.GenInvalid [a]
instance (GHC.Real.Integral a, GHC.Num.Num a, GHC.Classes.Ord a, Data.Validity.Validity a, Data.GenValidity.GenUnchecked a) => Data.GenValidity.GenInvalid (GHC.Real.Ratio a)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b) => Data.GenValidity.GenUnchecked (a, b)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b) => Data.GenValidity.GenUnchecked (Data.Either.Either a b)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b, Data.GenValidity.GenUnchecked c) => Data.GenValidity.GenUnchecked (a, b, c)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b, Data.GenValidity.GenUnchecked c, Data.GenValidity.GenUnchecked d) => Data.GenValidity.GenUnchecked (a, b, c, d)
instance (Data.GenValidity.GenUnchecked a, Data.GenValidity.GenUnchecked b, Data.GenValidity.GenUnchecked c, Data.GenValidity.GenUnchecked d, Data.GenValidity.GenUnchecked e) => Data.GenValidity.GenUnchecked (a, b, c, d, e)
instance Data.GenValidity.GenUnchecked a => Data.GenValidity.GenUnchecked (GHC.Maybe.Maybe a)
instance Data.GenValidity.GenUnchecked a => Data.GenValidity.GenUnchecked (GHC.Base.NonEmpty a)
instance Data.GenValidity.GenUnchecked a => Data.GenValidity.GenUnchecked [a]
instance Data.GenValidity.GenUnchecked ()
instance Data.GenValidity.GenUnchecked GHC.Types.Bool
instance Data.GenValidity.GenUnchecked GHC.Types.Ordering
instance Data.GenValidity.GenUnchecked GHC.Types.Char
instance Data.GenValidity.GenUnchecked GHC.Types.Int
instance Data.GenValidity.GenUnchecked GHC.Int.Int8
instance Data.GenValidity.GenUnchecked GHC.Int.Int16
instance Data.GenValidity.GenUnchecked GHC.Int.Int32
instance Data.GenValidity.GenUnchecked GHC.Int.Int64
instance Data.GenValidity.GenUnchecked GHC.Types.Word
instance Data.GenValidity.GenUnchecked GHC.Word.Word8
instance Data.GenValidity.GenUnchecked GHC.Word.Word16
instance Data.GenValidity.GenUnchecked GHC.Word.Word32
instance Data.GenValidity.GenUnchecked GHC.Word.Word64
instance Data.GenValidity.GenUnchecked GHC.Types.Float
instance Data.GenValidity.GenUnchecked GHC.Types.Double
instance Data.GenValidity.GenUnchecked GHC.Integer.Type.Integer
instance Data.GenValidity.GenUnchecked GHC.Natural.Natural
instance (GHC.Real.Integral a, Data.GenValidity.GenUnchecked a) => Data.GenValidity.GenUnchecked (GHC.Real.Ratio a)
instance Data.Fixed.HasResolution a => Data.GenValidity.GenUnchecked (Data.Fixed.Fixed a)
instance Data.GenValidity.GenUnchecked a => Data.GenValidity.GGenUnchecked (GHC.Generics.K1 i a)
instance Data.GenValidity.GenUnchecked a => Data.GenValidity.GUncheckedRecursivelyShrink (GHC.Generics.K1 i a)
instance Data.GenValidity.GUncheckedSubterms GHC.Generics.V1 a
instance Data.GenValidity.GUncheckedSubterms GHC.Generics.U1 a
instance Data.GenValidity.GUncheckedSubterms f a => Data.GenValidity.GUncheckedSubterms (GHC.Generics.M1 i c f) a
instance Data.GenValidity.GUncheckedSubterms (GHC.Generics.K1 i a) b
instance (Data.GenValidity.GUncheckedRecursivelyShrink f, Data.GenValidity.GUncheckedRecursivelyShrink g) => Data.GenValidity.GUncheckedRecursivelyShrink (f GHC.Generics.:*: g)
instance (Data.GenValidity.GUncheckedRecursivelyShrink f, Data.GenValidity.GUncheckedRecursivelyShrink g) => Data.GenValidity.GUncheckedRecursivelyShrink (f GHC.Generics.:+: g)
instance Data.GenValidity.GUncheckedRecursivelyShrink f => Data.GenValidity.GUncheckedRecursivelyShrink (GHC.Generics.M1 i c f)
instance Data.GenValidity.GUncheckedRecursivelyShrink GHC.Generics.U1
instance Data.GenValidity.GUncheckedRecursivelyShrink GHC.Generics.V1
instance Data.GenValidity.GGenUnchecked GHC.Generics.U1
instance (Data.GenValidity.GGenUnchecked a, Data.GenValidity.GGenUnchecked b) => Data.GenValidity.GGenUnchecked (a GHC.Generics.:*: b)
instance (Data.GenValidity.GGenUnchecked a, Data.GenValidity.GGenUnchecked b) => Data.GenValidity.GGenUnchecked (a GHC.Generics.:+: b)
instance Data.GenValidity.GGenUnchecked a => Data.GenValidity.GGenUnchecked (GHC.Generics.M1 i c a)

module Data.GenRelativeValidity
class (GenUnchecked a, RelativeValidity a b, GenRelativeUnchecked a b) => GenRelativeInvalid a b
genInvalidFor :: GenRelativeInvalid a b => b -> Gen a
class (GenValid a, RelativeValidity a b) => GenRelativeValid a b
genValidFor :: GenRelativeValid a b => b -> Gen a
class (GenUnchecked a, RelativeValidity a b) => GenRelativeUnchecked a b
genUncheckedFor :: GenRelativeUnchecked a b => b -> Gen a