Q)      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(c) Simon Marlow 2012BSD3 (see the file LICENSE)!Simon Marlow <marlowsd@gmail.com> provisional#non-portable (requires concurrency) TrustworthyCDQV8A 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 IOL 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")The exception thrown by  to terminate a thread."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. ). Returns the " of the thread running the given . Compare two s that may have different types2Spawn an asynchronous action in a separate thread.Like  but using  internally.Like  but using  internally.Like  but using i internally. The child thread is passed a function that can be used to unmask asynchronous exceptions.Like  but using i internally. The child thread is passed a function that can be used to unmask asynchronous exceptions.ASpawn an asynchronous action in a separate thread, and pass its AsyncV 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 `finally` uninterruptibleCancel aThis is a useful variant of  that ensures an Async( is never left running unintentionally.GNote: a reference to the child thread is kept alive until the call to  returns, so nesting many  calls requires linear memory.Like  but uses  internally.Like  but uses  internally.Like  but uses i internally. The child thread is passed a function that can be used to unmask asynchronous exceptions.Like  but uses h internally. The child thread is passed a function that can be used to unmask asynchronous exceptionsWait 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@Wait 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 . waitCatchSTMCheck whether an F 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 A version of , that can be used inside an STM transaction. A version of , that can be used inside an STM transaction. A version of , that can be used inside an STM transaction..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. Bcancel a = throwTo (asyncThreadId a) AsyncCancelled <* waitCatch a Note that ) will not terminate until the thread the , refers to has terminated. This means that U will block for as long said thread blocks when receiving an asynchronous exception.For example, it could block if:SIt's executing a foreign call, and thus cannot receive the asynchronous exception;fIt's executing some cleanup handler after having received the exception, and the handler is blocking.Cancel an asynchronous actionThis is a variant of , but it is not interruptible.HCancel 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 .gWait 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 Zs complete or have completed, then the value returned corresponds to the first completed  in the list. A version of , that can be used inside an STM transaction.Like S, but also cancels the other asynchronous operations as soon as one has completed.Wait for any of the supplied Asyncds to complete. If the first to complete throws an exception, then that exception is re-thrown by . If multiple Zs complete or have completed, then the value returned corresponds to the first completed  in the list. A version of , that can be used inside an STM transaction.Like S, but also cancels the other asynchronous operations as soon as one has completed.Wait for the first of two Async s to finish. A version of , that can be used inside an STM transaction.Like  , but also s both Asyncs before returning.Wait for the first of two Asyncs to finish. If the AsyncO that finished first raised an exception, then the exception is re-thrown by . A version of , that can be used inside an STM transaction.Like , but the result is ignored. A version of , that can be used inside an STM transaction.Like  , but also s both Asyncs before returning.Waits for both Async|s to finish, but if either of them throws an exception before they have both finished, then the exception is re-thrown by . A version of , that can be used inside an STM transaction.Link the given Async* to the current thread, such that if the AsyncZ 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 C a thread you're linked to. If you want different behaviour, use .Link 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. The supplied predicate determines which exceptions in the target thread should be propagated to the source thread. Link two Asynccs 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 T either thread without cancelling the other. If you want different behaviour, use .Run two IOR actions concurrently, and return the first to finish. The loser of the race is led. Urace left right = withAsync left $ \a -> withAsync right $ \b -> waitEither a bLike , but the result is ignored.Run 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 bmaps an IO-performing function over any  Traversable data type, performing all the IOn actions concurrently, and returning the original data structure with the arguments replaced by the results.oIf 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"] is  with its arguments flipped Fpages <- forConcurrently ["url1", "url2", "url3"] $ \url -> getURL url is 3 with the return value discarded, just like @mapM_ is 3 with the return value discarded, just like @forM_, but ignore the result values2Perform the action in the given number of threads.Same as , but ignore the results.Fork 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.Only defined by async for  base >= 4.9return ) if the exception should be propagated,  otherwise.91(c) Sterling Clover 2008-2011, Kevin Charter 2011 BSD 3 Clauses.clover@gmail.com experimentalportableSafe3A 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).ITakes two lists and returns a list of differences between them. This is  with  used as predicate.^Takes two lists and returns a list of differences between them, grouped into chunks. This is  with  used as predicate. A form of  with no L constraint. Instead, an equality predicate is taken as the first argument. SafeJ SafeS      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRS Safe<T Safe3UVWXUVW SafeYunstableSafe<A < represents the location of an example within the spec tree.JIt consists of a list of group descriptions and a requirement description.pluralize 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"%Strip leading and trailing whitespace,ensure that lines are not longer than given n(, insert line breaks at word boundariesQTry to create a proper English sentence from a path by applying some heuristics.3A predicate that can be used to filter a spec tree. The function # converts an exception to a string.This is different from p/. The type of the exception is included, e.g.:*formatException (toException DivideByZero)!"ArithException (divide by zero)"For Zs the [ is included, as well.safeTryu evaluates given action and returns its result. If an exception occurs, the exception is returned instead. Unlike \, it is agnostic to asynchronous exceptions.Safe]^_`abSafe1;=FT:A marker for source locations The source location is accurate XThe source location was determined on a best-effort basis and my be wrong or inaccurate Location' is used to represent source locations. The result of running an exampleAn ) action that expects an argument of type a A type class for examples  !"#$   !"unstableSafe+345<a %ItemF 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  r type class can be used as an example, including QuickCheck properties, Hspec expectations and HUnit assertions.'Textual description of behavior( Source location of the spec item)fA flag that indicates whether it is safe to evaluate this spec item in parallel with other spec items*Example for behavior+A tree is used to represent a spec internally. The tree is parametrize over the type of cleanup actions and the type of the actual spec items.,Internal tree data structure0The  specGroup6 function combines a list of specs into a larger spec.1The specItem function creates a spec item. %&'()*+,-./01%&'()*,-./NoneK72A writer monad for + forests6 Convert a 5 to a forest of +s.7 Create a 5 from a forest of +s.82Run an IO action while constructing the spec tree.2J 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. 23456789:;<23 provisionalNone =+Run a custom action before every spec item.>+Run a custom action before every spec item.?+Run a custom action before every spec item.@/Run a custom action before the first spec item.A/Run a custom action before the first spec item.B*Run a custom action after every spec item.C*Run a custom action after every spec item.D8Run a custom action before and/or after every spec item.E-Run a custom action after the last spec item.F-Run a custom action after the last spec item.G8Run a custom action before and/or after every spec item.H8Run a custom action before and/or after every spec item. =>?@ABCDEFGH =>?@ABCEFDGHcdefunstableNone+< IThe describe6 function combines a list of specs into a larger spec.Jcontext is an alias for I.K Changing I to K> marks all spec items of the corresponding subtree as pending.3This can be used to temporarily disable spec items.Lxcontext is an alias for K.MThe it function creates a spec item.A spec item consists of:+a textual description of a desired behavioran example for that behavior odescribe "absolute" $ do it "returns a positive number when given a negative number" $ absolute (-1) == 1Nspecify is an alias for M.O Changing M to O. marks the corresponding spec item as pending.4This can be used to temporarily disable a spec item.Pxspecify is an alias for O.QQL marks all spec items of the given spec to be safe for parallel evaluation.RR, can be used to mark a spec item as pending.VIf 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" $ pendingSS is similar to Rv, but it takes an additional string argument that can be used to specify the reason for why the spec item is pending.@  !"#$%&'()*+,-./0123456789:;<IJKLMNOPQRS@MNIJRSOPKLQ54236789:;< !"#  $+,-./%&'()*01 provisionalNoneTUse a modified g for given spec.UUse a modified h for given spec.VUse a modified i for given spec.TUVTUVNone "#0;=CQV ` evaluated before each test group@The given number indicates the position within the parent group.b>used to notify the progress of the currently evaluated exampleNote2: This is only called when interactive/color mode.c'evaluated after each successful exampled#evaluated after each failed examplee$evaluated after each pending examplefevaluated after a test rungevaluated after failuresFormatterh9Get the number of successful examples encountered so far.i6Get the number of pending examples encountered so far.j5Get the number of failed examples encountered so far.k4Get the total number of examples encountered so far.l-Get the list of accumulated failure messages.m,The random seed that is used for QuickCheck.n:Get the used CPU time since the test run has been started.o=Get the passed real time since the test run has been started.p!Append some output to the report.q The same as p, but adds a newline character.rRSet output color to red, run given action, and finally restore the default color.sTSet output color to green, run given action, and finally restore the default color.tUSet output color to yellow, run given action, and finally restore the default color.uSSet output color to cyan, run given action, and finally restore the default color.vOutput given chunk in red.wOutput given chunk in green.7jklmnopqrstuvwxyzWXYZ[\]^_`abcdefg{hijklmnopqrstuvwjklmnopqrstuvwxyz|}~XYZ[\] ^_`abcdefg experimentalNone*WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{*xyz{]^_`abcdefgWhijkXYZ[\lmnopqustrvwNonemqA predicate that is used to filter the spec before it is run. Only examples that satisfy the predicate are run. |}~|}~None NoneKoA lifted version of A lifted version of ,The random seed that is used for QuickCheck.,Increase the counter for successful examples)Increase the counter for pending examples(Increase the counter for failed examples9Get the number of successful examples encountered so far.6Get the number of pending examples encountered so far.5Get the number of failed examples encountered so far.3Append to the list of accumulated failure messages.-Get the list of accumulated failure messages.!Append some output to the report.RSet output color to red, run given action, and finally restore the default color.TSet output color to green, run given action, and finally restore the default color.USet output color to yellow, run given action, and finally restore the default color.SSet output color to cyan, run given action, and finally restore the default color.5Set a color, run an action, and finally reset colors.Output given chunk in red.Output given chunk in green.finally_ actionA actionB runs actionA and then actionB. actionB is run even when a  occurs during actionA.:Get the used CPU time since the test run has been started.=Get the passed real time since the test run has been started. NonecAdd a filter predicate to config. If there is already a filter predicate, then combine them with O.|}~None`;Evaluate all examples of a given spec and produce a report.?Execute given action at most every specified number of seconds. provisionalNone(Summary of a test run. Filter specs by given predicate.DThe predicate takes a list of "describe" labels and a "requirement".%Run given spec and write a report to  . Exit with ! if at least one spec item fails.8Run given spec with custom options. This is similar to , but more flexible.5Run given spec and returns a summary of the test run.Note:  does not exit with B on failing spec items. If you need this, you have to check the  yourself and act accordingly.IRun given spec with custom options and returns a summary of the test run.Note:  does not exit with B on failing spec items. If you need this, you have to check the  yourself and act accordingly.%|}~%|}~ !"#$%&''()*+,-./01234567789:;<=>??@ABCDEFGHIJKKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoopqrsstuvwxyz{|}~               !"#"$%&'()(*+,+-+.+/+0+1+2+3+4+5+6+789:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L(M(N(O(P(Q(R(S(T(U(V(W(XYZ[\]^_`abacadaeafagahaijklmnopqrsrtru(v(w9x9y9z9{9|9}9~99999999(((((((                  !""#$$%&'&(&)&*+,+-+./r0r12345(6(7(8(9(:(;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\"]"^a_`abcdefghijklmnopqprpstuv w x y z { { | } ~;;}~nn'hspec-core-2.4.8-3lSCaC6j1BnH8X9pc8wOSyTest.Hspec.Core.UtilTest.Hspec.Core.SpecTest.Hspec.Core.HooksTest.Hspec.Core.QuickCheckTest.Hspec.Core.FormattersTest.Hspec.Core.RunnerControl.Concurrent.AsyncData.Algorithm.DiffPaths_hspec_coreTest.Hspec.Core.CompatTest.Hspec.Core.Formatters.DiffTest.Hspec.Core.Formatters.FreeTest.Hspec.Core.TimerTest.Hspec.Core.QuickCheckUtilTest.Hspec.Core.ExampleTest.Hspec.Core.TreeTest.Hspec.Core.Spec.Monad beforeAll Test.Hspec.Core.Formatters.MonadTest.Hspec.Core.OptionsTest.Hspec.Core.FailureReport#Test.Hspec.Core.Formatters.InternalControl.Monad.Trans.StategetsmodifyTest.Hspec.Core.ConfigTest.Hspec.Core.Runner.EvalPath pluralizestrip lineBreaksAtformatRequirementfilterPredicateformatExceptionsafeTryLocationAccuracy ExactLocation BestEffortLocation locationFile locationLinelocationColumnlocationAccuracy FailureReasonNoReasonReasonExpectedButGotResultSuccessPendingFailure ActionWithProgressCallbackProgressParamsparamsQuickCheckArgsparamsSmallCheckDepthExampleArgevaluateExample defaultParamssafeEvaluateExampleItemitemRequirement itemLocationitemIsParallelizable itemExampleSpecTreeTreeNodeNodeWithCleanupLeaf specGroupspecItemSpecMSpecWithSpecrunSpecM fromSpecListrunIO mapSpecTree mapSpecItem mapSpecItem_ modifyParamsbeforebefore_ beforeWith beforeAll_afterafter_aroundafterAll afterAll_around_ aroundWithdescribecontext xdescribexcontextitspecifyxitxspecifyparallelpending pendingWithmodifyMaxSuccessmodifyMaxDiscardRatio modifyMaxSizeFormatM FailureRecordfailureRecordLocationfailureRecordPathfailureRecordMessage FormatterheaderFormatterexampleGroupStartedexampleGroupDoneexampleProgressexampleSucceeded exampleFailedexamplePendingfailedFormatterfooterFormattergetSuccessCountgetPendingCount getFailCount getTotalCountgetFailMessagesusedSeed getCPUTime getRealTimewrite writeLine withFailColorwithSuccessColorwithPendingColor withInfoColor extraChunk missingChunksilentspecdocprogressfailed_examples ColorMode ColorAuto ColorNever ColorAlwaysConfigconfigIgnoreConfigFile configDryRunconfigPrintCpuTimeconfigFastFailconfigFailureReport configRerunconfigRerunAllOnSuccessconfigFilterPredicateconfigSkipPredicateconfigQuickCheckSeedconfigQuickCheckMaxSuccessconfigQuickCheckMaxDiscardRatioconfigQuickCheckMaxSizeconfigSmallCheckDepthconfigColorMode configDiffconfigFormatterconfigHtmlOutputconfigOutputFileconfigConcurrentJobs defaultConfigconfigAddFilterSummarysummaryExamplessummaryFailureshspec hspecWith hspecResulthspecWithResult$fMonoidSummary $fEqSummary $fShowSummary ConcurrentlyAsyncCancelledcancelAsyncasync withAsyncwait asyncThreadIdbase GHC.Conc.SyncThreadId compareAsyncs asyncBoundControl.ConcurrentforkOSasyncOnforkOnasyncWithUnmaskforkIOWithUnmaskasyncOnWithUnmaskforkOnWithUnmaskuninterruptibleCancelwithAsyncBound withAsyncOnwithAsyncWithUnmaskwithAsyncOnWithUnmask waitCatchpollwaitSTM waitCatchSTMpollSTM cancelWith waitAnyCatchwaitAnyCatchSTMwaitAnyCatchCancelwaitAny waitAnySTM waitAnyCancelwaitEitherCatchwaitEitherCatchSTMwaitEitherCatchCancel waitEither waitEitherSTM waitEither_waitEitherSTM_waitEitherCancelwaitBoth waitBothSTMlinkExceptionInLinkedThreadlinkOnlylink2 link2Onlyracerace_ concurrentlymapConcurrentlyforConcurrentlymapConcurrently_forConcurrently_ concurrently_replicateConcurrentlyreplicateConcurrently_ forkRepeat$fMonoidConcurrently$fSemigroupConcurrentlyghc-prim GHC.TypesTrueFalserunConcurrently _asyncWaitDiffFirstSecondBothgetDiff getDiffBy GHC.Classes==getGroupedDiffgetGroupedDiffByEqDLpoipojpathDIFSBversion getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirgetDataFileNameGHC.Base++GHC.PrimseqGHC.Listfilterzip System.IOprint Data.Tuplefstsnd otherwisemap$GHC.Real fromIntegral realToFracGHC.EnumBoundedminBoundmaxBoundEnumenumFrom enumFromThenenumFromThenTo enumFromTofromEnumtoEnumsuccpred/= GHC.FloatFloatingpiexplogsqrt**logBasesincostanasinacosatansinhcoshtanhasinhacoshatanh Fractional fromRational/recipIntegral toIntegerquotremdivmodquotRemdivModMonad>>=>>returnfailFunctorfmap<$GHC.NumNum*+-negate fromIntegerabssignumOrd>=minmax><<=compareGHC.ReadRead readsPrecreadListReal toRational RealFloat floatRadix floatDigits floatRange decodeFloat encodeFloatexponent significand scaleFloatisNaN isInfiniteisDenormalizedisNegativeZeroisIEEEatan2RealFracproperFractiontruncateroundceilingfloorGHC.ShowShowshow showsPrecshowList ApplicativeliftA2pure<*>*><* Data.FoldableFoldabletoListfoldrfoldlfoldl'foldl1sumproductfoldr1maximumminimumelemfoldfoldr'foldMapnulllengthData.Traversable TraversablemapMsequencetraverse sequenceAMonoidmemptymappendmconcatBoolCharDoubleFloatInt integer-gmpGHC.Integer.TypeIntegerMaybeNothingJustOrderingLTEQGTRationalIOWord Data.EitherEitherLeftRightStringShowSSystem.Environment lookupEnvfoldMapDefault fmapDefault mapAccumR mapAccumLforMforControl.Applicativeoptional WrappedMonad WrapMonad unwrapMonad WrappedArrow WrapArrow unwrapArrowZipList getZipListreadIOreadLn appendFile writeFilereadFileinteract getContentsgetLinegetCharputStrLnputStrputCharGHC.IO.ExceptionioError Data.IORefatomicWriteIORefatomicModifyIORef'atomicModifyIORef modifyIORef' modifyIORef mkWeakIORef GHC.IORef writeIORef readIORefnewIORefIORefGHC.IOFilePath userErrorIOErrorData.Functor.ConstConstgetConstfindnotElem minimumBy maximumByallanyorand concatMapconcatmsumasum sequence_ sequenceA_forM_mapM_for_ traverse_foldlMfoldrM Data.Monoid<>DualgetDualEndoappEndoAllgetAllAnygetAnySumgetSumProduct getProductgetFirstLastgetLastAltgetAlt Data.OldListunwordswordsunlineslines Text.Readread readMaybereadseitherlex readParenText.ParserCombinators.ReadPReadS Data.Functor<$>lcmgcd^^^oddeven showParen showStringshowCharshowsunzip3unzipzipWith3zipWithzip3!!lookupreversebreakspansplitAtdroptake dropWhile takeWhilecycle replicaterepeatiteratescanr1scanrscanl1scanlinitlasttailhead Data.MaybemaybeuncurrycurrysubtractasTypeOfuntil$!flip.constid=<<liftA3liftA<**> Alternativeempty<|>somemanyGHC.Err undefinederrorWithoutStackTraceerror&&||notshowType showFullTypegetDefaultConcurrentJobsdiffFreePureliftFnewTimer IOException IOErrorTypeControl.Exception.BasetryaroundProperty aroundProp aroundRose formatNumbersnewSeedmkGenMemoizedEmptyFailed(QuickCheck-2.10.1-BUFYQzp5Pjm7JbQeTzW89lTest.QuickCheck.Test maxSuccessmaxDiscardRatiomaxSize EnvironmentenvironmentGetSuccessCountenvironmentGetPendingCountenvironmentGetFailCountenvironmentGetFailMessagesenvironmentUsedSeedenvironmentGetCPUTimeenvironmentGetRealTimeenvironmentWriteenvironmentWithFailColorenvironmentWithSuccessColorenvironmentWithPendingColorenvironmentWithInfoColorenvironmentExtraChunkenvironmentMissingChunkenvironmentLiftIO interpretWithFormatFGetSuccessCountGetPendingCount GetFailCountGetFailMessagesUsedSeed GetCPUTime GetRealTimeWrite WithFailColorWithSuccessColorWithPendingColor WithInfoColor ExtraChunk MissingChunkLiftIO ConfigFile envVarNamefilterOr parseOptionsignoreConfigFile _argumentName_argumentParser_argumentSetterInvalidArgument FailureReportfailureReportSeedfailureReportMaxSuccessfailureReportMaxSizefailureReportMaxDiscardRatiofailureReportPathswriteFailureReportreadFailureReportincreaseSuccessCountincreasePendingCountincreaseFailCountaddFailMessage withColorfinally_ UserInterrupt interpret runFormatMFormatterState stateHandle stateUseColor stateUseDiff produceHTML successCount pendingCount failCount failMessages stateUsedSeed cpuStartTime startTimeconfigQuickCheckArgs getConfig runFormattereveryMessageDoneRunReportReportProgress ReportResult filterSpecsGHC.IO.Handle.FDstdout System.Exit exitFailure