u(      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { | } ~                                                                                                                                                                   ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z{|}~NoneI`A range describes the bounds of a number to generate, which may or may not be dependent on a .Tests are parameterized by the size of the randomly-generated data, the meaning of which depends on the particular generator used.uGet the origin of a range. This might be the mid-point or the lower bound, depending on what the range represents.The ; of a range are scaled around this value when using the  family of combinators. When using a O to generate numbers, the shrinking function will shrink towards the origin.-Get the extents of a range, for a given size.2Get the lower bound of a range for the given size.2Get the upper bound of a range for the given size.;Construct a range which represents a constant single value.bounds x $ singleton 5(5,5)origin $ singleton 55<Construct a range which is unaffected by the size parameter. A range from 0 to 10, with the origin at 0:bounds x $ constant 0 10(0,10)origin $ constant 0 100tConstruct a range which is unaffected by the size parameter with a origin point which may differ from the bounds. A range from -10 to 10, with the origin at 0:"bounds x $ constantFrom 0 (-10) 10(-10,10) origin $ constantFrom 0 (-10) 100 A range from 1970 to 2100, with the origin at 2000:&bounds x $ constantFrom 2000 1970 2100 (1970,2100)$origin $ constantFrom 2000 1970 21002000cConstruct a range which is unaffected by the size parameter using the full range of a data type. A range from -128 to 127, with the origin at 0:(bounds x (constantBounded :: Range Int8) (-128,127)&origin (constantBounded :: Range Int8)0RConstruct a range which scales the second bound relative to the size parameter.bounds 0 $ linear 0 10(0,0)bounds 50 $ linear 0 10(0,5)bounds 99 $ linear 0 10(0,10)IConstruct a range which scales the bounds relative to the size parameter. bounds 0 $ linearFrom 0 (-10) 10(0,0)!bounds 50 $ linearFrom 0 (-10) 20(-5,10)!bounds 99 $ linearFrom 0 (-10) 20(-10,20) kConstruct a range which is scaled relative to the size parameter and uses the full range of a data type.&bounds 0 (linearBounded :: Range Int8)(0,0)'bounds 50 (linearBounded :: Range Int8)(-64,64)'bounds 99 (linearBounded :: Range Int8) (-128,127)!RConstruct a range which scales the second bound relative to the size parameter.This works the same as , but for fractional values."IConstruct a range which scales the bounds relative to the size parameter.This works the same as , but for fractional values.#/Truncate a value so it stays within some range. clamp 5 10 1510 clamp 5 10 05$3Scale an integral linearly with the size parameter.%;Scale a fractional number linearly with the size parameter. !"#$%&'( !"#$%!" #$% !"#$%&'(None 9:;<=DORT/AA node in an effectful tree, as well as its unevaluated children.3UAn effectful tree, each node in the tree can have an effect before it is produced.65Create a tree from a value and an unfolding function.77Create a forest from a value and an unfolding function.8*Expand a tree using an unfolding function.9Throw away a tree's children.:WRender a tree of strings, note that this forces all the delayed effects in the tree.5/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST /0123456789: 345/0126789:0/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTNone *DIORTUVWXYZ[\]^_`abcdeUVWXYZ[\]^_`ab_`a\]^UVWXYZ[bUVWXYZ[\]^_`abcdeSafet:Shrink an integral number by edging towards a destination. towards 0 100[0,50,75,88,94,97,99]towards 500 1000%[500,750,875,938,969,985,993,997,999]towards (-50) (-26)[-50,-38,-32,-29,-27]HNote we always try the destination first, as that is the optimal shrink.u?Shrink a floating-point number by edging towards a destination.take 7 (towardsFloat 0.0 100))[0.0,50.0,75.0,87.5,93.75,96.875,98.4375]take 7 (towardsFloat 1.0 0.5)2[1.0,0.75,0.625,0.5625,0.53125,0.515625,0.5078125]HNote we always try the destination first, as that is the optimal shrink.v/Shrink a list by edging towards the empty list. list [1,2,3][[],[2,3],[1,3],[1,2]] list "abcd"&["","cd","ab","bcd","acd","abd","abc"]GNote we always try the empty list first, as that is the optimal shrink.w%Produce all permutations of removing k elements from a list.removes 2 "abcdef"["cdef","abef","abcd"]xAProduce a list containing the progressive halving of an integral. halves 15 [15,7,3,1] halves 100[100,50,25,12,6,3,1] halves (-26)[-26,-13,-6,-3,-1]yECons an element on to the front of a list unless it is already there.tuvwxytuvwxytuvxwytuvwxySafeM[%z{|}~"  z{|}~" ~z{|}z{|}~None %A splittable random number generator.must be an odd numberCreate a random ) using an effectful source of randomness. Create a  using an .NA predefined gamma value's needed for initializing the "root" instances of O. That is, instances not produced by splitting an already existing instance.&We choose: the odd integer closest to 2^64/, where  = (1 + "5)/2 is the golden ratio.,Get the next value in the SplitMix sequence.+Splits a random number generator in to two.Generate a random .Generate a random .Generate a random $ in the [inclusive,inclusive] range.Generate a random $ in the [inclusive,exclusive) range.None None(IT[AThe number of workers to use when running properties in parallel.(How verbose should the report output be.)Only display the summary of the test run.?Display each property as it is running, as well as the summary.2Whether to render output using ANSI colors or not.%Disable ANSI colors in report output.$Enable ANSI colors in report output. NoneI[OUpdate the number of capabilities but never set it lower than it already is.  None%&,/2349;<=DILORT[MGenerator for random values of a.,Runs a generator, producing its shrink tree.#Map over a generator's shrink tree.(Generate a value with no shrinks from a  and a .cFreeze the size and seed used by a generator, so we can inspect the value which it will produce.This is used for implementing   and &_. It allows us to shrink the list itself before trying to shrink the values inside the list.SLift a predefined shrink tree in to a generator, ignoring the seed and the size.;Run the discard effects through the tree and reify them as  values at the nodes.  means discarded,  means we have a value.*Apply a shrinking function to a generator.hThis will give the generator additional shrinking options, while keeping the existing shrinks intact.%Throw away a generator's shrink tree.9Construct a generator that depends on the size parameter.tOverride the size parameter. Returns a generator which uses the given size instead of the runtime-size parameter.EAdjust the size parameter by transforming it with the given function.7Make a generator smaller by scaling its size parameter.$Scale a size using the golden ratio. )golden x = x /  golden x = x / 1.61803..0Generates a random integral number in the given [inclusive,inclusive] range.BWhen the generator tries to shrink, it will shrink towards the  of the specified .CFor example, the following generator will produce a number between 1970 and 2100, but will shrink towards 2000: integral (Range. 2000 1970 2100) ::   8Some sample outputs from this generator might look like: ==== Outcome === 1973 === Shrinks === 2000 1987 1980 1976 1974 B=== Outcome === 2061 === Shrinks === 2000 2031 2046 2054 2058 2060FGenerates a random integral number in the [inclusive,inclusive] range.This generator does not shrink.0Generates a random machine integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience..Generates a random 8-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience./Generates a random 16-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience./Generates a random 32-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience./Generates a random 64-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.-Generates a random machine word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.%Generates a random byte in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.,Generates a random 16-bit word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.,Generates a random 32-bit word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.,Generates a random 64-bit word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.0Generates a random floating-point number in the [inclusive,exclusive) range.!This generator works the same as !, but for floating point numbers.HGenerates a random fractional number in the [inclusive,exclusive) range.This generator does not shrink.0Generates a random floating-point number in the [inclusive,exclusive) range.This is a specialization of , offered for convenience.0Generates a random floating-point number in the [inclusive,exclusive) range.This is a specialization of , offered for convenience.)Generates an element from an enumeration.2This generator shrinks towards the first argument. For example: enum 'a' 'z' ::   4Generates a random value from a bounded enumeration.This generator shrinks towards . For example: enumBounded ::    Generates a random boolean.This generator shrinks to .This is a specialization of , offered for convenience. Generates a random boolean.This generator does not shrink. Generates an ASCII binit: '0'..'1' Generates an ASCII octit: '0'..'7' Generates an ASCII digit: '0'..'9'Generates an ASCII hexit: '0'..'9', 'a'..'f', 'A'..'F'%Generates an ASCII lowercase letter: 'a'..'z'%Generates an ASCII uppercase letter: 'A'..'Z'Generates an ASCII letter: 'a'..'z', 'A'..'Z'$Generates an ASCII letter or digit: 'a'..'z', 'A'..'Z', '0'..'9'Generates a string using  to determine the length.This is a specialization of  , offered for convenience.Generates a string using  to determine the length.(Generates a UTF-8 encoded string, using  to determine the length.Generates a random , using  to determine the length.8Trivial generator that always produces the same element.This is another name for  / .1Randomly selects one of the elements in the list.=This generator shrinks towards the first element in the list.!The input list must be non-empty.3Randomly selects one of the generators in the list.?This generator shrinks towards the first generator in the list.!The input list must be non-empty.UUses a weighted distribution to randomly select one of the generators in the list.?This generator shrinks towards the first generator in the list.!The input list must be non-empty.BModifies combinators which choose from a list of generators, like  or 2, so that they can be used in recursive scenarios.This combinator modifies its target to select one of the generators in either the non-recursive or the recursive list. When a selection is made from the recursive list, the  is halved. When the l gets to one or less, selections are no longer made from the recursive list, this ensures termination.FA good example of where this might be useful is abstract syntax trees: rdata Expr = Var String | Lam String Expr | App Expr Expr -- Assuming we have a name generator genName ::  m => B m String -- We can write a generator for expressions genExpr ::  m =>  m Expr genExpr = Gen. Gen./ [ -- non-recursive generators Var 9 genName ] [ -- recursive generators Gen.' genExpr (x -> Lam  genName  pure x) , Gen.* genExpr genExpr App ] )If we wrote the above example using only U, it is likely that it would fail to terminate. This is because for every call to genExpr9, there is a 2 in 3 chance that we will recurse again.Discards the whole generator.This is another name for  / .-Generates a value that satisfies a predicate.This is essentially: filter p gen =  p gen  filter p gen It differs from the above in that we keep some state to avoid looping forever. If we trigger these limits then the whole generator is discarded.Runs a  generator until it produces a .This is implemented using  and has the same caveats. Generates a  some of the time. Generates a list using a  to determine the length.!Generates a seq using a  to determine the length."#Generates a non-empty list using a  to determine the length.#Generates a set using a  to determine the length.;This may fail to generate anything if the element generator >cannot produce a large enough number of unique items to satify the required set size.$Generates a map using a  to determine the length.>This may fail to generate anything if the keys produced by the <generator do not account for a large enough number of unique &items to satify the required map size.Generate exactly n unique generators.%?Check that list contains at least a certain number of elements.&<Constructs a generator from a number of sub-term generators.,Shrinks to one of the sub-terms if possible.'1Constructs a generator from a sub-term generator.$Shrinks to the sub-term if possible.(1Constructs a generator from a sub-term generator.$Shrinks to the sub-term if possible.)4Constructs a generator from two sub-term generators.,Shrinks to one of the sub-terms if possible.*4Constructs a generator from two sub-term generators.,Shrinks to one of the sub-terms if possible.+6Constructs a generator from three sub-term generators.,Shrinks to one of the sub-terms if possible.,6Constructs a generator from three sub-term generators.,Shrinks to one of the sub-terms if possible.-)Generates a random subsequence of a list..)Generates a random permutation of a list.PThis shrinks towards the order of the list being identical to the input list./6Generate a random sample of data from the a generator.0hPrint the value produced by a generator, and the first level of shrinks, for the given size and seed.Use 2( to generate a value from a random seed.1NPrint the shrink tree produced by a generator, for the given size and seed.Use 3( to generate a value from a random seed.2\Run a generator with a random seed and print the outcome, and the first level of shrinks. Gen.print (Gen. 'a' 'f') /=== Outcome === 'd' === Shrinks === 'a' 'b' 'c'3GRun a generator with a random seed and print the resulting shrink tree. Gen.printTree (Gen. 'a' 'f')  C'd' %%|'a' %%|'b' % %%|'a' %%|'c' %%|'a' %%|'b' %%|'a'3This may not terminate when the tree is very large.4(Render a generator as a tree of strings.q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFT      !"#$%&'()*+,-./01234T      !"#$('*),+-./2301%&4i      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF5 None(29:;<=DILORT[!M6The difference between some expected and actual value.U'Details on where and why a test failed.W2Log messages which are recorded during a test run.Z"The name of a group of properties.]%A named collection of property tests.a1The number of discards to allow before giving up.c;The number of shrinks to try before giving up on shrinking.efThe number of successful tests that need to be run before a property test is considered successful.g"Configuration for a property test.lThe name of a property.oA property test.reA property test to check, along with some configurable limits like how many times to run the test.v.The default configuration for a property test.w3Map a config modification function over a property.xYSet the number times a property should be executed before it is considered successful.yYSet the number times a property is allowed to discard before the test runner gives up.zvSet the number times a property is allowed to shrink before the test runner gives up and prints the counterexample.{Creates a property to check.~HGenerates a random input for the test by running the provided generator.HGenerates a random input for the test by running the provided generator.This is a the same as ~( but allows the user to provide a custom @rendering function. This is useful for values which don't have a  instance.^Annotates the source code with a message that might be useful for debugging a test failure.\Annotates the source code with a value that might be useful for debugging a test failure.`Logs a message to be displayed as additional information in the footer of the failure report.^Logs a value to be displayed as additional information in the footer of the failure report.Discards a test entirely.JFail with an error message, useful for building other failure combinators.Causes a test to fail.Another name for pure ().,Fails the test if the condition provided is .;Fails the test if the two arguments provided are not equal.Fails the test if the  is (, otherwise returns the value in the .Fails the test if the  is (, otherwise returns the value in the .@Run a computation which requires resource acquisition / release.Note that if you  anything before a ~? you will likely encounter unexpected behaviour, due to the way 9 interacts with the control flow introduced by shrinking.TMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~@MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~@rstulmnghijkefabcd{xyz]^_`Z[\opqWXYUVMNOPQRST~vw}|7MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~4 None2[# None(234IL[ )A summary of all the properties executed.1A report on a running or completed property test.(The status of a completed property test.qIn the case of a failure it provides the seed used for the test, the number of shrinks, and the execution log.&The status of a running property test./$The number of properties in a group.1.The number of tests a property had to discard.30The number of tests a property ran successfully.5HThe numbers of times a property was able to shrink after a failing test.7)Construct a summary from a single result.3The span of non-whitespace characters for the line.The result is [inclusive, exclusive).      !"#$%&'()*+,-./012345678     9:;<=>?@ABU      !"#$%&'()*+,-./0123456789:;<=>?U !"#$%&'()*+,-.563412/0     =>?<9:;78>      ! "#$%&'()*+,-./012345678     9:;<=>?@ABNone[{(Discover all the properties in a module.Functions starting with prop_ are assumed to be properties.z{z{z{z{None|<Test that a pair of render / parse functions are compatible.||||None(IT[ }&Configuration for a property test run.2The number of property tests to run concurrently. ' means use one worker per processor.&Whether to use colored output or not. & means detect from the environment.(How verbose to be in the runner output. & means detect from the environment.Check a property.0Check a property using a specific size and seed.>Check a group of properties using the specified runner config.)Check a group of properties sequentially..Using Template Haskell for property discovery: 7tests :: IO Bool tests = checkSequential $$(discover)#With manually specified properties: ntests :: IO Bool tests = checkSequential $ Group "Test.Example" [ ("prop_reverse", prop_reverse) ](Check a group of properties in parallel.<Warning: although this check function runs tests faster than 4, it should be noted that it may cause problems with Hproperties that are not self-contained. For example, if you have a group Fof tests which all use the same database table, you may find that they 5interfere with each other when being run in parallel..Using Template Haskell for property discovery: 5tests :: IO Bool tests = checkParallel $$(discover)#With manually specified properties: ltests :: IO Bool tests = checkParallel $ Group "Test.Example" [ ("prop_reverse", prop_reverse) ]}~ !" }~ }~}~ !"None,Z]^_`acelorxyz{~{|,]^_`Zrloeac{xyz{~|# !"#$%&'()**++,-./0123456789:;<=>?@ABCDEFFGHIIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijjklmnoppqrrstuvwxyz{|}~             N                                  2 ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U U V W X Y Z [ \ \ ] ^ _ ` ` a b b c d e e f f g g h h i j k l l m n n o p p q r s t u v w x y z { | } ~   %                                                                                                                                                                       ! ! " # $ $ % % & & ' ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ] ^ _ ` a b c d e f g h i jklmnnopqrstuvwxyz{|}~!                                                                             "hedgehog-0.2-kTw5qIHDmh9MxbSesHO05Hedgehog.Internal.SourceHedgehog.Internal.ShowHedgehog.RangeHedgehog.Internal.TreeHedgehog.Internal.ShrinkHedgehog.Internal.SeedHedgehog.Internal.RegionHedgehog.Internal.ConfigHedgehog.Internal.Queue Hedgehog.GenHedgehog.Internal.PropertyHedgehog.Internal.DiscoveryHedgehog.Internal.ReportHedgehog.Internal.THHedgehog.Internal.TrippingHedgehog.Internal.RunnerControl.Monad.Trans.ResourceallocateHedgehogbaseGHC.Stack.Types CallStack GHC.StackwithFrozenCallStack callStack HasCallStack)pretty-show-1.6.12-APoyzWUT80sLwzp0X0LDvDText.Show.ValueNameStringCharFloatIntegerRatioNegListTupleRec InfixConsConValueRangeSizeunSizeoriginbounds lowerBound upperBound singletonconstant constantFromconstantBoundedlinear linearFrom linearBounded linearFraclinearFracFromclamp scaleLinearscaleLinearFrac$fFunctorRange $fReadSize $fShowSize$fEqSize $fOrdSize $fNumSize $fRealSize $fEnumSize$fIntegralSizeNode nodeValue nodeChildrenTreerunTreeunfold unfoldForestexpandprunerender $fShow1Tree $fShow1Node $fShowTree $fShowNode$fMonadResourceTree$fMonadErroreTree$fMonadWriterwTree$fMonadStatesTree$fMonadReaderrTree$fMonadCatchTree$fMonadThrowTree$fMonadBasebTree $fMonadIOTree$fPrimMonadTree $fMMonadTree$fMFunctorTree$fMFunctorNode$fMonadTransTree$fMonadPlusTree$fAlternativeTree $fMonadTree $fMonadNode$fApplicativeTree$fApplicativeNode $fFunctorTree $fFunctorNodeSpanspanFile spanStartLinespanStartColumn spanEndLine spanEndColumnColumnNo unColumnNoLineNounLineNo getCaller$fShowColumnNo $fShowLineNo $fShowSpan $fEqLineNo $fOrdLineNo $fNumLineNo $fEnumLineNo $fRealLineNo$fIntegralLineNo $fEqColumnNo $fOrdColumnNo $fNumColumnNo$fEnumColumnNo$fRealColumnNo$fIntegralColumnNo$fEqSpan $fOrdSpantowards towardsFloatlistremoveshalvesconsNubLineDiffLineSame LineRemoved LineAdded ValueDiffValueConValueRec ValueTuple ValueList ValueSame renderValuerenderValueDiffrenderLineDiffmkValue showPrettylineDiff toLineDiff valueDifftakeLeft takeRight $fEqValueDiff$fShowValueDiff $fEqLineDiff$fShowLineDiff $fEqDocDiff $fShowDocDiffSeed seedValue seedGammarandomfrom goldenGammasplit nextInt64 nextInt32 nextInteger nextDoublemix64mix32mix64variant13mixGamma$fRandomGenSeed $fReadSeed $fShowSeed$fEqSeed $fOrdSeedRegionunRegionnewEmptyRegion newRegion forceRegion setRegiondisplayRegions displayRegion moveToBottom finishRegion WorkerCount VerbosityQuietNormalUseColor DisableColor EnableColor detectMark detectColordetectVerbosity detectWorkers resolveColorresolveVerbosityresolveWorkers $fEqUseColor $fOrdUseColor$fShowUseColor $fEqVerbosity$fOrdVerbosity$fShowVerbosity$fEqWorkerCount$fOrdWorkerCount$fShowWorkerCount$fNumWorkerCount$fEnumWorkerCount$fRealWorkerCount$fIntegralWorkerCount$fLiftUseColor$fLiftVerbosity$fLiftWorkerCountTasksRemaining TaskIndex dequeueMVarrunTasksrunActiveFinalizers finalizeTaskupdateNumCapabilities $fEqTaskIndex$fOrdTaskIndex$fEnumTaskIndex$fNumTaskIndexVecNil:.NatZSGenunGenrunGenmapGengeneratefreezeliftTreerunDiscardEffectshrinksizedresizescalesmallgoldenintegral integral_intint8int16int32int64wordword8word16word32word64 realFloat realFrac_floatdoubleenum enumBoundedboolbool_binitoctitdigithexitlowerupperalphaalphaNumstringtextutf8byteselementchoice frequency recursivediscardfilterjustmaybeseqnonEmptysetmapatLeast subtermMVecsubtermMsubterm subtermM2subterm2 subtermM3subterm3 subsequenceshufflesample printWith printTreeWithprint printTree renderNodes$fMonadResourceGen$fMonadErroreGen$fMonadWriterwGen$fMonadStatesGen$fMonadReaderrGen$fMonadCatchGen$fMonadThrowGen$fMonadBasebGen $fMonadIOGen$fPrimMonadGen $fMMonadGen $fMFunctorGen$fMonadTransGen$fMonadPlusGen$fAlternativeGen $fMonadGen$fApplicativeGen $fFunctorGen$fFunctorSubterms$fFoldableSubterms$fTraversableSubterms$fTraversableVec $fFoldableVec $fFunctorVecDiff diffPrefix diffRemoved diffInfix diffAdded diffSuffix diffValueFailureLog AnnotationFootnote GroupName unGroupNameGroup groupNamegroupProperties DiscardLimit ShrinkLimit TestLimitPropertyConfigpropertyTestLimitpropertyDiscardLimitpropertyShrinkLimit PropertyNameunPropertyNameTestunTestPropertypropertyConfig propertyTest defaultConfig mapConfig withTests withDiscards withShrinkspropertyrunTestwriteLogforAll forAllWithannotate annotateShowfootnote footnoteShowfailWithfailuresuccessassert=== liftEither liftExceptT withResourceT$fMonadResourceTest$fMonadErroreTest$fMonadStatesTest$fMonadReaderrTest$fMonadCatchTest$fMonadThrowTest$fMonadBasebTest $fMonadIOTest$fPrimMonadTest$fMFunctorTest$fMonadTransTest$fAlternativeTest$fMonadPlusTest $fMonadTest$fEqPropertyName$fOrdPropertyName$fShowPropertyName$fIsStringPropertyName$fSemigroupPropertyName $fEqTestLimit$fOrdTestLimit$fShowTestLimit$fNumTestLimit$fEnumTestLimit$fRealTestLimit$fIntegralTestLimit$fEqShrinkLimit$fOrdShrinkLimit$fShowShrinkLimit$fNumShrinkLimit$fEnumShrinkLimit$fRealShrinkLimit$fIntegralShrinkLimit$fEqDiscardLimit$fOrdDiscardLimit$fShowDiscardLimit$fNumDiscardLimit$fEnumDiscardLimit$fRealDiscardLimit$fIntegralDiscardLimit$fEqPropertyConfig$fOrdPropertyConfig$fShowPropertyConfig $fEqGroupName$fOrdGroupName$fShowGroupName$fIsStringGroupName$fSemigroupGroupName$fEqLog $fShowLog$fEqDiff $fShowDiff $fEqFailure $fShowFailure $fFunctorTest$fApplicativeTest$fLiftGroupName$fLiftPropertyName$fLiftPropertyConfig$fLiftTestLimit$fLiftShrinkLimit$fLiftDiscardLimitPos posPostionposValuePosition_posPathposLine posColumnPropertySourcepropertySourcereadPropertiesreadDeclarationfindProperties$fSemigroupPos $fEqClass $fOrdClass $fShowClass$fEqClassified$fOrdClassified$fShowClassified $fEqPosition $fOrdPosition$fShowPosition$fEqPos$fOrdPos $fShowPos $fFunctorPos$fEqPropertySource$fOrdPropertySource$fShowPropertySourceMarkup WaitingIcon WaitingHeader RunningIcon RunningHeader ShrinkingIconShrinkingHeader FailedIcon FailedHeader GaveUpIcon GaveUpHeader SuccessIcon SuccessHeaderDeclarationLocation StyledLineNo StyledBorder StyledSourceAnnotationGutterAnnotationValue FailureArrows FailureGutterFailureMessage DiffPrefix DiffInfix DiffSuffixDiffSame DiffRemoved DiffAddedReproduceHeaderReproduceGutterReproduceSourceStyle StyleDefaultStyleAnnotation StyleFailureSummarysummaryWaitingsummaryRunning summaryFailed summaryGaveUp summaryOKReport reportTestsreportDiscards reportStatusResultFailedGaveUpOKProgressRunning Shrinking FailureReport failureSize failureSeedfailureShrinksfailureAnnotationsfailureLocationfailureMessage failureDifffailureFootnotesFailedAnnotation failedSpan failedValue PropertyCount DiscardCount TestCount ShrinkCount fromResult mkFailure ppProgressppResult ppSummary renderDocrenderProgress renderResult renderSummary$fSemigroupStyle$fSemigroupSummary$fMonoidSummary$fEqShrinkCount$fOrdShrinkCount$fShowShrinkCount$fNumShrinkCount$fEnumShrinkCount$fRealShrinkCount$fIntegralShrinkCount $fEqTestCount$fOrdTestCount$fShowTestCount$fNumTestCount$fEnumTestCount$fRealTestCount$fIntegralTestCount$fEqDiscardCount$fOrdDiscardCount$fShowDiscardCount$fNumDiscardCount$fEnumDiscardCount$fRealDiscardCount$fIntegralDiscardCount$fEqPropertyCount$fOrdPropertyCount$fShowPropertyCount$fNumPropertyCount$fEnumPropertyCount$fRealPropertyCount$fIntegralPropertyCount$fEqFailedAnnotation$fShowFailedAnnotation$fEqFailureReport$fShowFailureReport $fEqProgress$fShowProgress $fEqResult $fShowResult $fShowReport$fFunctorReport$fFoldableReport$fTraversableReport $fShowSummary$fEqLine $fOrdLine $fShowLine $fFunctorLine$fEqDeclaration$fOrdDeclaration$fShowDeclaration$fFunctorDeclaration $fEqStyle $fOrdStyle $fShowStyle $fEqMarkup $fOrdMarkup $fShowMarkupTExpQdiscovertripping RunnerConfig runnerWorkers runnerColorrunnerVerbosity checkReport checkRegion checkNamedcheckrecheck checkGroupcheckSequential checkParallel$fEqRunnerConfig$fOrdRunnerConfig$fShowRunnerConfig$fLiftRunnerConfig embedNode embedTree handleNode handleTree localNode localTree listenNode listenTreepassNodepassTreehandleErrorNodehandleErrorTreerenderTreeLines renderNoderenderForestLinesDocDiffDocSame DocRemovedDocAddedDocOpenDocItemDocClose mkLineDiffspaces collapseOpendropLeadingSep mkDocDiffoneLinersameremovedaddedGHC.IntInt64nextInt32 integer-gmpGHC.Integer.Typeghc-prim GHC.TypesDoubleglobal lookupBoolGHC.BaseMaybeNothingJustIntGHC.EnumminBoundBoolFalsebytestring-0.10.8.1Data.ByteString.Internal ByteStringpurereturnMonad Data.Functor<$><*>emptymzero Control.Monadmfilter<|> uniqueByKeySubtermsOneAll embedMaybeembedGen uniqueInsertshrinkSubterms genSubterms fromSubtermsGHC.ShowShow Data.EitherEitherLeftRighttransformers-0.5.2.0Control.Monad.Trans.ExceptExceptT&resourcet-1.1.9-45U5DrYGVGxEMBE6rBzI5V%Control.Monad.Trans.Resource.Internal ResourceT Classified_classifiedClassclassifiedValueClass NotCommentCommenttakeHeadfindDeclarations isProperty declarationstrimEnd isWhitespace tagWithNametakeNameforget isDeclaration classified positionedlineSpan DeclarationdeclarationFiledeclarationLine_declarationNamedeclarationSourceLine_lineAnnotation lineNumber _lineSourcesummaryCompleted summaryTotaltakeAnnotation takeFootnoteppShowmarkupguttericon ppTestCountppDiscardCount ppShrinkCountppRawPropertyCountppWithDiscardCountppShrinkDiscard mapSource takeLines defaultStyle lastLineSpanppFailedInputTypedArgumentppFailedInputDeclaration ppFailedInput ppLineDiffppDiffppFailureLocation ppDeclaration ppReproduce mergeLinemergeDeclarationmergeDeclarations ppTextLinesppFailureReportppName ppWhenNonZeroannotateSummarymkNamedPropertyunsafePropertylistTE moduleNamegetCurrentFilefindM isFailure takeSmallest updateSummarycheckGroupWith