h&p       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                           Safe-InferredlUTWVZYXWVUTZYX Safe-Inferred 2hedgehog.Distribute one monad transformer over another. Safe-Inferred  Safe-Inferredhedgehog"Higher-order traversable functors.Deprecated in favor of U which can be derived using  GHC.Generics Safe-Inferred hedgehogOpaque values..Useful if you want to put something without a / instance inside something which you'd like to be able to display. For example:  data State v = State { stateRefs :: [Var (Opaque (IORef Int)) v] } deriving (Eq, Show)  Safe-InferredS!" #$% &'()*+,-./01 2~tuvwxz|}{y3^`a_456DG789:;<=EF>LJK?@ABIHMNOSbcdefghijklmpqrs40!" #$% &'()*+,-./01 2~tuvwxz|}{y3^`a_456DG789:;<=EF>LJK?@ABIHMNOSbcdefghijklmpqrs  Safe-Inferred7ZhedgehogA range describes the bounds of a number to generate, which may or may not be dependent on a .The constructor takes an origin between the lower and upper bound, and a function from & to bounds. As the size goes towards 0&, the values go towards the origin.hedgehogTests are parameterized by the size of the randomly-generated data. The meaning of a  value depends on the particular generator used, but it must always be a number between 0 and 99 inclusive.hedgehogGet 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  to generate numbers, the shrinking function will shrink towards the origin.hedgehog-Get the extents of a range, for a given size.hedgehog2Get the lower bound of a range for the given size.hedgehog2Get the upper bound of a range for the given size.hedgehog;Construct a range which represents a constant single value.bounds x $ singleton 5(5,5)origin $ singleton 55hedgehog; hedgehog%A splittable random number generator.hedgehogmust be an odd numberhedgehogCreate a random ) using an effectful source of randomness.hedgehog Create a  using a  .hedgehogA predefined gamma value's needed for initializing the "root" instances of . That is, instances not produced by splitting an already existing instance.&We choose: the odd integer closest to 2^64/, where  = (1 + D5)/2 is the golden ratio. hedgehog,Get the next value in the SplitMix sequence.hedgehog+Splits a random number generator in to two.hedgehogGenerate a random  .hedgehogGenerate a random  .hedgehogGenerate a random <$ in the [inclusive,inclusive] range.hedgehogGenerate a random 9$ in the [inclusive,exclusive) range. Safe-Inferred<%%  Safe-InferredAhedgehog: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]Note we always try the destination first, as that is the optimal shrink.hedgehog?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]Note we always try the destination first, as that is the optimal shrink.hedgehog/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"]Note we always try the empty list first, as that is the optimal shrink.hedgehog%Produce all permutations of removing k elements from a list.removes 2 "abcdef"["cdef","abef","abcd"]hedgehogProduce 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]hedgehogCons an element on to the front of a list unless it is already there. Safe-Inferred/ACnoCon  Safe-Inferred/KhedgehogA node in an effectful tree, as well as its unevaluated children.hedgehogThe value at this  in the .hedgehogThe children of this .hedgehogA node in a rose tree.hedgehogAn effectful tree, each node in the tree can have an effect before it is produced.hedgehog A rose tree.hedgehog GenT m hedgehog Transform a  as a .hedgehog(Generate a value with no shrinks from a  and a .hedgehog*Apply a shrinking function to a generator.This will give the generator additional shrinking options, while keeping the existing shrinks intact.hedgehog%Throw away a generator's shrink tree.hedgehog9Construct a generator that depends on the size parameter.hedgehogOverride the size parameter. Returns a generator which uses the given size instead of the runtime-size parameter.hedgehogAdjust the size parameter by transforming it with the given function.hedgehog7Make a generator smaller by scaling its size parameter.hedgehog$Scale a size using the golden ratio. )golden x = x /  golden x = x / 1.61803..hedgehog0Generates a random integral number in the given [inclusive,inclusive] range.When the generator tries to shrink, it will shrink towards the  of the specified .For 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 === Outcome === 2061 === Shrinks === 2000 2031 2046 2054 2058 2060hedgehogGenerates a random integral number in the [inclusive,inclusive] range.This generator does not shrink. hedgehog/Generates a random integral value from a range.hedgehog0Generates a random machine integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog.Generates a random 8-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog/Generates a random 16-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog/Generates a random 32-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog/Generates a random 64-bit integer in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog-Generates a random machine word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog%Generates a random byte in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog,Generates a random 16-bit word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog,Generates a random 32-bit word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog,Generates a random 64-bit word in the given [inclusive,inclusive] range.This is a specialization of , offered for convenience.hedgehog0Generates a random floating-point number in the [inclusive,exclusive) range.!This generator works the same as !, but for floating point numbers.hedgehogGenerates a random fractional number in the [inclusive,exclusive) range.This generator does not shrink.hedgehog0Generates a random floating-point number in the [inclusive,exclusive) range.This is a specialization of , offered for convenience.hedgehog0Generates a random floating-point number in the [inclusive,exclusive) range.This is a specialization of , offered for convenience.hedgehog)Generates an element from an enumeration.2This generator shrinks towards the first argument. For example: enum 'a' 'z' ::  8 hedgehog4Generates a random value from a bounded enumeration.This generator shrinks towards . For example: enumBounded ::  6 $This is implemented in terms of the " class, and thus may be 'partial for integral types larger than ;, e.g.  .hedgehogGenerates a random boolean.This generator shrinks to D.This is a specialization of , offered for convenience.hedgehogGenerates a random boolean.This generator does not shrink.hedgehogGenerates an ASCII binit: '0'..'1'hedgehogGenerates an ASCII octit: '0'..'7'hedgehogGenerates an ASCII digit: '0'..'9'hedgehogGenerates an ASCII hexit: '0'..'9', 'a'..'f', 'A'..'F'hedgehog%Generates an ASCII lowercase letter: 'a'..'z'hedgehog%Generates an ASCII uppercase letter: 'A'..'Z'hedgehogGenerates an ASCII letter: 'a'..'z', 'A'..'Z'hedgehog$Generates an ASCII letter or digit: 'a'..'z', 'A'..'Z', '0'..'9'hedgehogGenerates an ASCII character: '0'..'127'hedgehogGenerates a Latin-1 character: '0'..'255'hedgehogGenerates a Unicode character, excluding noncharacters and invalid standalone surrogates: '0'..'1114111' (excluding '55296'..'57343', '65534', '65535')hedgehogGenerates a Unicode character, including noncharacters and invalid standalone surrogates: '0'..'1114111'hedgehog2Check if a character is in the surrogate category.hedgehogCheck if a character is one of the noncharacters '65534', '65535'.hedgehogGenerates a string using  to determine the length.This is a specialization of , offered for convenience.hedgehogGenerates a string using  to determine the length.hedgehog(Generates a UTF-8 encoded string, using  to determine the length.hedgehogGenerates a random  , using  to determine the length.hedgehog8Trivial generator that always produces the same element.This is another name for  / .hedgehog1Randomly 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.hedgehog1Randomly selects one of the elements in the list.5This generator does not shrink the choice of element.!The input list must be non-empty.hedgehog3Randomly 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.hedgehogUses 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.hedgehogModifies 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  gets to one or less, selections are no longer made from the recursive list, this ensures termination.A good example of where this might be useful is abstract syntax trees: data Expr = Var String | Lam String Expr | App Expr Expr -- Assuming we have a name generator genName ::  m => 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 , 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.hedgehogDiscards the whole generator.hedgehogDiscards the generator if the generated value does not satisfy the predicate.hedgehog-Generates a value that satisfies a predicate.This is essentially:  filter p gen = mfilter 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.hedgehogRuns a = generator until it produces a F.This is implemented using  and has the same caveats.hedgehogRuns a = generator until it produces a F.This is implemented using  and has the same caveats.hedgehog Generates a E some of the time.hedgehogGenerates either an a or a b.,As the size grows, this generator generates Rights more often than Lefts.hedgehogGenerates either an a or a b, without bias.!This generator generates as many Right s as it does Lefts.hedgehogGenerates a list using a  to determine the length.hedgehogGenerates a seq using a  to determine the length.hedgehog#Generates a non-empty list using a  to determine the length.hedgehogGenerates 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.hedgehogGenerates a map using a  to determine the length.>This may fail to generate anything if the keys produced by the 4hedgehog1The extent to which all classifiers cover a test.When a given classification's coverage does not exceed the required !minimum, the test will be failed.hedgehog6The extent to which a test is covered by a classifier.When a classifier's coverage does not exceed the required minimum, the test will be failed.hedgehogThe name of a classifier.Should be constructed using OverloadedStrings:  "apples" :: LabelName hedgehog?The relative number of tests which are covered by a classifier.*Can be constructed using numeric literals:  30 :: CoverPercentage hedgehogA test monad transformer allows the assertion of expectations.hedgehog2A test monad allows the assertion of expectations.hedgehogThe property monad transformer allows both the generation of test inputs and the assertion of expectations.hedgehogA property test, along with some configurable limits like how many times to run the test.hedgehog;Compress a Skip into a hopefully-short alphanumeric string."The bit that might be long is the  in . For that, we encode the path components in base 26, alternating between uppercase and lowercase alphabets to distinguish list elements. Additionally when we have runs of equal components, we use the normal base 10 encoding to indicate the length.This gives something which is hopefully quite short, but a human can roughly interpret it by eyeball.hedgehog Compress a , into a hopefully-short alphanumeric string.We encode the path components in base 26, alternating between uppercase and lowercase alphabets to distinguish list elements. Additionally when we have runs of equal components, we use the normal base 10 encoding to indicate the length.hedgehog Decompress a .This satisfies , skipDecompress (skipCompress a) == Just a hedgehog Decompress a .This satisfies 8 shrinkPathDecompress (shrinkPathCompress a) == Just a hedgehogLog some information which might be relevant to a potential test failure.hedgehogFail the test with an error message, useful for building other failure combinators.hedgehogAnnotates the source code with a message that might be useful for debugging a test failure.hedgehogAnnotates the source code with a value that might be useful for debugging a test failure.hedgehogLogs a message to be displayed as additional information in the footer of the failure report.hedgehogLogs a value to be displayed as additional information in the footer of the failure report.hedgehogFails with an error that shows the difference between two values.hedgehogFails with an error which renders the type of an exception and its error message. hedgehogFails with an error which renders the given messages, the type of an exception, and its error message.hedgehogCauses a test to fail.hedgehogAnother name for pure ().hedgehog,Fails the test if the condition provided is D.hedgehogFails the test and shows a git-like diff if the comparison operation evaluates to D when applied to its arguments.The comparison function is the second argument, which may be counter-intuitive to Haskell programmers. However, it allows operators to be written infix for easy reading:  diff y (<) 87 diff x (<=) r $This function behaves like the unix diff tool, which gives a 0 exit code if the compared files are identical, or a 1 exit code code otherwise. Like unix diff<, if the arguments fail the comparison, a /diff is shown.hedgehog;Fails the test if the two arguments provided are not equal.hedgehog7Fails the test if the two arguments provided are equal.hedgehogFails the test if the value throws an exception when evaluated to weak head normal form (WHNF).hedgehogFails the test if the value throws an exception when evaluated to normal form (NF).hedgehog1Fails the test if the action throws an exception.The benefit of using this over simply letting the exception bubble up is !that the location of the closest  will be shown in the output.hedgehogFails the test if the @ action throws an exception.The benefit of using this over   is that the location of the &exception will be shown in the output.hedgehogFails the test if the B is H(, otherwise returns the value in the I.hedgehog?Fails the test if the action throws an exception, or if the B is H%, otherwise returns the value in the I.hedgehogFails the test if the   is H(, otherwise returns the value in the I.hedgehogFails the test if the = is E(, otherwise returns the value in the F.hedgehog?Fails the test if the action throws an exception, or if the = is E%, otherwise returns the value in the F.hedgehogGenerates 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.hedgehogGenerates 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.hedgehogGenerates a random input for the test by running the provided generator.hedgehogGenerates a random input for the test by running the provided generator.hedgehog#Discards the current test entirely.hedgehogLift a test in to a property. Because both  and  have  instances, this function is not often required. It can however be useful for writing functions directly in  and thus gaining a   instance at the expense of not being able to generate additional inputs using .An example where this is useful is parallel state machine testing, as  requires   @, in order to be able to spawn threads in .hedgehog.The default configuration for a property test.hedgehog)The minimum amount of tests to run for a hedgehog>The default confidence allows one false positive in 10^9 testshedgehog3Map a config modification function over a property.hedgehogMake sure that the result is statistically significant in accordance to the passed hedgehogSet the number of times a property should be executed before it is considered successful.If you have a test that does not involve any generators and thus does not need to run repeatedly, you can use  withTests 18 to define a property that will only be checked once.hedgehogSet the number of times a property is allowed to discard before the test runner gives up.hedgehogSet the number of times a property is allowed to shrink before the test runner gives up and prints the counterexample.hedgehogSet the number of times a property will be executed for each shrink before the test runner gives up and tries a different shrink. See  for more information.hedgehogSet the target that a property will skip to before it starts to run.hedgehog2Creates a property with the default configuration.hedgehogAll labels are coveredhedgehog7Is true when the test coverage satisfies the specified . contstraint for all 'Coverage CoverCount'shedgehogIs true when there exists a label that is sure to have failed according to the  constrainthedgehogRequire a certain percentage of the tests to be covered by the classifier.  prop_with_coverage :: Property prop_with_coverage = property $ do match <- forAll Gen.bool cover 30 "True" $ match cover 30 "False" $ not match The example above requires a minimum of 30% coverage for both classifiers. If these requirements are not met, it will fail the test.hedgehogRecords the proportion of tests which satisfy a given condition.  prop_with_classifier :: Property prop_with_classifier = property $ do xs <- forAll $ Gen.list (Range.linear 0 100) Gen.alpha for_ xs $ \x -> do classify "newborns" $ x == 0 classify "children" $ x > 0 && x < 13 classify "teens" $ x > 12 && x < 20 hedgehogAdd a label for each test run. It produces a table showing the percentage of test runs that produced each label.hedgehogLike  , but uses /$ to render its argument for display.hedgehog*We use this instance to support usage like  withSkip "3:aB" :It throws an error if the input is not a valid compressed .hedgehogThis semigroup is right biased. The name, location and percentage from the rightmost  will be kept. This shouldn't be a problem since the library doesn't allow setting multiple classes with the same ClassifierName.44 Safe-Inferredhedgehog=Test that a pair of encode / decode functions are compatible.Given a printer from some type a -> b., and a parser with a potential failure case b -> f a. Ensure that a valid a round trips through the "print" and "parse" to yield the same a.For example, types should have tripping + and / instances: trippingShowRead :: (Show a, Read a, Eq a, MonadTest m) => a -> m () trippingShowRead a = tripping a show readEither  Safe-Inferred)*589:s(hedgehogA sequential prefix of actions to execute, with two branches to execute in parallel.hedgehogThe sequential prefix.hedgehogThe first branch.hedgehogThe second branch.hedgehog!A sequence of actions to execute.hedgehogThe sequence of actions.hedgehogAn instantiation of a 4 which can be executed, and its effect evaluated.hedgehog4The specification for the expected behaviour of an :. These are used to generate sequences of actions to test.This is the main type you will use when writing state machine tests. gen is usually an instance of , and m is usually an instance of /. These constraints appear when you pass your  list to  or .hedgehogA generator which provides random arguments for a command. If the command cannot be executed in the current state, it should return E.hedgehog4Executes a command using the arguments generated by .hedgehogA set of callbacks which provide optional command configuration such as pre-condtions, post-conditions and state updates.hedgehogOptional command configuration.hedgehogA pre-condition for a command that must be verified before the command can be executed. This is mainly used during shrinking to ensure that it is still OK to run a command despite the fact that some previously executed commands may have been removed from the sequence.hedgehogUpdates the model state, given the input and output of the command. Note that this function is polymorphic in the type of values. This is because it must work over / values when we are generating actions, and # values when we are executing them.hedgehogA post-condition for a command that must be verified for the command to be considered a success.This callback receives the state prior to execution as the first argument, and the state after execution as the second argument.hedgehogEnvironment errors.hedgehog0A mapping of symbolic values to concrete values.hedgehogVariables are the potential or actual result of executing an action. They are parameterised by either  or ' depending on the phase of the test. variables are the potential results of actions. These are used when generating the sequence of actions to execute. They allow actions which occur later in the sequence to make use of the result of an action which came earlier in the sequence. variables are the actual results of actions. These are used during test execution. They provide access to the actual runtime value of a variable.The state update  for a command needs to be polymorphic in the type of variable because it is used in both the generation and the execution phase.The order of arguments makes   HTraverable, which is how  values are turned into  ones.hedgehog)Concrete values: At test-execution time, - values from generation are replaced with  values from performing actions. This type gives us something of the same kind as " to pass as a type argument to .hedgehogSymbolic values: Because hedgehog generates actions in a separate phase before execution, you will sometimes need to refer to the result of a previous action in a generator without knowing the value of the result (e.g., to get the ID of a previously-created user).Symbolic variables provide a token to stand in for the actual variables at generation time (and in / callbacks). At execution time, real values are available, so your execute actions work on  variables. See also: , hedgehogSymbolic variable names.hedgehog(Take the value from a concrete variable.hedgehog0Take the value from an opaque concrete variable.hedgehogCreate an empty environment.hedgehog;Insert a symbolic / concrete pairing in to the environment.hedgehogCast a   in to a concrete value.hedgehogTurns an environment in to a function for looking up a concrete value from a symbolic one.hedgehogConvert a symbolic structure to a concrete one, using the provided environment.hedgehogChecks that input for a command can be executed in the given state. hedgehog=Extract the variable name and the type from a symbolic value. hedgehog=Insert a symbolic variable in to a map of variables to types.hedgehogCollects all the symbolic values in a data structure and produces a set of all the variables they refer to.hedgehogChecks that the symbolic values in the data structure refer only to the variables in the provided set, and that they are of the correct type.hedgehog(Drops invalid actions from the sequence.hedgehog:Generates a single action from a set of possible commands.hedgehogGenerates a sequence of actions from an initial model state and set of commands.hedgehogGiven the initial model state and set of commands, generates prefix actions to be run sequentially, followed by two branches to be run in parallel. hedgehog1Executes a single action in the given evironment.hedgehogExecutes a list of actions sequentially, verifying that all post-conditions are met and no exceptions are thrown.9To generate a sequence of actions to execute, see the  combinator in the  Hedgehog.Gen module.hedgehogExecutes the prefix actions sequentially, then executes the two branches in parallel, verifying that no exceptions are thrown and that there is at least one sequential interleaving where all the post-conditions are met.1To generate parallel actions to execute, see the  combinator in the  Hedgehog.Gen module.77 Safe-Inferred8} Safe-Inferredchedgehog(Discover all the properties in a module.Functions starting with prop_ are assumed to be properties. Safe-Inferred>]hedgehogThe number of workers to use when running properties in parallel.hedgehog(How verbose should the report output be.hedgehog)Only display the summary of the test run.hedgehog?Display each property as it is running, as well as the summary.hedgehog2Whether to render output using ANSI colors or not.hedgehog%Disable ANSI colors in report output.hedgehog$Enable ANSI colors in report output.     Safe-Inferred"89:ہ hedgehog)A summary of all the properties executed. hedgehog1A report on a running or completed property test. hedgehog(The status of a completed property test.In the case of a failure it provides the seed used for the test, the number of shrinks, and the execution log. hedgehog&The status of a running property test. hedgehog)Construct a summary from a single result. hedgehogRender a compressed . hedgehogRender a compressed #, such that it can be read back in. hedgehog3The span of non-whitespace characters for the line.The result is [inclusive, exclusive).  Safe-InferredV hedgehogUpdate the number of capabilities but never set it lower than it already is.  Safe-Inferred >Z hedgehog&Configuration for a property test run. hedgehog2The number of property tests to run concurrently. E' means use one worker per processor. hedgehog&Whether to use colored output or not. E& means detect from the environment. hedgehogThe seed to use. E# means detect from the environment. hedgehog(How verbose to be in the runner output. E& means detect from the environment. hedgehogFollow a given shrink path, instead of searching exhaustively. Assume that the end of the path is minimal, and don't try to shrink any further than that.This evaluates the test for all the shrinks on the path, but not ones off-path. Because the generator is mixed with the test code, it's probably not possible to avoid this. hedgehogCheck a property. hedgehog0Check a property using a specific size and seed. hedgehog>Check a group of properties using the specified runner config. hedgehog)Check a group of properties sequentially..Using Template Haskell for property discovery: 7tests :: IO Bool tests = checkSequential $$(discover)#With manually specified properties: tests :: IO Bool tests = checkSequential $ Group "Test.Example" [ ("prop_reverse", prop_reverse) ] hedgehog(Check a group of properties in parallel.?/@/A/B/C D E F G H I J1K1L"6MNO/P/Q R S,T"6UVW/XNY/Z[\>] ^_`ab c d"ef g"eh"ei"ej"eklmnop"eq/r"es"etuvwx"eyozo{"e|u}u~"e"e"e_% 'aaaa____________________uVVVVNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN///////////////////111111[[[[[[[[%%%%%%%%%%%%%%%%%%%%%%%%%%',,,,,           w"6"6"6"6"6"6"6"6"6"6ghjn                                                                                                                                               $                                                                                                                                                                                         #hedgehog-1.2-HRY24zgrRs74I5aryTxEFQHedgehog.Internal.PreludeHedgehog.Internal.SourceHedgehogHedgehog.Internal.ShowHedgehog.Internal.DistributiveHedgehog.Internal.ExceptionHedgehog.Internal.OpaqueHedgehog.RangeHedgehog.Internal.RangeHedgehog.Internal.RegionHedgehog.Internal.SeedHedgehog.Internal.ShrinkHedgehog.Internal.Tree Hedgehog.MainHedgehog.Internal.Gen Hedgehog.GenHedgehog.Internal.PropertyHedgehog.Internal.ConfigHedgehog.Internal.StateHedgehog.Internal.DiscoveryHedgehog.Internal.THHedgehog.Internal.ReportHedgehog.Internal.QueueHedgehog.Internal.RunnerHedgehog.Internal.BarbieHedgehog.Internal.HTraversableexecuteParallelHedgehog.Internal.Tripping sequentialparallelbaseGHC.Base++ghc-primGHC.PrimseqGHC.Listzip Data.Tuplefstsnd otherwise$GHC.Num fromInteger-GHC.Real fromRationalGHC.EnumenumFrom enumFromThen enumFromToenumFromThenTo GHC.Classes==>=negate>>=>>fmapreturnControl.Monad.Failfail fromIntegral realToFrac toInteger toRational<>memptymappendmconcat<*>pure*>BoundedEnumEq GHC.FloatFloating FractionalIntegralMonadFunctorNumOrdGHC.ReadReadReal RealFloatRealFracGHC.ShowShow MonadFail Applicative Data.FoldableFoldableData.Traversable Traversable SemigroupMonoid GHC.TypesBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeOrderingRationalIOWord Data.EitherEitherGHC.Stack.Types CallStackFalseNothingJustTrueLeftRightLTEQGTmapM_unzipidData.Functor.ClassesEq1Ord1Show1uncurry&barbies-2.0.3.1-1ljX5eI0orpG39rwz2vmZ6Barbies.Internal.TraversableB btraverse TraversableBBarbies.Internal.FunctorBbmapFunctorBData.Generics.GenericNunRecRec showsPrec1eq1compare1traverse sequenceAsequencemapM System.IO writeFilereadLnreadIOreadFileputStrLnputStrputCharinteractgetLine getContentsgetChar appendFile GHC.StackwithFrozenCallStack callStackGHC.IO.ExceptionioErrorGHC.IOFilePathIOError userErrorsumproductnullminimummaximumlengthfoldr1foldrfoldl1foldlfoldMapelem sequence_ornotElem concatMapconcatanyandall Data.OldListwordsunwordsunlineslines Text.Readreadsreadeither readsPrecreadList readParenlexText.ParserCombinators.ReadPReadS significand scaleFloatisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloat decodeFloatatan2tanhtansqrtsinhsinpilogBaselogexpcoshcosatanhatanasinhasinacoshacos**truncateroundproperFractionfloorceilingremquotRemquotmoddivModdivrecip/oddlcmgcdeven^^^toEnumsuccpredfromEnumminBoundmaxBoundShowS showsPrecshowListshowshows showString showParenshowCharzipWith3zipWithzip3unzip3 takeWhiletaketailsplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatlookuplastiterateinithead dropWhiledropcyclebreak!! Data.Maybemaybe Data.Functor<$>currysignumabs+*subtractstimessconcat<$<*untilflipconstasTypeOf=<<.$!GHC.Err undefinederrorWithoutStackTraceerror HasCallStack&&not||/=<<=>comparemaxmin'pretty-show-1.10-6lSSyJ47f2OEwIxxs0u6jpText.Show.ValueNameQuoteTimeDateRatioNegListTuple InfixConsConValueMonadTransDistributive Transformer distributeT$fMonadTransDistributiveRWST$fMonadTransDistributiveRWST0$fMonadTransDistributiveStateT$fMonadTransDistributiveStateT0$fMonadTransDistributiveWriterT $fMonadTransDistributiveWriterT0$fMonadTransDistributiveReaderT$fMonadTransDistributiveExceptT$fMonadTransDistributiveMaybeT!$fMonadTransDistributiveIdentityTtryAll tryEvaluate HTraversable htraverseOpaqueunOpaque $fShowOpaque $fEqOpaque $fOrdOpaqueRangeSizeunSizeoriginbounds lowerBound upperBound singletonconstant constantFromconstantBoundedlinear linearFrom linearBounded linearFraclinearFracFromclamp scaleLinearscaleLinearFrac exponentialexponentialFromexponentialBoundedexponentialFloatexponentialFloatFromscaleExponentialscaleExponentialFloat $fReadSize $fShowSize$fFunctorRange$fEqSize $fOrdSize $fNumSize $fRealSize $fEnumSize$fIntegralSizeRegionunRegionnewEmptyRegion newOpenRegion openRegion setRegiondisplayRegions displayRegion moveToBottom finishRegionSeed seedValue seedGammarandomfrom goldenGammasplit nextWord64 nextWord32 nextInteger nextDoublemix64mix32mix64variant13mixGamma$fRandomGenSeed $fReadSeed $fShowSeed$fEqSeed $fOrdSeed$fLiftBoxedRepSeedLineDiffLineSame LineRemoved LineAdded ValueDiffValueConValueRec ValueTuple ValueList ValueSame renderValuerenderValueDiffrenderLineDiffmkValue showPrettylineDiff toLineDiff valueDifftakeLeft takeRight $fEqDocDiff $fShowDocDiff $fEqLineDiff$fShowLineDiff $fEqValueDiff$fShowValueDifftowards towardsFloatlistremoveshalvesconsNubSpanspanFile spanStartLinespanStartColumn spanEndLine spanEndColumnColumnNo unColumnNoLineNounLineNo getCaller $fShowLineNo$fShowColumnNo $fShowSpan$fEqSpan $fOrdSpan $fEqColumnNo $fOrdColumnNo $fNumColumnNo$fEnumColumnNo$fRealColumnNo$fIntegralColumnNo $fEqLineNo $fOrdLineNo $fNumLineNo $fEnumLineNo $fRealLineNo$fIntegralLineNoNodeT nodeValue nodeChildrenNodeTreeTrunTreeTTreerunTreemapTreeT fromNodeT treeValue treeChildrenunfold unfoldForestexpandprunedepth catMaybesfiltermapMaybe filterMaybeTmapMaybeMaybeTfilterT mapMaybeT consChild interleaverenderrenderT $fShow1TreeT $fShow1NodeT $fShowTreeT $fShowNodeT$fMonadResourceTreeT$fMonadErroreTreeT$fMonadWriterwTreeT$fMonadStatesTreeT$fMonadReaderrTreeT$fMonadCatchTreeT$fMonadThrowTreeT$fMonadBasebTreeT$fMonadIOTreeT$fPrimMonadTreeT$fMonadTransDistributiveTreeT $fMMonadTreeT$fMFunctorTYPETreeT$fMFunctorTYPENodeT$fMonadTransTreeT$fMonadZipTreeT$fMonadPlusTreeT$fAlternativeTreeT $fMonadTreeT $fMonadNodeT$fApplicativeTreeT$fApplicativeNodeT$fFunctorTreeT$fFunctorNodeT $fEqTreeT$fMonadBaseControlbTreeT$fTraversableNodeT$fFoldableNodeT$fTraversableTreeT$fFoldableTreeT $fEqNodeT defaultMainVecNil:.NatZSMonadGenGenBasetoGenTfromGenTGenTunGenTGenrunGenTevalGenevalGenTmapGenTfromTree fromTreeTfromTreeMaybeTtoTree toTreeMaybeTrunDiscardEffectrunDiscardEffectT generalizegenerateshrinksizedresizescalesmallgoldenintegral integral_intint8int16int32int64wordword8word16word32word64 realFloat realFrac_floatdoubleenum enumBoundedboolbool_binitoctitdigithexitlowerupperalphaalphaNumasciilatin1unicode unicodeAll isSurrogateisNoncharacterstringtextutf8byteselementelement_choice frequency recursivediscardensurejustjustTeither_nonEmptysetmapatLeastfreeze subtermMVecsubtermMsubterm subtermM2subterm2 subtermM3subterm3 subsequencesubsetshuffle shuffleSeqsampleprint printWith printTree printTreeWith renderTree$fMonadResourceGenT$fMonadErroreGenT$fMonadWriterwGenT$fMonadStatesGenT$fMonadReaderrGenT$fMonadCatchGenT$fMonadThrowGenT$fMonadBasebGenT $fMonadIOGenT$fPrimMonadGenT$fMonadTransDistributiveGenT $fMMonadGenT$fMFunctorTYPEGenT$fMonadTransGenT$fMonadPlusGenT$fAlternativeGenT$fMonadFailGenT $fMonadGenT$fApplicativeGenT $fFunctorGenT $fMonoidGenT$fSemigroupGenT$fMonadGenWriterT$fMonadGenWriterT0$fMonadGenStateT$fMonadGenStateT0$fMonadGenReaderT$fMonadGenExceptT$fMonadGenMaybeT$fMonadGenIdentityT$fMonadGenGenT$fFunctorSubterms$fFoldableSubterms$fTraversableSubterms$fTraversableVec $fFoldableVec $fFunctorVec$fMonadBaseControlbGenT MonadTestliftTestCoveragecoverageLabelsLabelMkLabel labelName labelLocation labelMinimumlabelAnnotation LabelName unLabelNameCoverPercentageunCoverPercentage CoverCount unCoverCountCoverNoCoverDiff diffPrefix diffRemoved diffInfix diffAdded diffSuffix diffValueFailureJournal journalLogsLog AnnotationFootnoteTerminationCriteriaEarlyTerminationNoEarlyTerminationNoConfidenceTermination PropertyCount GroupName unGroupNameGroup groupNamegroupProperties ShrinkRetries ShrinkPathSkip SkipNothing SkipToTest SkipToShrink ShrinkCount ShrinkLimit DiscardLimit DiscardCount TestCount TestLimitPropertyConfigpropertyDiscardLimitpropertyShrinkLimitpropertyShrinkRetriespropertyTerminationCriteria propertySkip Confidence unConfidence PropertyNameunPropertyNameTestTunTestTest PropertyT unPropertyTPropertypropertyConfig propertyTest skipCompressshrinkPathCompressskipDecompressshrinkPathDecompressmkTestTmkTestrunTestTrunTestwriteLogfailWithannotate annotateShowfootnote footnoteShowfailDiff failExceptionfailuresuccessassertdiff===/==evalevalNFevalMevalIO evalEither evalEitherM evalExceptT evalMaybe evalMaybeM forAllWithT forAllWithforAllTforAlltest defaultConfigdefaultMinTestsdefaultConfidence mapConfigwithConfidenceverifiedTermination withTests withDiscards withShrinks withRetrieswithSkipproperty toCoverCountcoverPercentage labelCoveredcoverageSuccesscoverageFailuresconfidenceSuccessconfidenceFailure wilsonBoundsjournalCoveragecoverclassifylabelcollect$fIsStringSkip $fMonoidCover$fSemigroupCover$fMonoidCoverCount$fSemigroupCoverCount$fSemigroupLabel$fMonadBaseControlbTestT$fMonadTransControlTestT$fMonadResourceTestT$fMonadErroreTestT$fPrimMonadTestT$fMonadTransDistributiveTestT$fMFunctorTYPETestT$fMonadTransTestT$fMonadFailTestT $fMonadTestT$fAlternativePropertyT$fMonadPlusPropertyT$fPrimMonadPropertyT!$fMonadTransDistributivePropertyT$fMFunctorTYPEPropertyT$fMonadFailPropertyT$fMonadTransPropertyT$fMonoidCoverage$fSemigroupCoverage$fMonadTestPropertyT$fMonadTestResourceT$fMonadTestContT$fMonadTestRWST$fMonadTestRWST0$fMonadTestWriterT$fMonadTestWriterT0$fMonadTestStateT$fMonadTestStateT0$fMonadTestReaderT$fMonadTestExceptT$fMonadTestMaybeT$fMonadTestIdentityT$fMonadTestTestT $fEqCoverage$fShowCoverage$fFunctorCoverage$fFoldableCoverage$fTraversableCoverage$fFunctorPropertyT$fApplicativePropertyT$fMonadPropertyT$fMonadIOPropertyT$fMonadBasebPropertyT$fMonadThrowPropertyT$fMonadCatchPropertyT$fMonadReaderrPropertyT$fMonadStatesPropertyT$fMonadErrorePropertyT$fFunctorTestT$fApplicativeTestT$fMonadIOTestT$fMonadBasebTestT$fMonadThrowTestT$fMonadCatchTestT$fMonadReaderrTestT$fMonadStatesTestT $fEqJournal $fShowJournal$fSemigroupJournal$fMonoidJournal$fEqLog $fShowLog $fEqLabel $fShowLabel$fFunctorLabel$fFoldableLabel$fTraversableLabel $fEqLabelName$fMonoidLabelName$fOrdLabelName$fSemigroupLabelName$fShowLabelName$fIsStringLabelName$fEqCoverPercentage$fOrdCoverPercentage$fShowCoverPercentage$fNumCoverPercentage$fFractionalCoverPercentage$fEqCoverCount$fOrdCoverCount$fShowCoverCount$fNumCoverCount $fEqCover $fOrdCover $fShowCover $fEqFailure $fShowFailure$fEqDiff $fShowDiff$fEqPropertyConfig$fOrdPropertyConfig$fShowPropertyConfig$fLiftBoxedRepPropertyConfig$fEqTerminationCriteria$fOrdTerminationCriteria$fShowTerminationCriteria!$fLiftBoxedRepTerminationCriteria$fEqPropertyCount$fOrdPropertyCount$fShowPropertyCount$fNumPropertyCount$fEnumPropertyCount$fRealPropertyCount$fIntegralPropertyCount $fEqGroupName$fOrdGroupName$fShowGroupName$fIsStringGroupName$fSemigroupGroupName$fLiftBoxedRepGroupName$fEqShrinkRetries$fOrdShrinkRetries$fShowShrinkRetries$fNumShrinkRetries$fEnumShrinkRetries$fRealShrinkRetries$fIntegralShrinkRetries$fLiftBoxedRepShrinkRetries$fEqSkip $fOrdSkip $fShowSkip$fLiftBoxedRepSkip$fEqShrinkPath$fOrdShrinkPath$fShowShrinkPath$fLiftBoxedRepShrinkPath$fEqShrinkCount$fOrdShrinkCount$fShowShrinkCount$fNumShrinkCount$fEnumShrinkCount$fRealShrinkCount$fIntegralShrinkCount$fEqShrinkLimit$fOrdShrinkLimit$fShowShrinkLimit$fNumShrinkLimit$fEnumShrinkLimit$fRealShrinkLimit$fIntegralShrinkLimit$fLiftBoxedRepShrinkLimit$fEqDiscardLimit$fOrdDiscardLimit$fShowDiscardLimit$fNumDiscardLimit$fEnumDiscardLimit$fRealDiscardLimit$fIntegralDiscardLimit$fLiftBoxedRepDiscardLimit$fEqDiscardCount$fOrdDiscardCount$fShowDiscardCount$fNumDiscardCount$fEnumDiscardCount$fRealDiscardCount$fIntegralDiscardCount $fEqTestCount$fOrdTestCount$fShowTestCount$fNumTestCount$fEnumTestCount$fRealTestCount$fIntegralTestCount$fLiftBoxedRepTestCount $fEqTestLimit$fOrdTestLimit$fShowTestLimit$fNumTestLimit$fEnumTestLimit$fRealTestLimit$fIntegralTestLimit$fLiftBoxedRepTestLimit$fEqConfidence$fOrdConfidence$fShowConfidence$fNumConfidence$fLiftBoxedRepConfidence$fEqPropertyName$fOrdPropertyName$fShowPropertyName$fIsStringPropertyName$fSemigroupPropertyName$fLiftBoxedRepPropertyName$fMonadBaseControlbPropertyT$fMonadResourcePropertyTtrippingParallelparallelPrefixparallelBranch1parallelBranch2 SequentialsequentialActionsAction actionInput actionOutput actionExecute actionRequire actionUpdate actionEnsureCommand commandGencommandExecutecommandCallbacksCallbackRequireUpdateEnsureEnvironmentErrorEnvironmentValueNotFoundEnvironmentTypeError Environment unEnvironmentVarConcreteSymbolicconcreteopaqueemptyEnvironmentinsertConcrete reifyDynamicreifyEnvironmentreify commandGenOK takeVariables variablesOK dropInvalidactionexecuteSequential $fShowName$fOrd1Symbolic $fEq1Symbolic$fShow1Symbolic$fShowSymbolic$fOrd1Concrete $fEq1Concrete$fShow1Concrete$fShowConcrete$fTraversableBTYPEVar$fFunctorBTYPEVar $fShowVar$fOrdVar$fEqVar $fShowAction$fShowSequential$fShowParallel$fEqEnvironmentError$fOrdEnvironmentError$fShowEnvironmentError$fShowEnvironment $fEqConcrete $fOrdConcrete$fFunctorConcrete$fFoldableConcrete$fTraversableConcrete$fEqName $fOrdName $fNumName $fOrdSymbolic $fEqSymbolicPos posPostionposValuePosition_posPathposLine posColumnPropertySourcepropertySourcereadPropertiesreadDeclarationfindProperties$fSemigroupPos$fEqPropertySource$fOrdPropertySource$fShowPropertySource$fEqPos$fOrdPos $fShowPos $fFunctorPos $fEqPosition $fOrdPosition$fShowPosition$fEqClassified$fOrdClassified$fShowClassified $fEqClass $fOrdClass $fShowClassTExpQdiscoverdiscoverPrefix WorkerCount VerbosityQuietNormalUseColor DisableColor EnableColor detectMark detectColor detectSeeddetectVerbosity detectWorkers detectSkip resolveColor resolveSeedresolveVerbosityresolveWorkers resolveSkip$fEqWorkerCount$fOrdWorkerCount$fShowWorkerCount$fNumWorkerCount$fEnumWorkerCount$fRealWorkerCount$fIntegralWorkerCount$fLiftBoxedRepWorkerCount $fEqVerbosity$fOrdVerbosity$fShowVerbosity$fLiftBoxedRepVerbosity $fEqUseColor $fOrdUseColor$fShowUseColor$fLiftBoxedRepUseColorMarkup WaitingIcon WaitingHeader RunningIcon RunningHeader ShrinkingIconShrinkingHeader FailedIcon FailedText GaveUpIcon GaveUpText SuccessIcon SuccessText CoverageIcon CoverageText CoverageFillDeclarationLocation StyledLineNo StyledBorder StyledSourceAnnotationGutterAnnotationValue FailureArrows FailureGutterFailureMessage DiffPrefix DiffInfix DiffSuffixDiffSame DiffRemoved DiffAddedReproduceHeaderReproduceGutterReproduceSourceStyle StyleDefaultStyleAnnotation StyleFailureSummarysummaryWaitingsummaryRunning summaryFailed summaryGaveUp summaryOKReport reportTestsreportDiscardsreportCoverage reportSeed reportStatusResultFailedGaveUpOKProgressRunning Shrinking FailureReportfailureShrinksfailureShrinkPathfailureCoveragefailureAnnotationsfailureLocationfailureMessage failureDifffailureFootnotesFailedAnnotation failedSpan failedValue fromResult mkFailure ppProgressppResult ppSummary renderDocrenderProgress renderResult renderSummary$fSemigroupSummary$fMonoidSummary$fSemigroupStyle$fMonoidColumnWidth$fSemigroupColumnWidth $fEqMarkup $fOrdMarkup $fShowMarkup $fEqStyle $fOrdStyle $fShowStyle$fEqDeclaration$fOrdDeclaration$fShowDeclaration$fFunctorDeclaration$fEqLine $fOrdLine $fShowLine $fFunctorLine $fShowSummary $fShowReport$fFunctorReport$fFoldableReport$fTraversableReport $fEqResult $fShowResult $fEqProgress$fShowProgress$fEqFailureReport$fShowFailureReport$fEqFailedAnnotation$fShowFailedAnnotationTasksRemaining TaskIndex dequeueMVarrunTasksrunActiveFinalizers finalizeTaskupdateNumCapabilities $fEqTaskIndex$fOrdTaskIndex$fEnumTaskIndex$fNumTaskIndex RunnerConfig runnerWorkers runnerColor runnerSeedrunnerVerbosity checkReport checkRegion checkNamedcheckrecheck recheckAt checkGroupcheckSequential checkParallel$fEqRunnerConfig$fOrdRunnerConfig$fShowRunnerConfig$fLiftBoxedRepRunnerConfigGHC.WordWord64nextWord32emptysplitswithGenTintegralHelperbytestring-0.11.3.1Data.ByteString.Internal ByteString<|> uniqueByKeyfailExceptionWithControl.Monad.IO.ClassliftIOtransformers-0.5.6.2Control.Monad.Trans.ExceptExceptT,monad-control-1.0.3.1-GUowGCcH8pF8zTgO3n351lControl.Monad.Trans.ControlMonadTransControlMonadBaseControl Data.DynamicDynamic takeSymbolicinsertSymbolicexecuteUpdateEnsureppSkipppSkipReadablelineSpan skipToShrink