h&s+      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  Safe-Inferred%%'()*12589:;<=?falsify,Binary encoding (most significant bit first)falsify Elias  codePrecondition: input x >= 1.See  0https://en.wikipedia.org/wiki/Elias_gamma_coding .falsify.Extension of Elias  coding to signed integersThis is adapted from integerVariant in Test.QuickCheck.Random. The first bit encs whether x >= 1 or not (this will result in 0 and 1 having short codes).  Safe-Inferred%%'()*12589:;<=?}falsify4Traverse the argument, generating all values marked #, and replacing all values marked  by    Safe-Inferred%%'()*12589:;<=?falsify"Permutation is a sequence of swapsfalsifyTake chunks of a non-empty list This is lazy:  NE.take 4 $ chunksOfNonEmpty 3 (0 :| [1..]) == [ 0 :| [1,2] , 3 :| [4,5] , 6 :| [7,8] , 9 :| [10,11] ]   Safe-Inferred%%'()*12589:;<=? falsifySize of the tree O(1)falsify Propagate  marker down the tree#This is useful in conjunction with #, which truncates entire subtrees.falsify%Generate those values we want to keep#Whenever we meet an element marked !, that entire subtree is dropped.falsify(Change enough nodes currently marked as  to  to ensure at least n nodes are marked .Precondition: any & marks must have been propagated; see -. Postcondition: this property is preserved.falsify?Compute interval with inclusive bounds, without exceeding rangeReturns  if the interval is empty, and Just0 the inclusive lower and upper bound otherwise.falsifyLook value up in BST NOTE: The   datatype itself does NOT guarantee that the tree is in fact a BST. It is the responsibility of the caller to ensure this.    Safe-Inferred&%'()*12589:;<=? N Safe-Inferred%%'()*12589:;<=?falsifyRange of valuesfalsifyConstant (point) rangefalsify%Construct values in the range from a !This is the main constructor for .falsify-Evaluate each range and choose the "smallest"Each value in the range is annotated with some distance metric; for example, this could be the distance to some predefined point (e.g. as in )falsifyPrecision (in bits)falsifyValue x such that  0 <= x < 1falsifyShow instance relies on the  pattern synonym Safe-Inferred%%'()*12589:;<=? falsifySampleThe samples in the  record if they were the originally produced sample, or whether they have been shrunk.falsify Sample treeA sample tree is a (conceptually and sometimes actually) infinite tree representing drawing values from and splitting a PRNG.falsifyDefault constructorThe type of ST is really 6ST :: Word64 & (SampleTree * SampleTree) -> SampleTreewhere (&) is the additive conjunction from linear logic. In other words, the intention is that either the Word64 is used, or, the pair of subtrees; put another way, we either draw a value from the PRNG, or" split it into two new PRNGs. See  and split.falsifyMinimal tree (0 everywhere)This constructor allows us to represent an infinite tree in a finite way and, importantly,  recognize a tree that is minimal everywhere. This is necessary when shrinking in the context of generators that generate infinitely large values.falsify8Pattern synonym for treating the sample tree as infinitefalsifyMinimal sample treeGenerators should produce the "simplest" value when given this tree, for some suitable application-specific definition of "simple".falsify.Sample tree that is the given value everywhere'This is primarily useful for debugging.falsify0Map function over all random samples in the tree/Precondition: the function must preserve zeros: f 0 == 0This means that we have  map f M == M'This is primarily useful for debugging.falsifyApply mod m at every sample in the tree'This is primarily useful for debugging. Safe-Inferred%%'()*12589:;<=? Lfalsify Binary search.Compute one step of a binary search algorithm. Examples: binarySearch 0 == [] binarySearch 1 == [0] binarySearch 2 == [0,1] binarySearch 3 == [0,2] binarySearch 4 == [0,2,3] binarySearch 5 == [0,3,4] binarySearch 6 == [0,3,5] binarySearch 7 == [0,4,6] binarySearch 8 == [0,4,6,7] binarySearch 9 == [0,5,7,8] binarySearch 10 == [0,5,8,9] binarySearch 16 == [0,8,12,14,15] binarySearch 127 == [0,64,96,112,120,124,126] binarySearch 128 == [0,64,96,112,120,124,126,127];The gap between each successive number halves at each step.NOTE:  introduces a bias for even numbers: when shrinking succeeds with the first (non-zero) option, the number is basically halved each at step; since halving an even number results in another even number, and halving an odd number also results in an even number, this results in a strong bias towards even numbers. See also .falsify!Binary search without parity biasFor some cases the parity (even or odd) of a number is very important, and unfotunately standard binary search is not very good at allowing search to flip between even and odd. For example, if we start with , every# possibly shrink value computed by  is even. The situation is less extreme for other numbers, but it's nonetheless something we need to take into account.In this function we pair each possible shrunk value with the corresponding value of opposite parity, ordered in such a way that we try to shrink to opposite parity first. Examples: binarySearchNoParityBias 0 == [] binarySearchNoParityBias 1 == [0] binarySearchNoParityBias 2 == [1,0] binarySearchNoParityBias 3 == [0,1,2] binarySearchNoParityBias 4 == [1,0,3,2] binarySearchNoParityBias 5 == [0,1,2,3,4] binarySearchNoParityBias 6 == [1,0,3,2,5,4] binarySearchNoParityBias 7 == [0,1,4,5,6] binarySearchNoParityBias 8 == [1,0,5,4,7,6] binarySearchNoParityBias 9 == [0,1,4,5,6,7,8] binarySearchNoParityBias 10 == [1,0,5,4,9,8] binarySearchNoParityBias 16 == [1,0,9,8,13,12,15,14] binarySearchNoParityBias 127 == [0,1,64,65,96,97,112,113,120,121,124,125,126] binarySearchNoParityBias 128 == [1,0,65,64,97,96,113,112,121,120,125,124,127,126]falsify Auxiliary to Given a number n, compute a set of steps  n1, n2, .. such that sum [n1, n2, ..] == n, the distance between each subsequent step is halved, and all steps are non-zero. For example: &deltas 200 == [100,50,25,12,6,3,2,1,1] Safe-Inferred%%'()*12589:;<=?/* falsifyGenerator of a random value)Generators can be combined through their ,  and ) interfaces. The primitive generator is , but most users will probably want to construct their generators using the predefined from Test.Falsify.Generator as building blocks.Generators support "internal integrated shrinking". Shrinking is  integrated in the sense of Hedgehog, meaning that we don't write a separate shrinker at all, but the shrink behaviour is implied by the generator. For example, if you have a generator genList for a list of numbers, then filter even <$> genListwill only generate even numbers, and that property is automatically preserved during shrinking. Shrinking is internal in the sense of Hypothesis, meaning that unlike in Hedgehog, shrinking works correctly even in the context of monadic bind. For example, if you do 2do n <- genListLength replicateM n someOtherGenthen we can shrink n and the results from  someOtherGen in any order (that said, users may prefer to use the dedicated  generator for this purpose, which improves on this in a few ways).NOTE:  is NOT an instance of  Alternative; this would not be compatible with the generation of infinite data structures. For the same reason, we do not have a monad transformer version of Gen either.falsify*Combine shrunk left and right sample trees"This is an internal function only.falsify Varation on (>>=)$ that doesn't apply the shortcut to 0This function is primarily useful for debugging falsify, itself; users will probably never need it.falsifySelective bindUnlike monadic bind, the RHS is generated and shrunk completely independently for each different value of a produced by the LHS.This is a generalization of  to arbitrary integral values; it is also much more efficient than .NOTE: This is only one way to make a generator independent. See  for more primitive combinator.falsifyRun generator on different part of the sample tree depending on afalsifyUniform selection of *, shrinking towards 0, using binary searchThis is a primitive generator; most users will probably not want to use this generator directly.falsifyGeneralization of - that allows to override the shrink behaviourThis is only required in rare circumstances. Most users will probably never need to use this generator.falsifyGenerate arbitrary value x <= nUnlike , * does not execute binary search. Instead, all smaller values are considered. This is potentially very expensive; the primary use case for this generator is testing shrinking behaviour, where binary search can lead to some unpredicatable results. This does NOT! do uniform selection: for small n<, the generator will with overwhelming probability produce n itself as initial value.This is a primitive generator; most users will probably not want to use this generator directly.falsifyCapture the local sample treeThis generator does not shrink.falsify(Disable shrinking in the given generatorDue to the nature of internal shrinking, it is always possible that a generator gets reapplied to samples that were shrunk wrt to a  different generator. In this sense, ) should be considered to be a hint only.This function is only occassionally necessary; most users will probably not need to use it.falsifyOriginal and shrunk left treesfalsifyOriginal and shrunk right trees  Safe-Inferred%%'()*12589:;<=?5 falsify8Does a given shrunk value represent a valid shrink step?falsifyShrink explanationfalsify-We successfully executed a single shrink stepfalsifyWe could no shrink any furtherWe also record all rejected next steps. This is occasionally useful when trying to figure out why a value didn't shrink any further (what did it try to shrink to?)falsifyWe stopped shrinking early8This is used when the number of shrink steps is limited.falsifyShrink explanationp is the type of "positive" elements that satisfied the predicate (i.e., valid shrinks), and n( is the type of "negative" which didn't.falsify&The value we started, before shrinkingfalsifyThe full shrink historyfalsify?Simplify the shrink explanation to keep only the shrink historyfalsify0The final shrunk value, as well as all rejected next shrunk steps"The list of rejected next steps isNothing$ if shrinking was terminated early ()Just [] if the final value truly is minimal (typically, it is only minimal wrt to a particular properly, but not the minimal value that a generator can produce).falsifyFind smallest value that the generator can produce and still satisfies the predicate. Returns the full shrink history.To avoid boolean blindness, we use different types for values that satisfy the property and values that do not.(This is lazy in the shrink history; see ) to limit the number of shrinking steps.falsifyInitial result of the generator Safe-Inferred%%'()*12589:;<=?6F  Safe-Inferred%%'()*12589:;<=?J<falsifyN-ary predicateA predicate of type  Predicate '[Int, Bool, Char, ..]is essentially a function !Int -> Bool -> Char -> .. -> Bool, along with some metadata about that function that allows us to render it in a human readable way. In particular, we construct an !8 for the values that the predicate has been applied to.falsifyPrimitive generatorfalsifyPredicate that always passesfalsifyPredicate that always failsfalsify Conjunctionfalsify AbstractionfalsifyPartial applicationfalsifyFunction compostionfalsify!Analogue of 'Control.Arrow.(***)'falsify Analogue of falsifyChoicefalsify#Predicate that ignores its argumentfalsify(Error message (when the predicate fails)falsify Input to a falsifyExpression describing the inputfalsifyRendered value of the inputfalsifyThe input proper falsify$Function (used for composition of a  with a function)falsify,Function that is visible in rendered resultsfalsify7Function that should not be visible in rendered resultsSee % for an example.!falsifySimple expression language>The internal details of this type are (currently) not exposed.falsifyVariablefalsify ApplicationfalsifyNon-associative infix operatorfalsifyVariable#falsify"Default constructor for a function$falsifyGeneralization of # that does not depend on %falsify;Function that should not be visible in any rendered failureConsider these two predicates: p1, p2 :: Predicate '[Char, Char] p1 = P.eq `P.on` (P.fn "ord" ord) p2 = P.eq `P.on` (P.transparent ord)Both of these compare two characters on their codepoints (through ord), but they result in different failures. The first would give us something like <(ord x) /= (ord y) x : 'a' y : 'b' ord x: 97 ord y: 98/whereas the second might give us something like x /= y x: 'a' y: 'b'which of these is more useful is of course application dependent.falsifyApply function to an argument/If the funciton is visible, we also return the input to the function (so that we can render both the input and the output); we return  for transparent functions.falsify&Primitive way to construct a predicate/This is (currently) not part of the public API.&falsify Constant 'falsify Constant (falsifyUnary predicateThis is essentially a function  a -> Bool; see  for detailed discussion.)falsifyBinary predicateThis is essentially a function a -> b -> Bool; see  for detailed discussion.*falsifySpecialization of ( for unary relations+falsifySpecialization of ) for relations,falsify"Function composition (analogue of )-falsify!Analogue of 'Control.Arrow.(***)'.falsify Analogue of /falsify Analogue of 0falsifyMatch on the argument, and apply whichever predicate is applicable.1falsify ConditionalThis is a variation on choose6 that provides no evidence for which branch is taken.2falsify Evaluate fully applied predicate3falsifyInfix version of 4Typical usage example: assert $ P.relatedBy ("equiv", equiv) .$ ("x", x) .$ ("y", y)4falsifyGeneralization of 3 that does not require a  instancefalsifyGeneralization of 4 for an arbitrary !This is not currently part of the public API, since we haven't yet decided how exactly we want to expose ! (if at all).falsify8Construct predicate corresponding to some infix operatorThis is an internal auxiliary.5falsifyEqual6falsify Not equal7falsify(Strictly) less than8falsifyLess than or equal to9falsify(Strictly) greater than:falsifyGreater than or equal to;falsify4Check that values get closed to the specified target<falsifySpecialization of 52, useful when expecting a specific value in a test=falsify Check that  lo <= x <= hi>falsifyNumber is even?falsify Number is odd@falsifyMembership checkAfalsifyApply predicate to every pair of consecutive elements in the listfalsifyPredicate to checkfalsifyProduce error message, given the expressions describing the inputs(falsifyThe predicate properfalsifyError message, given ! describing the input)falsifyThe predicate properfalsifyError message, given ! describing inputs1falsify.Predicate to evaluate if the condition is truefalsify/Predicate to evaluate if the condition is false4falsify+Rendered name, expression, and input properfalsify+Rendered name, expression, and input properfalsify-Infix operator corresponding to the relation NOT holding# !"#$%&'()*+,-./0123456789:;<=>?@A#!" #$%&'()*+,-./0123456789:;<=>?@A Safe-Inferred%%'()*12589:;<=?V= DfalsifyRange that is x everywhereEfalsify Construct a given a fractionPrecondition: f5 must be monotonically increasing or decreasing; i.e.for all x <= y,  f x <= f y, orfor all x <= y,  f y <= f xFfalsifyGenerate value in any of the specified ranges, then choose the one that is closest to the specified originPrecondition: the target must be within the bounds of all ranges.GfalsifyUniform selection between the given bounds, shrinking towards first boundHfalsify Variation on G for types that are  but not !This is useful for types such as !. However, since this relies on #, it's limited by the precision of .IfalsifySelection within the given bounds, shrinking towards the specified origin,All else being equal, prefers values in the second/ half of the range (in the common case of say withOrigin (-100, 100) 0), this means we prefer positive values).Jfalsify&Introduce skew (non-uniform selection) A skew of s == 0" means no skew: uniform selection.A positive skew (s > 0) introduces a bias towards smaller values (this is the typical use case). As example, for a skew of s == 1:We will generate a value from the lower 20% of the range 60% of the time.We will generate a value from the upper 60% of the range 20% of the time.A negative skew (s < 0)9 introduces a bias towards larger values. For a skew of s == 1:We will generate a value from the upper 20% of the range 60% of the time.We will generate a value from the lower 60% of the range 20% of the time.The table below lists values for the percentage of the range used, given a percentage of the time (a value of 0 means a single value from the range):  | time% s | 50% | 90% -------------- 0 | 50 | 90 1 | 13 | 56 2 | 4 | 35 3 | 1 | 23 4 | 0 | 16 5 | 0 | 11 6 | 0 | 8 7 | 0 | 6 8 | 0 | 5 9 | 0 | 4 10 | 0 | 3Will shrink towards x, independent of skew.NOTE: The implementation currently uses something similar to -law encoding. As a consequence, the generator gets increased precision near the end of the range we skew towards, and less precision near the other end. This means that not all values in the range can be produced.falsify>Precision required to be able to choose within the given rangeIn order to avoid rounding errors, we set a lower bound on the precision. This lower bound is verified in TestSuite.Sanity.Range, which verifies that for small ranges, the expected distribution is never off by more than 1% from the actual distribution.Kfalsify-Origin of the range (value we shrink towards)Lfalsify7Evaluate a range, given an action to generate fractions:Most users will probably never need to call this function.DEFGHIJKLGHIJKDEFL Safe-Inferred%%'()*12589:;<=?ZMfalsifyn -bit wordfalsifyMake n -bit word (n <= 64)4Bits outside the requested precision will be zeroed.We use this to generate random n>-bit words from random 64-bit words. It is important that we truncate rather than cap the value: capping the value (limiting it to a certain maximum) would result in a strong bias towards that maximum value. Of course,  shrinking of a Word64 bit does not translate automatically to shrinking of the lower n. bits of that word (a decrease in the larger  may very well be an increase in the lower n, bits), so this must be taken into account.OfalsifyUniform selection of n1-bit word of given precision, shrinking towards 0falsifyCompute fraction from n -bit wordPfalsify2Uniform selection of fraction, shrinking towards 0Precondition: precision must be at least 1 bit (a zero-bit number is constant 0; it is meaningless to have a fraction in a point range).MNOP Safe-Inferred%%'()*12589:;<=?`Qfalsify Start with x, then shrink to one of the xs#Once shrunk, will not shrink again.Minimal value is the first shrunk value, if it exists, and the original otherwise.RfalsifyGenerator that always produces x" as initial value, and shrinks to ySfalsifyShrink with provided shrinkerThis provides compatibility with QuickCheck-style manual shrinking.Defined in terms of T6; see discussion there for some notes on performance.Tfalsify$Construct generator from shrink treeThis provides compatibility with Hedgehog-style integrated shrinking.This is O(n^2) in the number of shrink steps: as this shrinks, the generator is growing a path of indices which locates a particular value in the shrink tree (resulting from unfolding the provided shrinking function). At each step during the shrinking process the shrink tree is re-evaluated and the next value in the tree is located; since this path throws linearly, the overall cost is O(n^2).$The O(n^2) cost is only incurred on locating the next element to be tested; the property is not reevaluated at already-shrunk values.Ufalsify*Expose the full shrink tree of a generatorThis generator does not shrink.QRSTU Safe-Inferred%%'()*12589:;<=?aVfalsify4Generate random bool, shrink towards the given value'Chooses with equal probability between  and .Wfalsify%Generate value in the specified rangeXfalsifyDeprecated alias for WYfalsifyDeprecated alias for WZfalsifyType-specialization of WVWXYZ Safe-Inferred%%'()*12589:;<=?z\falsify+Generate a value with one of two generatorsShrinks towards the first generator;the two generators can shrink independently from each other. BackgroundIn the remainder of this docstring we give some background to this function, which may be useful for general understanding of the falsify library./The implementation takes advantage of the that  is a selective functor to ensure that the two generators can shrink independently: if the initial value of the generator is some y9 produced by the second generator, later shrunk to some y'&, then if the generator can shrink to x! at some point, produced by the first generator, then shrinking effectively "starts over": the value of x is independent of y'."That is different from doing this: "do b <- bool if b then l else rIn this case, l and r will be generated from the same2 sample tree, and so cannot shrink independently.It is also different from ?do x <- l y <- r b <- bool return $ if b then x else yIn this case, l and r are run against  different! sample trees, like we do here, but in this case if the current value produced by the generator is produced by the right generator, then the sample tree used for the left generator will always shrink to Minimal (this must be possible because we're not currently using it); this means that we would then only be able to shrink to a value from the left generator if the minimal3 value produced by that generator happens to work.To rephrase that last point: generating values that are not actually used will lead to poor shrinking, since those values can always be shrunk to their minimal value, independently from whatever property is being tested: the shrinker does not know that the value is not being used. The correct way to conditionally use a value is to use the selective interface, as we do here.]falsify,Generate a value with one of many generatorsUniformly selects a generator and shrinks towards the first one.^falsify Start with Just x for some x, then shrink to Nothing_falsify#Mark an element, shrinking towards This is similar to ^, except that  still has a value in the : case: marks are merely hints, that we may or may not use.`falsify!Generate list of specified lengthShrinking behaviour:The length of the list will shrink as specified by the given range.We can drop random elements from the list, but prefer to drop them from near the end of the list.Note on shrinking predictability: in the case that the specified  has an origin which is neither the lower bound nor the upper bound (and only in that case), ` can have confusing shrinking behaviour. For example, suppose we have a range (0, 10) with origin 5. Then we could start by generating an intermediate list of length of 10 and then subsequently drop 5 elements from that, resulting in an optimal list length. However, we can now shrink that length from 10 to 2 (which is closer to 5, after all), but now we only have 2 elements to work with, and hence the generated list will now drop from 5 elements to 2. This is not necessarily a problem, because that length 2 can now subsequently shrink further towards closer to the origin (5), but nonetheless it might result in confusing intermediate shrinking steps.afalsifyChoose random element!Shrinks towards earlier elements.NOTE: Does not work on infinite lists (it computes the length of the list).bfalsifyGeneralization of a that additionally returns the parts of the list before and after the elementcfalsify!Choose random element from a listThis is different from a: it avoids first computing the length of the list, and is biased towards elements earlier in the list. The advantage is that this works for infinite lists, too.Also returns the elements from the list before and after the chosen element.dfalsify)Choose generator with the given frequency For example, +frequency [ (1, genA) , (2, genB) ] will use genA 13rd of the time, and genB 23rds.Shrinks towards generators earlier in the list; the generators themselves are independent from each other (shrinking of genB does not affect shrinking of genA).Precondition: there should at least one generator with non-zero frequency.falsifyInternal auxiliary to defalsify&Shuffle list (construct a permutation)Shrinking behaviour: e is defined in terms of f, which provides some guarantees: it shrinks towards making changes near the start$ of the list, and towards swapping fewer elements of the list.It is difficult to define precisely how this affects the resulting list, but we can say that if for a particular counter-example it suffices if two lists are different in one element, then the shuffled list will in fact only be different in one place from the original, and that one element will have been swapped with an immediate neighbour.ffalsify*Generate permutation for a list of length nThis is essentially an implemention of Fisher-Yates, in that we generate a series of swaps (i, j), with 1 <= i <= n - 1 and  0 <= j <= i , except thatWe can shrink a choice of i (towards 1).We can drop arbitrary swaps., or rely on the default implementation in terms of generics.nfalsify Function a -> b* which can be shown, generated, and shrunkofalsifyPattern synonym useful when generating functions of three argumentspfalsifyPattern synonym useful when generating functions of two argumentsqfalsifyPattern synonym useful when generating functions of one argumentrfalsifyGenerate function a -> b given a generator for bsfalsifyThe basic building block for k instances Provides a k< instance by mapping to and from a type that already has a k instance.falsifyApply concrete functiontfalsifyApply function to argument See also the q, p, and o patter synonyms.falsifyShow concrete function"Only use this on finite functions.falsify+Generating a table from a concrete functionThis is only used in the  instance. klmnopqrst Safe-Inferred%%'()*12589:;<=? MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstVWXYZ\]`abce fd gh[ij_ntqporklmsMNOPQRS^TU Safe-Inferred&%'()*12589:;<=?5ufalsifyPropertyA Property is a generator that can fail and keeps a track of some information about the test run.-In most cases, you will probably want to use  instead, which fixes e at .falsify Test resultfalsifyTest was successfulUnder normal circumstances a will be ().falsify Test failedfalsifyTest was discardedThis is neither a failure nor a success, but instead is a request to discard this PRNG seed and try a new one.falsify,Log of the events happened during a test run6The events are recorded in reverse chronological orderfalsifyGenerated a value2We record the value that was generated as well as where we generated itfalsifySome additional informationfalsify,Did we generate any values in this test run?If not, there is no point running the test more than once (with different seeds), since the test is deterministic.falsifyLabelsfalsify8Append log from another test run to the current test runThis is an internal function, used when testing shrinking to include the runs from an unshrunk test and a shrunk test.falsify?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abZcdefPgghijklmnopqcrstuvw]xyz{|}~?      !!!!!!!!!                          a2M6                            $falsify-0.2.0-9iEl6oVWKuGBEAdnfNgikeTest.Falsify.GeneratorTest.Falsify.RangeTest.Falsify.PredicateTest.Falsify.PropertyTest.Tasty.FalsifyTest.Falsify.InteractiveTest.Falsify.GenDefaultTest.Falsify.GenDefault.StdData.Falsify.IntegerData.Falsify.MarkedData.Falsify.ListData.Falsify.Tree'Test.Falsify.Internal.Driver.ReplaySeedTest.Falsify.Internal.Rangetowards Test.Falsify.Internal.SampleTreeTest.Falsify.Internal.Search*Test.Falsify.Internal.Generator.DefinitionTest.Falsify.Generator.Compoundlist)Test.Falsify.Internal.Generator.ShrinkingTest.Falsify.Internal.GeneratorPreludeon+Test.Falsify.Reexported.Generator.Precision+Test.Falsify.Reexported.Generator.Shrinking(Test.Falsify.Reexported.Generator.Simple*Test.Falsify.Reexported.Generator.Compound*Test.Falsify.Reexported.Generator.FunctionTest.Falsify.Internal.PropertyPropertyTest.Falsify.Internal.Driver"Test.Falsify.Internal.Driver.TastyMarkedgetMarkunmarkMarkKeepDrop selectAllKept PermutationapplyPermutationTreeLeafBranchdrawTreeRange PrecisionProperFractionGenbindWithoutShortcut bindIntegralperturbprimprimWith exhaustivecaptureLocalTreewithoutShrinking IsValidShrink ValidShrink InvalidShrink PredicateFnExpr prettyExprfnfnWith transparent alwaysPass alwaysFailunarybinary satisfies relatedBydotsplitflip matchEither matchBooleval.$ateqneltlegtgeexpectbetweenevenoddelempairwise$fSemigroupPredicate$fMonoidPredicateconstantfromProperFractionenum withOriginskewedByoriginWordNwordNproperFraction shrinkToOneOf firstThen shrinkWithfromShrinkTree toShrinkTreeboolinRangeintegralint ShrinkTreechooseoneofshrinkToNothingmarkpick pickBiased frequencyshuffle permutationtreebstpathpathAnyFunctionfunction:->FunFn3Fn2fun functionMapapplyFun Property' testFaileddiscardinfoassertlabelcollectgengenWith testShrinking testMinimumtestGentestShrinkingOfGen ExpectFailureDontExpectFailureVerbose NotVerbose TestOptions expectFailureoverrideVerboseoverrideMaxShrinksoverrideNumTestsoverrideMaxRatio testPropertytestPropertyWithsampleshrinkshrink'falsifyfalsify' ViaGeneric unViaGeneric ViaString unViaStringViaList unViaListViaEnum unViaEnum ViaIntegral unViaIntegralViaTagunViaTag GenDefault genDefault$fGenDefaulttagViaTag$fGenDefaulttagViaIntegral$fGenDefaulttagViaEnum$fGenDefaulttagViaList$fGenDefaulttagViaString$fGGenDefaulttagK1$fGGenDefaulttag:+:$fGGenDefaulttag:*:$fGGenDefaulttagM1$fGGenDefaulttagU1$fGenDefaulttagViaGenericStd$fGenDefaultStd(,,,,)$fGenDefaultStd(,,,)$fGenDefaultStd(,,)$fGenDefaultStd(,)$fGenDefaultStdEither$fGenDefaultStdMaybe$fGenDefaultStdWord64$fGenDefaultStdWord32$fGenDefaultStdWord16$fGenDefaultStdWord8$fGenDefaultStdWord$fGenDefaultStdInt64$fGenDefaultStdInt32$fGenDefaultStdInt16$fGenDefaultStdInt8$fGenDefaultStdInt$fGenDefaultStdChar$fGenDefaultStdBool$fGenDefaultStd() natToBits encEliasGencIntegerEliasGBitOIbase GHC.MaybeNothing countKept shouldKeepchunksOfNonEmpty keepAtLeastsize propagategenKeptinclusiveBoundslookupIntervalEndpoint Inclusive Exclusive ReplaySeedReplaySplitmixsplitmixReplaySeedsafeReadReplaySeedparseReplaySeedConstantFromProperFractionSmallest$fShowProperFractionSample SampleTreenextMinimalInfminimalmapmod NotShrunkShrunk sampleValueleftrightfromPRNGfromSeed binarySearchbinarySearchNoParityBiasGHC.EnummaxBounddeltasGHC.BaseFunctor ApplicativeMonad combineShrunk$selective-0.7-4rqDrqM1pRY5pncT4EBoXpControl.SelectivebindSGHC.WordWord64runGen ShrinkHistoryShrunkTo ShrinkingDoneShrinkingStoppedShrinkExplanationinitialhistory shrinkHistory shrinkOutcomelimitShrinkSteps shrinkFromPrimPassFailBothLamAtDotSplitFlipChooseConstErrInput inputExpr inputRendered inputValueVisible TransparentVarAppInfixGHC.ShowShowapplyFnghc-prim GHC.TypesTrueFalse.atExpr binaryInfixEnumGHC.RealIntegralCharIntprecisionRequiredToRepresent truncateAt mkFractionfrequencyLookupabstract showFunctiontoTableString TestResult TestPassed TestFailed TestDiscardedLog GeneratedInforunDeterministic runLabels appendLogresultIsValidShrink mkProperty runPropertygenWithCallStack genShrinkPathtestGen'LogEntryTestRunrunLogRenderedTestResultprng successestododiscardedForTestdiscardedTotalOptionstests maxShrinksreplaymaxRatio testPassed testOutputTotalDiscardedFailure failureSeed failureRunSuccess successResult successSeed successRunrenderTestResult