h&z"k      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                    Safe-Inferred  Safe-Inferred)*/01 } quickcheck-state-machineN-ary traversable functors6TODO: Don't provide Elem explicitly (just instantiate c')? TODO: Introduce HTraverse into SOP? !"#$%&'()* "#$% !&'()*-(C) 2017, ATS Advanced Telematic Systems GmbH BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred5?Tquickcheck-state-machine3Gather user annotations of a true logic expression.!gatherAnnotations (Top .// "top")["top"]7gatherAnnotations ((Bot .// "bot") .|| (Top .// "top"))["top"]5gatherAnnotations (Top .// "top1" .&& Top .// "top2")["top1","top2"]3gatherAnnotations (Bot .// "bot" .&& Top .// "top")[]gatherAnnotations (forall [1,2,3] (\i -> 0 .< i .// "positive"))"["positive","positive","positive"]gatherAnnotations (forall [0,1,2,3] (\i -> 0 .< i .// "positive"))[]gatherAnnotations (exists [1,2,3] (\i -> 0 .< i .// "positive")) ["positive"]8+,-.6/012345789:=?;<>@ABCIEJDFGHKLMNOPQRSTUVWXYZ[\]^_`ab8CIEJDFGHKLMN:=?;<>@ABOP.6/012345789+,-QRSTUVWXYZ[\]^_`ab U5V5W5X5Y5Z5[8\8]4^3_2`1 Safe-Inferred0< fghijklmno jklmhinfgo(C) 2017, Jacob Stanley BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred )*5;?-(C) 2017, ATS Advanced Telematic Systems GmbH BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred5?quickcheck-state-machineAn operation packs up an invocation event with its corresponding response event.quickcheck-state-machineGiven a sequential history, group invocation and response events into operations.quickcheck-state-machineGiven a parallel history, return all possible interleavings of invocations and corresponding response events. Safe-Inferred%&8?% % (C) 2018, HERE Europe B.V. BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred? (C) 2017, Jacob Stanley BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred?quickcheck-state-machineEnvironment errors.quickcheck-state-machine0A mapping of symbolic values to concrete values.quickcheck-state-machineCreate an empty environment.quickcheck-state-machine;Insert a symbolic / concrete pairing in to the environment.quickcheck-state-machineCast a  in to a concrete value.quickcheck-state-machineTurns an environment in to a function for looking up a concrete value from a symbolic one.quickcheck-state-machineConvert a symbolic structure to a concrete one, using the provided environment.   -(C) 2017, ATS Advanced Telematic Systems GmbH BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred 589:?pquickcheck-state-machine(Previously symbolically executed command?Invariant: the variables must be the variables in the response.* (C) 2019, Edsko de Vries BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred%&'1?quickcheck-state-machine Given an a", either successfully classify as b or continue lookingquickcheck-state-machineEnd of the string8The predicate is given a final chance to return a value.quickcheck-state-machine(Construct simply predicate that returns  on terminationquickcheck-state-machineMaximum value found, if anyquickcheck-state-machineDo a linear scan over the list, returning all successful classificationsquickcheck-state-machineStep the model using a  (i.e., a command associated with an explicit set of variables).quickcheck-state-machine is just the repeated form of .  Safe-Inferred 01< quickcheck-state-machine"The names of all possible commands=This is used for things like tagging, coverage checking, etc.quickcheck-state-machineName of this particular commandquickcheck-state-machineName of all possible commandsquickcheck-state-machineConvenience wrapper for  -(C) 2017, ATS Advanced Telematic Systems GmbH BSD-style (see the file LICENSE)5Mats Daniel Gustafsson  provisionalnon-portable (GHC extensions) Safe-Inferred8?"*quickcheck-state-machineEvent invocation or response.quickcheck-state-machineGiven a history, and output from processes generate Doc with boxes(C) 2019, Stevan Andjelkovic BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred%&'& quickcheck-state-machine Markov chain.quickcheck-state-machineConstructor for  chains.quickcheck-state-machine,Expose inner graph structure of markov chainquickcheck-state-machine provisionalnon-portable (GHC extensions) Safe-Inferred'8?-quickcheck-state-machineMore permissive notion of shrinking where a value can shrink to itself For example shrink 3 == [0, 2] -- standard QuickCheck shrink shrinkS 3 == [Shrunk True 0, Shrunk True 2, Shrunk False 3]This is primarily useful when shrinking composite structures: the combinators here keep track of whether something was shrunk  somewhere( in the structure. For example, we have  shrinkListS (shrinkPairS shrinkS shrinkS) [(1,3),(2,4)] == [ Shrunk True [] -- removed all elements of the list , Shrunk True [(2,4)] -- removed the first , Shrunk True [(1,3)] -- removed the second , Shrunk True [(0,3),(2,4)] -- shrinking the '1' , Shrunk True [(1,0),(2,4)] -- shrinking the '3' , Shrunk True [(1,2),(2,4)] -- .. , Shrunk True [(1,3),(0,4)] -- shrinking the '2' , Shrunk True [(1,3),(1,4)] -- .. , Shrunk True [(1,3),(2,0)] -- shrinking the '4' , Shrunk True [(1,3),(2,2)] -- .. , Shrunk True [(1,3),(2,3)] -- .. , Shrunk False [(1,3),(2,4)] -- the original unchanged list ]quickcheck-state-machine/Lifts a plain property into a monadic property.quickcheck-state-machineLifts  to .quickcheck-state-machineLifts  to properties.quickcheck-state-machine'Shrink list without shrinking elements.quickcheck-state-machine'Shrink list by only shrinking elements.-(C) 2017, ATS Advanced Telematic Systems GmbH BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-Inferred %&'0;k quickcheck-state-machineEnvironment required during quickcheck-state-machine(The model we're starting validation fromquickcheck-state-machineReference renumberingWhen a command Command .. [Var i, ..]is changed during validation to Command .. [Var j, ..]then any subsequent uses of Var i should be replaced by Var j. This is recorded in  . When we remove8 the first command altogether (during shrinking), then Var i won't appear in the : and shrank candidates that contain commands referring to Var i! should be considered as invalid.quickcheck-state-machine'Counter (for generating new references)quickcheck-state-machine,Generate commands from a list of generators.quickcheck-state-machine provisionalnon-portable (GHC extensions) Safe-Inferred'Li quickcheck-state-machineGenerate parallel commands.Parallel commands are generated as follows. We begin by generating sequential commands and then splitting this list in two at some index. The first half will be used as the prefix.The second half will be used to build suffixes. For example, starting from the following sequential commands: , B, C, D, E, F, G, H, I]6We split it in two, giving us the prefix and the rest: ,prefix: [A, B] rest: [C, D, E, F, G, H, I]%We advance the model with the prefix. Make a suffix: we take commands from rest* as long as these are parallel safe (see ). This means that the pre-conditions (using the 'advanced' model) of each of those commands will hold no matter in which order they are executed.Say this is true for  [C, D, E], but not anymore for F, maybe because F depends on one of  [C, D, E]. Then we divide this 'chunk' in two by splitting it in the middle, obtaining [C] and [D, E].. These two halves of the chunk (stored as a ) will later be executed in parallel. Together they form one suffix.1Then the model is advanced using the whole chunk  [C, D, E]. Think of it as a barrier after executing the two halves of the chunk in parallel. Then this process of building a chunk/suffix repeats itself, starting from  Make a suffix using the 'advanced' model.4In the end we might end up with something like this:  JJ [C] JJJ J [F, G] J [A, B] JJ JJJJ J J [D, E] J J [H, I] Jquickcheck-state-machineA list of commands is parallel safe if the pre-conditions for all commands hold in all permutations of the list.quickcheck-state-machine1Apply the transition of some commands to a model.quickcheck-state-machineShrink a parallel program in a pre-condition and scope respecting way.quickcheck-state-machineShrink a parallel program in a pre-condition and scope respecting way.quickcheck-state-machineShrinks Commands in a way that it has strictly less number of commands.quickcheck-state-machineTry to linearise a history of a parallel program execution using a sequential model. See the *Linearizability: a correctness condition for concurrent objects* paper linked to from the README for more info.quickcheck-state-machineTakes the output of parallel program runs and pretty prints a counterexample if any of the runs fail.quickcheck-state-machineTakes the output of parallel program runs and pretty prints a counterexample if any of the runs fail.quickcheck-state-machineDraw an ASCII diagram of the history of a parallel program. Useful for seeing how a race condition might have occured.quickcheck-state-machinePrint the percentage of each command used. The prefix check is an unfortunate remaining for backwards compatibility.quickcheck-state-machine-Fail if some commands have not been executed. quickcheck-state-machine Predicate.quickcheck-state-machineNumber of threadsquickcheck-state-machine Predicate.quickcheck-state-machine The model.quickcheck-state-machine The commands.quickcheck-state-machine/How many times to execute the parallel program.quickcheck-state-machine/How many times to execute the parallel program.quickcheck-state-machine/How many times to execute the parallel program.quickcheck-state-machine/How many times to execute the parallel program.quickcheck-state-machine/How many times to execute the parallel program.quickcheck-state-machine/How many times to execute the parallel program.quickcheck-state-machine Output of .quickcheck-state-machine Output of .quickcheck-state-machine Output of .quickcheck-state-machine Output of .-(C) 2017, ATS Advanced Telematic Systems GmbH BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalnon-portable (GHC extensions) Safe-InferredM+,-.9875432106/:BA@><;=?CNMLKHGFDJIEOPQRSTUVWXYZ[\]^_`ab<None%&)*125;?\quickcheck-state-machineState machine test/This captures the design patterns sketched in  1https://well-typed.com/blog/2019/01/qsm-in-depth/.quickcheck-state-machine.Relation between real and mock references for all handle typesquickcheck-state-machineRelation between real and mock references for single handle type aquickcheck-state-machineTags/Tags are used when labelling execution runs in , as well as when looking for minimal examples with a given label ().quickcheck-state-machine Responses+The type arguments are similar to those of Cmd. Two typical instances: Resp t I (RealHandles t) -- for the system under test Resp t (MockHandle t) (RealHandles t) -- for the mockquickcheck-state-machineCommandsIn  Cmd t f hs, hs' is the list of real handle types, and f is some functor applied to each of them. Two typical instantiations are Cmd t I (RealHandles t) -- for the system under test Cmd t (MockHandle t) (RealHandles t) -- for the mockquickcheck-state-machine Mock handlesFor each real handle a, MockHandle t a" is the corresponding mock handle.quickcheck-state-machineType-level list of the types of the handles in the system under testNOTE: If your system under test only requires a single real handle, you might consider using !Test.StateMachine.Lockstep.Simple instead.quickcheck-state-machine Mock stateThe t argument (here and elsewhere) is a type-level tag that combines all aspects of the test; it does not need any term-level constructors /data MyTest type instance MockState MyTest = ..quickcheck-state-machineTurn Cmd or Resp in terms of (symbolic or concrete) references to real handles into a command in terms of mock handles.This is isomorphic to toMock :: Refss t Symbolic> Cmd (FlipRef r) (Handles t)> Cmd ToMock (Handles t)quickcheck-state-machineSequential testquickcheck-state-machine Parallel test+NOTE: This currently does not do labelling.quickcheck-state-machineTranslate QSM's  into our The QSM  is purely in terms of symbolic references. In order to construct our  from this, we need to reconstruct the mock response. We can do this, because we maintain a mapping between references and mock handles in the model, irrespective of whether those references are symbolic (as here) or concrete (during test execution). We can therefore apply this mapping, and re-compute the mock response. We could use  instead of , but this would recompute the new state, which is not necessary.NOTE: This forgets the symbolic response in favour of the mock response. This seems more in line with what we do elsewhere in the lockstep infrastructure, but we could conceivably return both.quickcheck-state-machine5Show minimal examples for each of the generated tags.This is the analogue of  . See also .quickcheck-state-machineSimplified form of quickcheck-state-machine%(Optional) minimum number of commandsquickcheck-state-machine%(Optional) minimum number of commandsquickcheck-state-machineSeedquickcheck-state-machine'Number of tests to run to find examplesquickcheck-state-machineTag filter (can be  const True).. Safe-Inferred%&)*15?cquickcheck-state-machineState machine test/This captures the design patterns sketched in  1https://well-typed.com/blog/2019/01/qsm-in-depth/; for the case where there is exactly one real handle. See Test.StateMachine.Lockstep.NAry for the generalization to n handles.quickcheck-state-machine ResponsesIn Resp t h, h is the type of the handle Resp t (RealHandle t) -- for the system under test Resp t (MockHandle t) -- for the mockquickcheck-state-machineCommandsIn Cmd t h, h is the type of the handle Cmd t (RealHandle t) -- for the system under test Cmd t (MockHandle t) -- for the mockquickcheck-state-machineThe type of the mock handle#NOTE: In the n-ary infrastructure,  is a type family of two arguments, because we have a mock handle for each real handle. Here, however, we only have a single real handle, so the " corresponding " real handle is implicitly  RealHandle t.quickcheck-state-machine4The type of the real handle in the system under testThe key difference between the " simple " lockstep infrastructure and the n-ary lockstep infrastructure is that the former only supports a single real handle, whereas the latter supports an arbitrary list of them.quickcheck-state-machine%(Optional) minimum number of commandsquickcheck-state-machine%(Optional) minimum number of commands""-(C) 2017, ATS Advanced Telematic Systems GmbH BSD-style (see the file LICENSE)4Stevan Andjelkovic  provisionalportable Safe-Inferredjquickcheck-state-machine(Partial) functions.quickcheck-state-machine Relations.quickcheck-state-machineSubset.'boolean ([1, 2] `isSubsetOf` [3, 2, 1])Truequickcheck-state-machine Set equality.boolean ([1, 1, 2] ~= [2, 1])Truequickcheck-state-machineDomain restriction.(['a'] <| [ ('a', "apa"), ('b', "bepa") ] [('a',"apa")]quickcheck-state-machineCodomain restriction.*[ ('a', "apa"), ('b', "bepa") ] |> ["apa"] [('a',"apa")]quickcheck-state-machineDomain substraction.)['a'] <-| [ ('a', "apa"), ('b', "bepa") ][('b',"bepa")]quickcheck-state-machineCodomain substraction.:[ ('a', "apa"), ('b', "bepa"), ('c', "cepa") ] |-> ["apa"][('b',"bepa"),('c',"cepa")][ ('a', "apa"), ('b', "bepa"), ('c', "cepa") ] |-> ["apa", "cepa"][('b',"bepa")][ ('a', "apa"), ('b', "bepa"), ('c', "cepa") ] |-> ["apa"] |-> ["cepa"][('b',"bepa")]quickcheck-state-machineThe image of a relation.quickcheck-state-machine Overriding.![('a', "apa")] <+ [('a', "bepa")][('a',"bepa")]![('a', "apa")] <+ [('b', "bepa")][('a',"apa"),('b',"bepa")]quickcheck-state-machineDirect product.quickcheck-state-machineParallel product.quickcheck-state-machine Application.quickcheck-state-machine Assignment.$singleton 'a' "apa" .! 'a' .= "bepa"[('a',"bepa")]$singleton 'a' "apa" .! 'b' .= "bepa"[('a',"apa"),('b',"bepa")]++1116755444444449 4 !"#$%&'()*+,-./012345678978:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdUefghijklmnopqrstuvwxyz{|}~                                                                                                                    5quickcheck-state-machine-0.7.3-2LUIv8Um45c39ThIAXg7SQTest.StateMachine.DotDrawingTest.StateMachine$Test.StateMachine.Lockstep.AuxiliaryTest.StateMachine.LogicTest.StateMachine.Types.Rank2"Test.StateMachine.Types.ReferencesTest.StateMachine.Types.HistoryTest.StateMachine.Types.GenSym#Test.StateMachine.Types.EnvironmentTest.StateMachine.TypesTest.StateMachine.Labelling!Test.StateMachine.ConstructorNameTest.StateMachine.BoxDrawerTest.StateMachine.MarkovTest.StateMachine.UtilsTest.StateMachine.SequentialTest.StateMachine.ParallelTest.StateMachine.Lockstep.NAry!Test.StateMachine.Lockstep.SimpleTest.StateMachine.ZPaths_quickcheck_state_machineshowLabelledExamples'+graphviz-2999.20.1.0-KJQGMGkMerTDCXRXQUb8l1Data.GraphViz.CommandsWebPWBmpVrmlVmlZVmlTiffSvgZSvgPs2PsPngPlainExtPlainPdfJpegCmapxNPImapNPCmapxImapIcoGifGd2GdFigEpsXDot DotOutputCanonBmpGraphvizOutput(tree-diff-0.3.0.1-EkLuptx3eDMEJYhupUqh5DData.TreeDiff.ClasstoExprToExpr NTraversable nctraverseElemElemHeadElemTailnpAt ntraversencfmapnfmap ncfoldMapnfoldMapValueVFalseVTrueCounterexampleBotCFstSndEitherCImpliesCNotC PredicateCForallCExistsCBooleanC AnnotateCLogicPredicate:==:/=:<:<=:>:>=Member NotMemberLogicBotTop:&&:||:=>NotForallExistsBooleanAnnotatedual strongNegbooleanlogicevalLogicPredicategatherAnnotations.==./=.<.<=.>.>=member notMember.//.&&.||.=>forallexists $fShowValue$fShowCounterexample$fShowLogicPredicate TraversabletraverseFoldablefoldMapFunctorfmapgfmap<$>gfoldMap gtraverse$fFunctorkRec1 $fFunctorkM1 $fFunctork:.: $fFunctork:*: $fFunctork:+: $fFunctorkK1 $fFunctorkU1$fFoldablekRec1 $fFoldablekM1$fFoldablek:.:$fFoldablek:*:$fFoldablek:+: $fFoldablekK1 $fFoldablekU1$fTraversablekRec1$fTraversablekM1$fTraversablek:.:$fTraversablek:*:$fTraversablek:+:$fTraversablekK1$fTraversablekU1OpaqueunOpaque ReferenceConcreteSymbolicVar referenceconcreteopaque$fOrd1Symbolic $fEq1Symbolic$fToExprSymbolic$fShow1Symbolic$fToExprConcrete$fOrd1Concrete $fEq1Concrete$fShow1Concrete$fShowReference$fOrdReference $fEqReference$fTraversableTYPEReference$fFoldableTYPEReference$fFunctorTYPEReference$fToExprReference$fToExprOpaque $fShowOpaque $fEqOpaque $fOrdOpaque$fGenericReference$fEqVar$fOrdVar $fShowVar $fGenericVar $fReadVar $fToExprVar$fReadReference $fOrdConcrete $fEqConcrete$fShowConcrete $fOrdSymbolic $fEqSymbolic$fReadSymbolic$fShowSymbolic OperationCrash HistoryEvent InvocationResponse ExceptionPidunPidHistory'History unHistorymakeOperations interleavingsoperationsPathcompleteHistory$fEqPid $fShowPid$fOrdPid$fShowOperation$fShowHistoryEvent$fEqHistoryEvent $fShowHistory $fEqHistoryRose GraphOptionsfilePathgraphvizOutput printDotGraph $fFunctorRose $fShowRoseCounterGenSym runGenSymgenSym newCounter$fFunctorGenSym$fApplicativeGenSym $fMonadGenSym $fShowCounterEnvironmentErrorEnvironmentValueNotFoundEnvironmentTypeError Environment unEnvironmentemptyEnvironmentinsertConcreteinsertConcretes reifyDynamicreifyEnvironmentreify$fEqEnvironmentError$fOrdEnvironmentError$fShowEnvironmentError$fShowEnvironment$fSemigroupEnvironment$fMonoidEnvironmentNParallelCommandsParallelCommandsPairproj1proj2ParallelCommandsFprefixsuffixesReasonOkPreconditionFailedPostconditionFailedInvariantBrokenExceptionThrownMockSemanticsMismatchCommands unCommandsCommand StateMachine initModel transition precondition postcondition invariant generatorshrinker semanticsmockcleanup noCleanup getCommandlengthCommandsisOKfromPairtoPair fromPair' toPairUnsafe'$fEqPair $fOrdPair $fShowPair $fFunctorPair$fFoldablePair$fTraversablePair $fEqReason $fShowReason$fSemigroupCommands$fMonoidCommands$fShowParallelCommandsF$fEqParallelCommandsF $fEqCommands$fReadCommands$fShowCommands $fEqCommand $fReadCommand $fShowCommandEvent eventBeforeeventCmd eventAfter eventResp Predicate predApply predFinish predicatemaximumclassifyexecCmds execHistory$fFunctorPredicate $fShowEvent CommandNamescmdNamecmdNames commandName$fCommandNameskRec1$fCommandNamesk:*:$fCommandNamesk:+:$fCommandNameskM1$fCommandNameskM10$fCommandNameskM11$fCommandNameskK1$fCommandNameskU1Fork EventTypeOpenCloseexec $fFunctorFork$fShowEventType PropertyNameStatsDbstoreloadMarkov makeMarkovtoAdjacencyMap-<>-/-markovGenerator coverMarkovtabulateMarkovtransitionMatrixstimulusMatrixhistoryObservations markovToDot markovToPs nullStatsDb fileStatsDb persistStatscomputeReliabilityprintReliabilityquickCheckReliabilitytestChainToDotShrunk wasShrunkshrunk liftProperty whenFailManyPsuchThatEithercollectsshrinkS shrinkListS shrinkListS' shrinkListS'' shrinkPairS shrinkPairS'pickOneReturnRest2pickOneReturnRestpickOneReturnRestLmkModel $fEqShrunk $fShowShrunk$fFunctorShrunkCheckCheckPreconditionCheckEverything CheckNothing ShouldShrink MustShrink DontShrink ValidateEnvveModelveScope veCounterforAllCommandsexistsCommands deadlockErrorgenerateCommandsgenerateCommandsState getUsedVarsshrinkCommandsinitValidateEnvshrinkAndValidate runCommandsrunCommandsWithSetup runCommands'getChanContentsexecuteCommandsprettyPrintHistoryprettyCommandsprettyPrintHistory'prettyCommands' saveCommandsrunSavedCommandscheckCommandNamescoverCommandNames commandNamescommandNamesInOrdershowLabelledExamplesforAllParallelCommandsforAllNParallelCommandsgenerateParallelCommandsgenerateNParallelCommands advanceModelshrinkParallelCommandsshrinkNParallelCommandsshrinkCommands'shrinkAndValidateParallelshrinkAndValidateNParallelrunParallelCommandsrunParallelCommandsWithSetuprunParallelCommands'runNParallelCommandsrunNParallelCommandsWithSetuprunParallelCommandsNTimes"runParallelCommandsNTimesWithSetuprunParallelCommandsNTimes'runNParallelCommandsNTimes#runNParallelCommandsNTimesWithSetuprunNParallelCommandsNTimes'executeParallelCommands lineariseprettyParallelCommandsWithOptsprettyParallelCommandsprettyNParallelCommandsWithOptsprettyNParallelCommands toBoxDrawingscheckCommandNamesParallelcoverCommandNamesParallelcommandNamesParallelbeforecmdaftermockRespStateMachineTestrunMockrunRealinitMock newHandlestagModel modelState modelRefss:@AtunAtFlipRef unFlipRefTestRefssunRefssRefsunRefsTagRespCmd MockHandle RealHandles MockStatehoistStateMachineTesttoStateMachineprop_sequential prop_parallel $fMonoidRefss$fSemigroupRefss $fToExprRefss $fShowRefss$fTraversableTYPEAt$fFoldableTYPEAt$fFunctorTYPEAt$fTraversableTYPEAt0$fFoldableTYPEAt0$fFunctorTYPEAt0 $fToExprModel$fGenericModel $fShowFlipRef$fSemigroupRefs $fMonoidRefs $fGenericRefs $fShowModel$fShowAt $fToExprRefs $fShowRefs modelRefs RealHandle fromSimple$fToExprMockHandle$fNTraversableTYPECmd$fNTraversableTYPEResp $fShowCmd $fShowResp $fShowResp0$fEqResp$fShowMockHandle$fEqMockHandle:<->:/->:->FunRelconsunion intersect isSubsetOf~=emptyidentity singletondomaincodomaincomposefcomposeinverse lookupDom lookupCod<||><-||->image<+<**><||> isTotalRel isSurjRelisTotalSurjRel isPartialFun isTotalFun isPartialInj isTotalInj isPartialSurj isTotalSurj isBijection!!?.%.!.=versiongetDataFileName getBinDir getLibDir getDynLibDir getDataDir getLibexecDir getSysconfDirbase Data.DynamicDynamic GHC.MaybeNothingexecCmd(QuickCheck-2.14.3-2ZlD5s41ttb557C1ruU8WiTest.QuickCheck.Property coverTabletabulatewhenFailTest.QuickCheck.Monadic PropertyM Data.Foldableany parallelSafe toMockHandlesfromLabelEventlockstepstep