h&      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~, (c) Simon Marlow 2012BSD3 (see the file LICENSE)!Simon Marlow  provisional#non-portable (requires concurrency) Trustworthy09 hspec-coreA value of type Concurrently a is an IO, operation that can be composed with other  Concurrently values, using the  Applicative and  Alternative instances.Calling runConcurrently on a value of type Concurrently a will execute the IO operations it contains concurrently, before delivering the result of type a. For example (page1, page2, page3) <- runConcurrently $ (,,) <$> Concurrently (getURL "url1") <*> Concurrently (getURL "url2") <*> Concurrently (getURL "url3") hspec-coreThe exception thrown by  to terminate a thread. hspec-core"An asynchronous action spawned by  or . Asynchronous actions are executed in a separate thread, and operations are provided for waiting for asynchronous actions to complete and obtaining their results (see e.g. ). hspec-core Returns the " of the thread running the given . hspec-core:Compare two Asyncs that may have different types by their . hspec-core2Spawn an asynchronous action in a separate thread. Like for , the action may be left running unintentinally (see module-level documentation for details).Use * style functions wherever you can instead! hspec-coreLike  but using  internally. hspec-coreLike  but using  internally. hspec-coreLike  but using  internally. The child thread is passed a function that can be used to unmask asynchronous exceptions. hspec-coreLike  but using  internally. The child thread is passed a function that can be used to unmask asynchronous exceptions. hspec-coreSpawn an asynchronous action in a separate thread, and pass its Async handle to the supplied function. When the function returns or throws an exception,  is called on the Async. withAsync action inner = mask $ \restore -> do a <- async (restore action) restore (inner a) `finally` uninterruptibleCancel aThis is a useful variant of  that ensures an Async( is never left running unintentionally.Note: a reference to the child thread is kept alive until the call to  returns, so nesting many  calls requires linear memory. hspec-coreLike  but uses  internally. hspec-coreLike  but uses  internally. hspec-coreLike  but uses  internally. The child thread is passed a function that can be used to unmask asynchronous exceptions. hspec-coreLike  but uses  internally. The child thread is passed a function that can be used to unmask asynchronous exceptions hspec-coreWait for an asynchronous action to complete, and return its value. If the asynchronous action threw an exception, then the exception is re-thrown by . wait = atomically . waitSTM hspec-coreWait for an asynchronous action to complete, and return either Left e# if the action raised an exception e, or Right a if it returned a value a. %waitCatch = atomically . waitCatchSTM hspec-coreCheck whether an  has completed yet. If it has not completed yet, then the result is Nothing, otherwise the result is Just e where e is Left x if the Async raised an exception x, or Right a if it returned a value a. poll = atomically . pollSTM hspec-core A version of , that can be used inside an STM transaction. hspec-core A version of , that can be used inside an STM transaction. hspec-core A version of , that can be used inside an STM transaction. hspec-core.Cancel an asynchronous action by throwing the AsyncCancelled' exception to it, and waiting for the ' thread to quit. Has no effect if the  has already completed. cancel a = throwTo (asyncThreadId a) AsyncCancelled <* waitCatch a Note that ) will not terminate until the thread the , refers to has terminated. This means that  will block for as long said thread blocks when receiving an asynchronous exception.For example, it could block if:It's executing a foreign call, and thus cannot receive the asynchronous exception;It's executing some cleanup handler after having received the exception, and the handler is blocking. hspec-coreCancel an asynchronous actionThis is a variant of , but it is not interruptible. hspec-coreCancel an asynchronous action by throwing the supplied exception to it. ,cancelWith a x = throwTo (asyncThreadId a) x*The notes about the synchronous nature of  also apply to . hspec-coreWait for any of the supplied asynchronous operations to complete. The value returned is a pair of the ; that completed, and the result that would be returned by  on that . If multiple s complete or have completed, then the value returned corresponds to the first completed  in the list. hspec-core A version of , that can be used inside an STM transaction. hspec-coreLike , but also cancels the other asynchronous operations as soon as one has completed. hspec-coreWait for any of the supplied Asyncs to complete. If the first to complete throws an exception, then that exception is re-thrown by . If multiple s complete or have completed, then the value returned corresponds to the first completed  in the list. hspec-core A version of , that can be used inside an STM transaction. hspec-coreLike , but also cancels the other asynchronous operations as soon as one has completed. hspec-coreWait for the first of two Async s to finish. hspec-core A version of , that can be used inside an STM transaction. hspec-coreLike  , but also s both Asyncs before returning. hspec-coreWait for the first of two Asyncs to finish. If the Async that finished first raised an exception, then the exception is re-thrown by . hspec-core A version of , that can be used inside an STM transaction. hspec-coreLike , but the result is ignored. hspec-core A version of , that can be used inside an STM transaction. hspec-coreLike  , but also s both Asyncs before returning. hspec-coreWaits for both Asyncs to finish, but if either of them throws an exception before they have both finished, then the exception is re-thrown by . hspec-core A version of , that can be used inside an STM transaction. hspec-coreLink the given Async* to the current thread, such that if the Async raises an exception, that exception will be re-thrown in the current thread, wrapped in . ignores > exceptions thrown in the other thread, so that it's safe to  a thread you're linked to. If you want different behaviour, use . hspec-coreLink the given Async* to the current thread, such that if the Async raises an exception, that exception will be re-thrown in the current thread, wrapped in .The supplied predicate determines which exceptions in the target thread should be propagated to the source thread. hspec-core Link two Asyncs together, such that if either raises an exception, the same exception is re-thrown in the other Async, wrapped in . ignores ' exceptions, so that it's possible to  either thread without cancelling the other. If you want different behaviour, use . hspec-core Link two Asyncs together, such that if either raises an exception, the same exception is re-thrown in the other Async, wrapped in .The supplied predicate determines which exceptions in the target thread should be propagated to the source thread. hspec-coreRun two IO actions concurrently, and return the first to finish. The loser of the race is led. race left right = withAsync left $ \a -> withAsync right $ \b -> waitEither a b hspec-coreLike , but the result is ignored. hspec-coreRun two IO actions concurrently, and return both results. If either action throws an exception at any time, then the other action is (led, and the exception is re-thrown by . concurrently left right = withAsync left $ \a -> withAsync right $ \b -> waitBoth a b hspec-core, but ignore the result values hspec-coreMaps an -performing function over any  data type, performing all the IO actions concurrently, and returning the original data structure with the arguments replaced by the results.If any of the actions throw an exception, then all other actions are cancelled and the exception is re-thrown. For example, mapConcurrently works with lists: 8pages <- mapConcurrently getURL ["url1", "url2", "url3"]Take into account that async will try to immediately spawn a thread for each element of the  Traversable, so running this on large inputs without care may lead to resource exhaustion (of memory, file descriptors, or other limited resources). hspec-core is  with its arguments flipped pages <- forConcurrently ["url1", "url2", "url3"] $ \url -> getURL url hspec-core is > with the return value discarded; a concurrent equivalent of . hspec-core is > with the return value discarded; a concurrent equivalent of . hspec-core2Perform the action in the given number of threads. hspec-coreSame as , but ignore the results. hspec-coreFork a thread that runs the supplied action, and if it raises an exception, re-runs the action. The thread terminates only when the action runs to completion without raising an exception. hspec-core hspec-coreOnly defined by async for  base >= 4.9 hspec-corereturn ) if the exception should be propagated,  otherwise.; 1(c) Sterling Clover 2008-2011, Kevin Charter 2011 BSD 3 Clauses.clover@gmail.com experimentalportable Safe-Inferred83 hspec-coreA value is either from the  list, the  or from .  contains both the left and right values, in case you are using a form of equality that doesn't check all data (for example, if you are using a newtype to only perform equality on side of a tuple). hspec-coreTakes two lists and returns a list of differences between them. This is  with  used as predicate. hspec-coreTakes two lists and returns a list of differences between them, grouped into chunks. This is  with  used as predicate. hspec-core A form of  with no  constraint. Instead, an equality predicate is taken as the first argument.  Safe-Inferred4  Safe-Inferred4I  Safe-Inferred8E Safe-Inferred89:8~5 Safe-Inferred8  Safe-Inferred8 Safe-Inferred9g hspec-coreLocation' is used to represent source locations. Safe-Inferred(:! hspec-core"Split a string at line boundaries.splitLines "foo\nbar\nbaz"["foo\n","bar\n","baz"]concat (splitLines xs) == xs Safe-Inferred8:U Safe-Inferred:  Safe-Inferred: Safe-Inferred": Safe-Inferred8; Safe-Inferred/;P Safe-Inferred;unstable Safe-Inferred(AE  hspec-coreA  : describes the location of a spec item within a spec tree.It consists of a list of group descriptions and a requirement description.  hspec-corepluralize count singular pluralizes the given singular word unless given count is 1. Examples:pluralize 0 "example" "0 examples"pluralize 1 "example" "1 example"pluralize 2 "example" "2 examples"  hspec-core%Strip leading and trailing whitespace  hspec-core,Ensure that lines are not longer than given n(, insert line breaks at word boundaries   hspec-core#Remove ANSI color escape sequences. hspec-coreJoin a   with slashes. The result will have a leading and a trailing slash. hspec-coreTry to create a proper English sentence from a path by applying some heuristics. hspec-core3A predicate that can be used to filter a spec tree. hspec-core The function # converts an exception to a string.This is different from /. The type of the exception is included, e.g.:*formatException (toException DivideByZero) "ArithException\ndivide by zero"For s the  is included, as well. hspec-coresafeTry evaluates given action and returns its result. If an exception occurs, the exception is returned instead. Unlike , it is agnostic to asynchronous exceptions.   Safe-Inferred%&A Safe-Inferred %&B hspec-core The result of running an example! hspec-coreAn ) action that expects an argument of type a( hspec-coreA type class for examples# !"#$%&'()*+,- Safe-Inferred/89:F . hspec-coreItem is used to represent spec items internally. A spec item consists of:+a textual description of a desired behavioran example for that behavioradditional meta information&Everything that is an instance of the ( type class can be used as an example, including QuickCheck properties, Hspec expectations and HUnit assertions.0 hspec-coreTextual description of behavior1 hspec-core Source location of the spec item2 hspec-coreA flag that indicates whether it is safe to evaluate this spec item in parallel with other spec items3 hspec-core8A flag that indicates whether this spec item is focused.4 hspec-coreExample for behavior5 hspec-coreA tree is used to represent a spec internally. The tree is parameterized over the type of cleanup actions and the type of the actual spec items.6 hspec-coreInternal tree data structureB hspec-coreThe  specGroup6 function combines a list of specs into a larger spec.C hspec-coreThe specItem function creates a spec item../0123456789:;<=>?@ABCD Safe-InferredGDunstable Safe-InferredG|3 #EFGHIJKLMNOPQRSTU\YVWXZ[]^`_abcdefgh3gEFGHIJKLMNOPQRSTU\YVWXZ[# abcdef]^`_h Safe-InferredI l hspec-coreSummary of a test run.t  hspec-coreu  hspec-corev  hspec-corew  hspec-corex  hspec-corey  hspec-corez  hspec-core| hspec-core if the given l) indicates that there were no failures,  otherwise.lmnopqrstvuwyxz{| Safe-Inferred%&N hspec-core9Get the number of successful examples encountered so far. hspec-core6Get the number of pending examples encountered so far. hspec-core5Get the number of failed examples encountered so far. hspec-core4Get the total number of examples encountered so far. hspec-core-Get the list of accumulated failure messages. hspec-core,The random seed that is used for QuickCheck. hspec-coreReturn  if the user requested time reporting for individual spec items,  otherwise. hspec-core:Get the used CPU time since the test run has been started. hspec-core=Get the passed real time since the test run has been started. hspec-core!Append some output to the report. hspec-core The same as , but adds a newline character. hspec-coreSet output color to red, run given action, and finally restore the default color. hspec-coreSet output color to green, run given action, and finally restore the default color. hspec-coreSet output color to yellow, run given action, and finally restore the default color. hspec-coreSet output color to cyan, run given action, and finally restore the default color. hspec-coreReturn ( if the user requested colorized diffs,  otherwise. hspec-coreOutput given chunk in red. hspec-coreOutput given chunk in green.]^`_abcdef}~  Safe-Inferred%&Yz hspec-core5Get the number of failed examples encountered so far. hspec-coreReturn ( if the user requested colorized diffs,  otherwise.  hspec-core9Do nothing on `--expert`, otherwise run the given action.  hspec-coreReturn the value of !.  hspec-coreAn action for printing diffs.The action takes expected and actual as arguments.When this is a -value then it should be used instead of any built-in diff implementation. A -value also implies that  returns . hspec-coreReturn % if the user requested pretty diffs,  otherwise.  hspec-coreReturn a function for pretty-printing if the user requested pretty diffs,  otherwise.  hspec-coreReturn ' if the user requested unicode output,  otherwise. hspec-core The same as , but adds a newline character. hspec-coreReturn  if the user requested time reporting for individual spec items,  otherwise. hspec-core4Get the total number of examples encountered so far. hspec-coreA lifted version of "# hspec-coreA lifted version of "$ hspec-core,The random seed that is used for QuickCheck. hspec-core,Increase the counter for successful examples hspec-core)Increase the counter for pending examples hspec-core9Get the number of successful examples encountered so far. hspec-core6Get the number of pending examples encountered so far. hspec-core-Get the list of accumulated failure messages.  hspec-coreGet the number of spec items that will have been encountered when this run completes (if it is not terminated early). hspec-core!Append some output to the report. hspec-coreSet output color to red, run given action, and finally restore the default color. hspec-coreSet output color to green, run given action, and finally restore the default color. hspec-coreSet output color to yellow, run given action, and finally restore the default color. hspec-coreSet output color to cyan, run given action, and finally restore the default color. hspec-core5Set a color, run an action, and finally reset colors. hspec-coreOutput given chunk in red. hspec-coreOutput given chunk in green. hspec-core:Get the used CPU time since the test run has been started. hspec-core=Get the passed real time since the test run has been started.:]^`_abcdefunstable Safe-InferredZ #]^`_abcdef #abcdef]^`_% Safe-Inferred%&[3& Safe-Inferred%&'[a2}~ deprecated Safe-Inferred[2}~2}~' Safe-Inferred\2}~( Safe-Inferred]X) Safe-Inferred]* Safe-Inferred]+ Safe-Inferred^4  hspec-core  hspec-core5, Safe-Inferreda hspec-coreA writer monad for 5 forests  hspec-core hspec-core Convert a  to a forest of 5s. hspec-core Create a  from a forest of 5s. hspec-core Create a  from a forest of 5s. hspec-core2Run an IO action while constructing the spec tree. is a monad to construct a spec tree, without executing any spec items. runIO allows you to run IO actions during this construction phase. The IO action is always run when the spec tree is constructed (e.g. even when  --dry-run is specified). If you do not need the result of the IO action to construct the spec tree, -( may be more suitable for your use case. hspec-coreDeprecated: Use  instead. provisional Safe-Inferred/gm hspec-core+Run a custom action before every spec item. hspec-core+Run a custom action before every spec item. hspec-core+Run a custom action before every spec item. hspec-core/Run a custom action before the first spec item. hspec-core/Run a custom action before the first spec item. hspec-coreRun a custom action with an argument before the first spec item. hspec-core*Run a custom action after every spec item. hspec-core*Run a custom action after every spec item. hspec-core8Run a custom action before and/or after every spec item. hspec-core-Run a custom action after the last spec item. hspec-core-Run a custom action after the last spec item. hspec-core8Run a custom action before and/or after every spec item. hspec-core8Run a custom action before and/or after every spec item. hspec-core%Wrap an action around the given spec. hspec-core%Wrap an action around the given spec. hspec-coreWrap an action around the given spec. Changes the arg type inside. hspec-coreModify the subject under test.Note that this resembles a contravariant functor on the first type parameter of . This is because the subject is passed inwards, as an argument to the spec item. hspec-core/Ignore the subject under test for a given spec.!!unstable Safe-Inferred/pn hspec-coreThe describe6 function combines a list of specs into a larger spec. hspec-corecontext is an alias for . hspec-core Changing  to > marks all spec items of the corresponding subtree as pending.3This can be used to temporarily disable spec items. hspec-corexcontext is an alias for . hspec-coreThe it function creates a spec item.A spec item consists of:+a textual description of a desired behavioran example for that behavior describe "absolute" $ do it "returns a positive number when given a negative number" $ absolute (-1) == 1 hspec-corespecify is an alias for . hspec-core Changing  to . marks the corresponding spec item as pending.4This can be used to temporarily disable a spec item. hspec-corexspecify is an alias for . hspec-core* focuses all spec items of the given spec. Applying 1 to a spec with focused spec items has no effect. hspec-corefit is an alias for fmap focus . it hspec-corefspecify is an alias for . hspec-core fdescribe is an alias for fmap focus . describe hspec-corefcontext is an alias for . hspec-core marks all spec items of the given spec to be safe for parallel evaluation. hspec-core marks all spec items of the given spec to be evaluated sequentially. hspec-core, can be used to mark a spec item as pending.If you want to textually specify a behavior but do not have an example yet, use this: describe "fancyFormatter" $ do it "can format text in a way that everyone likes" $ pending hspec-core is similar to , but it takes an additional string argument that can be used to specify the reason for why the spec item is pending.  hspec-coreGet the path of  labels, from the root all the way in to the call-site of this function.Example:{ runSpecM $ do describe "foo" $ do describe "bar" $ do. getSpecDescriptionPath >>= runIO . print:} ["foo","bar"] !"#$%&'()*+,-./0123456789:;<=>?@ABCD()*$%&'+!#" -,56789./01234BC;:<=>?A@D. Safe-Inferred%&/89:q hspec-core;Evaluate all examples of a given spec and produce a report. provisional Safe-InferredsV hspec-coreUse a modified  for given spec. hspec-coreUse a modified  for given spec. hspec-coreUse a modified  for given spec. hspec-coreUse a modified  for given spec. hspec-core Use modified  for given spec./ Safe-Inferreds 0 Safe-Inferreds1 Safe-Inferredw hspec-coreAdd a filter predicate to config. If there is already a filter predicate, then combine them with . hspec-core> parses config options from several sources and constructs a  value. It takes options from: ~/.hspec- (a config file in the user's home directory).hspec1 (a config file in the current working directory) https://hspec.github.io/options.html#specifying-options-through-environment-variables$environment variables starting with HSPEC_the provided list of command-line options (the second argument to  readConfig)(precedence from low to high)When parsing fails then  readConfig writes an error message to  and exits with .When --help+ is provided as a command-line option then  readConfig writes a help message to  and exits with .A common way to use  readConfig is: 23 >>= readConfig  4 provisional Safe-Inferred   hspec-core(Make a formatter available for use with --format.  hspec-core(Make a formatter available for use with --format and use it by default. hspec-core'Run a given spec and write a report to  . Exit with ! if at least one spec item fails.Note:  handles command-line options and reads config files. This is not always desirable. Use  and . if you need more control over these aspects.  hspec-core Evaluate a  to a forest of 5s. This does not execute any spec items, but it does run any IO that is used during spec construction time (see ).A  may modify a  through . These modifications are applied to the given config (the first argument). hspec-core8Run given spec with custom options. This is similar to , but more flexible. hspec-core Exit with  if the given l0 indicates that there was at least one failure. hspec-core5Run given spec and returns a summary of the test run.Note:  does not exit with  on failing spec items. If you need this, you have to check the l yourself and act accordingly. hspec-coreRun given spec with custom options and returns a summary of the test run.Note:  does not exit with  on failing spec items. If you need this, you have to check the l yourself and act accordingly. hspec-coreNote: > is deprecated. It ignores any modifications applied through . Use  and  instead.  hspec-core, is the most basic primitive to run a spec.  is defined in terms of  runSpecForest: hspec =   >=> \ (config, spec) ->  >>=  config >>=  [] . runSpecForest spec >>=  lmnopqrstuvwxyz{|lmno|wxy{tuvzpqrs 456789 : :;;<=>?@ABCDEFGHIJKLMNOPQRSSTUVWXYYZ[\]^_`abbcdefghijklmnopqrstuvwxxyz{|}~XSPQRbbdIJKMN                                          &&&&&&++++++++++++++++++++++++++++!++++++++++++++++++,,,,,,,,,,,,-111        4 4 4 4 4 4                                     4  4 4                         444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444442444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444             ]4 # $   %())P)R))))+++++++,,,,,..................i.j.k.l/////////0000444411142342(hspec-core-2.11.2-Hqk20we27iGDA1pmXrmzhfTest.Hspec.Core.SpecTest.Hspec.Core.FormatTest.Hspec.Core.UtilTest.Hspec.Core.HooksTest.Hspec.Core.RunnerTest.Hspec.Core.Formatters.V1Test.Hspec.Core.Formatters.V2Test.Hspec.Core.QuickCheckControl.Concurrent.AsyncData.Algorithm.DiffPaths_hspec_coreTest.Hspec.Core.CompatTest.Hspec.Core.ClockNonEmptyGetOpt.Declarative.TypesGetOpt.Declarative.Environment Test.Hspec.Core.Example.LocationTest.Hspec.Core.Formatters.Diff/Test.Hspec.Core.Formatters.Pretty.Parser.Parser(Test.Hspec.Core.Formatters.Pretty.Parser)Test.Hspec.Core.Formatters.Pretty.Unicode!Test.Hspec.Core.Formatters.Pretty"Test.Hspec.Core.Formatters.V1.FreeTest.Hspec.Core.Runner.JobQueueTest.Hspec.Core.TimerTest.Hspec.Core.QuickCheckUtilTest.Hspec.Core.ExampleTest.Hspec.Core.TreeTest.Hspec.Core.ShuffleTest.Hspec.Core.Runner.Result#Test.Hspec.Core.Formatters.V1.Monad#Test.Hspec.Core.Formatters.InternalconfigDiffContextControl.Monad.Trans.Stategetsmodify)Test.Hspec.Core.Runner.PrintSlowSpecItems&Test.Hspec.Core.Formatters.V1.InternalTest.Hspec.Core.FormattersGetOpt.Declarative.UtilGetOpt.Declarative.InterpretGetOpt.Declarative!Test.Hspec.Core.Config.DefinitionTest.Hspec.Core.Spec.Monad beforeAllTest.Hspec.Core.Runner.EvalTest.Hspec.Core.FailureReportTest.Hspec.Core.Config.OptionsTest.Hspec.Core.ConfigSystem.EnvironmentgetArgsbaseGHC.Stack.Types HasCallStack/hspec-expectations-0.8.3-1P1KHTjynHR10MJ2lwFtSXTest.Hspec.Expectations ExpectationSecondsLocation locationFile locationLinelocationColumnPath pluralizestrip lineBreaksAt stripAnsijoinPathformatRequirementfilterPredicateformatExceptionsafeTry FailureReasonNoReasonReasonColorizedReasonExpectedButGotError ResultStatusSuccessPendingFailureResult resultInfo resultStatus ActionWithProgressCallbackProgressParamsparamsQuickCheckArgsparamsSmallCheckDepthExampleArgevaluateExample defaultParamssafeEvaluateExample safeEvaluateItemitemRequirement itemLocationitemIsParallelizable itemIsFocused itemExampleSpecTreeTreeNodeNodeWithCleanupLeaf bimapForest bimapTree filterTree filterForestfilterTreeWithLabelsfilterForestWithLabels pruneForest pruneTree specGroupspecItemlocation FormatConfigformatConfigUseColorformatConfigReportProgressformatConfigOutputUnicodeformatConfigUseDiffformatConfigDiffContextformatConfigExternalDiffformatConfigPrettyPrintformatConfigPrettyPrintFunctionformatConfigPrintTimesformatConfigHtmlOutputformatConfigPrintCpuTimeformatConfigUsedSeedformatConfigExpectedTotalCountformatConfigExpertModeEventStarted GroupStarted GroupDone ItemStartedItemDoneDone itemDurationitemInfo itemResultFormatmonadic $fShowEvent $fShowItem $fShowResultSummarysummaryExamplessummaryFailuresResultItemStatusResultItemSuccessResultItemPendingResultItemFailure ResultItemresultItemPathresultItemStatus SpecResultspecResultItemsspecResultSuccessresultItemIsFailure toSummary isSuccessFormatM FailureRecordfailureRecordLocationfailureRecordPathfailureRecordMessage FormatterheaderFormatterexampleGroupStartedexampleGroupDoneexampleStartedexampleProgressexampleSucceeded exampleFailedexamplePendingfailedFormatterfooterFormattergetSuccessCountgetPendingCount getFailCount getTotalCountgetFailMessagesusedSeed getCPUTime getRealTimewrite writeLinewriteTransient withFailColorwithSuccessColorwithPendingColor withInfoColoruseDiff extraChunk missingChunkformatterStartedformatterGroupStartedformatterGroupDoneformatterProgressformatterItemStartedformatterItemDone formatterDoneformatterToFormat unlessExpert diffContextexternalDiffAction prettyPrintprettyPrintFunction outputUnicode printTimesgetExpectedTotalCountsilentchecksspecdocprogressfailed_examplesformatLocation$fEqStartsWith$fEqColorChunk$fShowColorChunk $fEqChunk $fShowChunkConfigconfigIgnoreConfigFile configDryRunconfigFocusedOnlyconfigFailOnEmptyconfigFailOnFocusedconfigFailOnPendingconfigFailOnEmptyDescriptionconfigPrintSlowItemsconfigPrintCpuTimeconfigFailFastconfigRandomizeconfigFailureReport configRerunconfigRerunAllOnSuccessconfigFilterPredicateconfigSkipPredicateconfigQuickCheckSeedconfigQuickCheckMaxSuccessconfigQuickCheckMaxDiscardRatioconfigQuickCheckMaxSizeconfigQuickCheckMaxShrinksconfigSmallCheckDepthconfigColorModeconfigUnicodeMode configDiffconfigExternalDiffconfigPrettyPrintconfigPrettyPrintFunction configTimesconfigExpertModeconfigAvailableFormatters configFormatconfigFormatterconfigHtmlOutputconfigConcurrentJobs UnicodeMode UnicodeAuto UnicodeNever UnicodeAlways ColorMode ColorAuto ColorNever ColorAlwaysSpecMSpecWithSpec modifyConfigrunSpecM fromSpecListrunIO mapSpecForest mapSpecItem mapSpecItem_ modifyParamsbeforebefore_ beforeWith beforeAll_ beforeAllWithafterafter_aroundafterAll afterAll_around_ aroundWith aroundAll aroundAll_ aroundAllWith mapSubject ignoreSubjectdescribecontext xdescribexcontextitspecifyxitxspecifyfocus focusForestfitfspecify fdescribefcontextparallel sequentialpending pendingWithgetSpecDescriptionPathmodifyMaxSuccessmodifyMaxDiscardRatio modifyMaxSizemodifyMaxShrinks modifyArgs defaultConfigconfigAddFilter readConfigregisterFormatterregisterDefaultFormatterhspecevalSpec hspecWithevaluateSummaryevaluateResult hspecResulthspecWithResultrunSpec runSpecForest $fEqUseColor$fShowUseColor$fEqProgressReporting$fShowProgressReporting ConcurrentlyAsyncCancelledcancelAsyncasync withAsyncwait asyncThreadId GHC.Conc.SyncThreadId compareAsyncsforkIO asyncBoundControl.ConcurrentforkOSasyncOnforkOnasyncWithUnmaskforkIOWithUnmaskasyncOnWithUnmaskforkOnWithUnmaskuninterruptibleCancelwithAsyncBound withAsyncOnwithAsyncWithUnmaskwithAsyncOnWithUnmask waitCatchpollwaitSTM waitCatchSTMpollSTM cancelWith waitAnyCatchwaitAnyCatchSTMwaitAnyCatchCancelwaitAny waitAnySTM waitAnyCancelwaitEitherCatchwaitEitherCatchSTMwaitEitherCatchCancel waitEither waitEitherSTM waitEither_waitEitherSTM_waitEitherCancelwaitBoth waitBothSTMlinkExceptionInLinkedThreadlinkOnlylink2 link2Onlyracerace_ concurrently concurrently_mapConcurrentlyghc-prim GHC.TypesIOData.Traversable TraversableforConcurrentlymapConcurrently_ Data.FoldablemapM_forConcurrently_forM_replicateConcurrentlyreplicateConcurrently_ forkRepeat$fMonoidConcurrently$fSemigroupConcurrentlyTrueFalserunConcurrentlyDiffFirstSecondBothgetDiff getDiffBy GHC.Classes==getGroupedDiffgetGroupedDiffByEqversiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirGHC.Base++GHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwiseassertmap$GHC.Real fromIntegral realToFrac Control.MonadguardjoinGHC.EnumBoundedminBoundmaxBoundEnumsuccpredtoEnumfromEnumenumFrom enumFromThen enumFromToenumFromThenTo/= GHC.FloatFloatingtanhtansqrtsinhsinpilogBaselogexpcoshcosatanhatanasinhasinacosh**acos Fractionalrecip fromRational/IntegralremquotRemquotmoddivMod toIntegerdivMonad>>=return>>Functorfmap<$GHC.NumNumsignumabs*+negate fromInteger-Ord<<=>maxmin>=compareGHC.ReadRead readsPrecreadListReal toRational RealFloat significand scaleFloatisNegativeZeroisNaN isInfiniteisIEEEisDenormalized floatRange floatRadix floatDigitsexponent encodeFloatatan2 decodeFloatRealFractruncateroundproperFractionceilingfloorGHC.ShowShowshowListshow showsPrecControl.Monad.Fail MonadFailfail ApplicativeliftA2<*pure*><*>Foldablefoldr'foldMap'foldMapfoldsumproductnullminimummaximumfoldr1foldl1foldl'elemfoldllengthfoldrtoListtraversesequencemapM sequenceA Semigroup<>MonoidmemptymconcatmappendBoolStringCharDoubleFloatInt ghc-bignumGHC.Num.IntegerInteger GHC.MaybeMaybeNothingJustOrderingGTLTEQRationalWord Data.EitherEitherRightLeftShowSGHC.ResponseFile unescapeArgs lookupEnv zipWithM_zipWithMunless replicateM_ replicateMmfilter mapAndUnzipMforeverfoldM_foldMfilterM>=><=<<$!> mapAccumR mapAccumLforMforfoldMapDefault fmapDefaultControl.ApplicativeZipList getZipList WrappedMonad WrapMonad unwrapMonad WrappedArrow WrapArrow unwrapArrowoptional Control.Arrowsecondfirst&&& writeFilereadLnreadIOreadFileputStrLnputStrputCharinteractgetLine getContentsgetChar appendFileControl.ExceptionHandlercatchesallowInterruptControl.Exception.Base TypeError RecUpdError RecSelError RecConErrorPatternMatchFailNonTermination NoMethodErrorNestedAtomicallytryJusttry onException mapException handleJusthandlefinally catchJustbracket_bracketOnErrorbracketthrowToGHC.IO.ExceptionSomeAsyncExceptionDeadlockCompactionFailedBlockedIndefinitelyOnSTMBlockedIndefinitelyOnMVarAsyncException UserInterrupt ThreadKilled HeapOverflow StackOverflowAssertionFailedArrayExceptionIndexOutOfBoundsUndefinedElementAllocationLimitExceededioErrorasyncExceptionToExceptionasyncExceptionFromException Data.IORef modifyIORef' modifyIORef mkWeakIORefatomicWriteIORefatomicModifyIORef GHC.IORefIORef writeIORef readIORefnewIORefatomicModifyIORef'GHC.IO MaskingStateUnmaskedMaskedInterruptibleMaskedUninterruptibleFilePathuninterruptibleMask_uninterruptibleMaskthrowIOmask_mask interruptiblegetMaskingStateevaluatecatch IOExceptionIOError userError GHC.Exception ErrorCallErrorCallWithLocationthrowGHC.Exception.Type Exception toExceptiondisplayException fromExceptionArithExceptionRatioZeroDenominatorLossOfPrecision DivideByZeroDenormal UnderflowOverflowData.Functor.ConstConstgetConst traverse_ sequence_ sequenceA_ornotElemmsum minimumBy maximumByfor_foldrMfoldlMfind concatMapconcatasumanyandall Data.OldListwordsunwordsunlinestails stripPrefixsortOnsortBylines isSuffixOf isPrefixOf isInfixOf intercalateinits Data.MonoidLastgetLastgetFirstApgetApData.Semigroup.InternalSumgetSumProduct getProductEndoappEndoDualgetDualAnygetAnyAltgetAltAllgetAll Text.Readreads readMaybereadeitherControl.Category>>> readParenlexText.ParserCombinators.ReadPReadSoddlcmgcdeven^^^shows showString showParenshowCharzipWith3zipWithzip3unzip3unzip takeWhiletaketailsplitAtspanscanr1scanrscanl1scanlreverse replicaterepeatlookuplastiterateinithead dropWhiledropcyclebreak!! Data.Maybe maybeToListmaybemapMaybe listToMaybe isNothingisJust fromMaybefromJust catMaybes Data.Boolbool Data.Functorvoid<&><$>uncurrycurrysubtract MonadPlusmplusmzero Alternativesomemany<|>emptywhenuntilliftM5liftM4liftM3liftM2liftMliftA3liftAidflipconstasTypeOfap=<<<**>.$!GHC.Err undefinederrorWithoutStackTraceerror SomeException&&not||showType showFullTypegetDefaultConcurrentJobsguardedendsWithpassdietoMillisecondstoMicrosecondsgetMonotonicTimemeasuresleeptimeout:|nonEmpty OptionSetterFlagOptArgNoArgOptionoptionDocumented optionHelp optionSetteroptionShortcut optionName InvalidValueparseEnvironmentOptionsparseEnvironmentOptionextractLocation splitLinesOmitteddiffParser runParsersatisfysepBysepBy1readAValue ConstructorNumberListRecordTuple parseValueushowushowspretty2FreePureliftFJobQueue Concurrency Concurrent SequentialJobMonadIO withJobQueue enqueueJob withTimer IOErrorTypeQuickCheckFailure QCFailurequickCheckFailureNumShrinksquickCheckFailureExceptionquickCheckFailureReasonquickCheckFailureCounterexampleStatusQuickCheckSuccessQuickCheckOtherFailureQuickCheckResultquickCheckResultNumTestsquickCheckResultInfoquickCheckResultStatusliftHookaroundPropertynewSeedmkGen formatNumbersparseQuickCheckResultsafeEvaluateResultStatusexceptionToResultStatus toLocationcallSiteformatDefaultDescription toModuleName shuffleForest toSpecResult EnvironmentenvironmentGetSuccessCountenvironmentGetPendingCountenvironmentGetFailMessagesenvironmentUsedSeedenvironmentPrintTimesenvironmentGetCPUTimeenvironmentGetRealTimeenvironmentWriteenvironmentWriteTransientenvironmentWithFailColorenvironmentWithSuccessColorenvironmentWithPendingColorenvironmentWithInfoColorenvironmentUseDiffenvironmentExtraChunkenvironmentMissingChunkenvironmentLiftIO interpretWithincreaseSuccessCountincreasePendingCount withColorprintSlowSpecItems mkUsageInfo ParseResultHelpparseCommandLineOptionsparseinterpretOptionsmkDefaultConfigformatterOptionssmallCheckOptionsquickCheckOptions runnerOptionscommandLineOnlyOptionsfilterOrfromSpecForestEnvenvSpecDescriptionPathwithEnv runFormatterEvalTreeEvalItemevalItemDescriptionevalItemLocationevalItemConcurrencyevalItemAction ColorDisabled ColorEnabled EvalConfigevalConfigFormatevalConfigConcurrentJobsevalConfigFailFastevalConfigColorMode(QuickCheck-2.14.3-2ZlD5s41ttb557C1ruU8WiTest.QuickCheck.Test maxSuccessmaxDiscardRatiomaxSize maxShrinksArgs FailureReportfailureReportSeedfailureReportMaxSuccessfailureReportMaxSizefailureReportMaxDiscardRatiofailureReportPathswriteFailureReportreadFailureReport ConfigFile envVarNameignoreConfigFile parseOptionsGHC.IO.StdHandlesstderr System.Exit exitFailurestdout exitSuccessapplyFailureReportconfigQuickCheckArgsreadFailureReportOnRerunwithArgs