h&kSY=      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred)*<  Safe-Inferred%&F Safe-Inferred)*/0156 quickspecMeasure the arity. quickspecFunctions for re-wrapping an  value. quickspecWrap up a value which has the same existential type as this one. quickspec?Unwrap a value which has the same existential type as this one. quickspecThe unwrapped value. Consists of the value itself (with an existential type) and functions to wrap it up again. quickspec-Dynamic values inside an applicative functor.For example, a value of type  Value Maybe represents a Maybe something. quickspecRepresents a forall-quantifier over all the type variables in a type. Wrapping a term in Poly normalises the type by alpha-renaming type variables canonically.The  instance for = does unification to handle applying a polymorphic function. quickspec/Typed things that support function application.  quickspec!Apply a function to its argument.For most instances of $, the type of the argument must be exactly equal to the function's argument type. If you want unification to happen, use the $ instance of .! quickspecA wrapper for using the  machinery on types.$ quickspec$A class for things that have a type.% quickspec The type.& quickspec#Types that appear elsewhere in the $, for example, types of subterms. Should return everything which is affected by Q.' quickspec"Substitute for all type variables.( quickspec"A polymorphic type of kind Symbol.4 quickspecA type constructor.5 quickspecThe function type constructor (->).6 quickspec%An ordinary Haskell type constructor.7 quickspecA string. Can be used to represent miscellaneous types that do not really exist in Haskell.8 quickspecA (possibly polymorphic) type. quickspec3All type variables that are defined in this module.9 quickspecA type variable.: quickspec#Check if a type is a type variable.; quickspecConstruct a type from a .< quickspecConstruct a type from a .= quickspecTurn a 4 into a type.> quickspec+Function application for type constructors. For example, applyType (typeRep (Proxy :: Proxy [])) (typeRep (Proxy :: Proxy Int)) == typeRep (Proxy :: Proxy [Int]).? quickspecConstruct a function type.@ quickspec Is a given type a function type?A quickspec2Decompose a function type into (argument, result).6For multiple-argument functions, unpacks one argument.B quickspec!The arguments of a function type.C quickspecThe result of a function type.D quickspecGiven the type of a function, returns the type of applying that function to n? arguments. Crashes if the type does not have enough arguments.E quickspec(How many arguments does a function take?F quickspec#Unify all type variables in a type.G quickspec2Replace all type variables with a particular type.H quickspecMake a type ground by replacing all type variables with Skolem constants.I quickspecConstruct a type from a .J quickspec Construct a 4 type from a  Data.Typeable . quickspecSome built-in type consructors. quickspecSome built-in type consructors. quickspecSome built-in type consructors. quickspecSome built-in type consructors.K quickspecGet the outermost 4 of a .L quickspecCheck if a type is of the form  c, and if so, return c.M quickspecCheck if a type is of the form  c.N quickspec/Count how many dictionary arguments a type has.O quickspec.Split a type into constraints and normal type.P quickspec&Pretty-print a type. Differs from the  3 instance by printing type variables in lowercase.Q quickspec'Substitute for all type variables in a $.R quickspecAll types that occur in a $.S quickspec#All type variables that occur in a $.T quickspecCast a $ to a target type. Succeeds if the target type is an instance of the current type.U quickspecCheck if the second argument is an instance of the first argument.V quickspec6Apply a function to its argument, crashing on failure.For most instances of $, the type of the argument must be exactly equal to the function's argument type. If you want unification to happen, use the $ instance of .W quickspec3Check if a function can be applied to its argument.X quickspecBuild a .Y quickspec/Alpha-rename type variables in a canonical way.Z quickspec0Get the polymorphic type of a polymorphic value.[ quickspecRename the type variables of the second argument so that they don't overlap with those of the first argument.\ quickspecRename the type variables of both arguments so that they don't overlap.] quickspecRename the type variables of both arguments so that they don't overlap.^ quickspecRename the type variables of all arguments so that they don't overlap._ quickspec+Find the most general unifier of two types.a quickspec-Convert an ordinary value to a dynamic value.b quickspec Construct a .c quickspecDeconstruct a .d quickspecUnwrap a value to get at the thing inside, with an existential type.e quickspec"Apply a polymorphic function to a .f quickspec"Apply a polymorphic function to a .g quickspec0Apply a polymorphic function that returns a non- result to a .h quickspec0Apply a polymorphic function that returns a non- result to a .i quickspec*Apply a polymorphic function to a pair of s. !"#$%&'()*+,-./0123476589:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl84765KJ3210/.-,+*)(9:;<=>I?@ABCDEMLONP$%&'QRSTU!"# VWFGHYaXZ[\]^_`bcdefghijklV  Safe-Inferred Safe-Inferred Safe-Inferred(/89:;=% quickspecA sum type. Intended to be used to build the type of function symbols. Comes with instances that are useful for QuickSpec. quickspec A helper for . quickspecA standard term ordering - size, skeleton, generality. Satisfies the property: if measure (schema t) < measure (schema u) then t < u. quickspec8A type representing functions which may be the identity. quickspec&A class for things that contain terms. quickspec5A different list of all terms contained in the thing. quickspec/Apply a substitution to all terms in the thing. quickspec*A variable, which has a type and a number. quickspec A typed term. quickspec5Decompose a term into a head and a list of arguments. quickspecAll terms contained in a . quickspec$All function symbols appearing in a 4, in order of appearance, with duplicates included. quickspecAll variables appearing in a 4, in order of appearance, with duplicates included. quickspec,Compute the number of a variable which does not appear in the . quickspec4Count how many times a given function symbol occurs. quickspec-Count how many times a given variable occurs. quickspecMap a function over variables. quickspec%Map a function over function symbols. quickspec%Map a function over function symbols. quickspec,Eliminate the identity function from a term. quickspec6Find all subterms of a term. Includes the term itself. quickspec>Find all subterms of a term. Does not include the term itself. quickspecRenames variables so that they appear in a canonical order. Also makes sure that variables of different types have different numbers. quickspecEvaluate a term, given a valuation for variables and function symbols. quickspec%Compute the term ordering for a term. quickspec A helper for .    8    Safe-Inferred89:;&544  Safe-Inferred )*8<'G   Safe-Inferred)*89:<'  Safe-Inferred%&'  Safe-Inferred %&)*(R Safe-Inferred ( Safe-Inferred (  Safe-Inferred %&8)@  Safe-Inferred %&)*) Safe-Inferred )*) Safe-Inferred%&* Safe-Inferred%&+ quickspecConstrains how variables of a particular type may occur in a term. quickspecUpTo n: terms may contain up to n distinct variables of this type (in some cases, laws with more variables may still be found) quickspec*Each variable in the term must be distinct quickspec;Instantiate a schema by making all the variables different. Safe-Inferred%&)*,J# Safe-Inferred %&8, Safe-Inferred-' Safe-Inferred%&)*/1<5K quickspec%How QuickSpec should style equations. quickspec>A test case is everything you need to evaluate a Haskell term. quickspecEvaluate a variable. Returns Nothing if no  instance was found. quickspec:Apply an observation function to get a value implementing  . Returns Nothing if no observer was found. quickspecA typeclass for types which support observational equality, typically used for types that have no  instance. An instance Observe test outcome a declares that values of type a can be tested8 for equality by random testing. You supply a function observe :: test -> outcome -> a. Then, two values x and y: are considered equal, if for many random values of type test,  observe test x == observe test y. The function  declares a monomorphic type with an observation function. For polymorphic types, use  to declare the  instance.4For an example of using observational equality, see  https://github.com/nick8325/quickspec/tree/master/examples/PrettyPrinting.hsPrettyPrinting.hs. quickspecMake an observation on a value. Should satisfy the following law: if x /= y, then there exists a value of test such that  observe test x /= observe test y. quickspecLike , but using the  typeclass instead of . quickspecGenerate a random test case. quickspec%Generate a random variable valuation. quickspecGenerate a random observation. quickspec4Generate a random function. Should be in QuickCheck. quickspec*Evaluate a Haskell term in an environment. quickspecDeclare a predicate with a given name and value. The predicate should have type  ... -> Bool. Uses an explicit generator. quickspecDeclare a predicate with a given name and value. The predicate should have type  ... -> Bool.4 Safe-Inferred)*/WJ- quickspec.Type class constraints as first class citizens quickspec [A])QuickSpec will then understand that the constant is really polymorphic. quickspecAdd a custom constant. quickspecLift a constrained type to a $ type which QuickSpec can work with quickspec0Add an instance of a type class to the signature quickspecDeclare a predicate with a given name and value. The predicate should be a function which returns . It will appear in equations just like any other constant, but will also be allowed to appear as a condition.Warning: if the predicate is unlikely to be true for a randomly-generated value, you will get bad-quality test data. In that case, use  instead. For example:  sig = [  "delete" ( :: Int -> [Int] -> [Int]),  "insert" ( :: Int -> [Int] -> [Int]), predicate "member" (member :: Int -> [Int] -> Bool) ]  quickspecDeclare a predicate with a given name and value. The predicate should be a function which returns . It will appear in equations just like any other constant, but will also be allowed to appear as a condition. The third argument is a generator for values satisfying the predicate.For example, this declares a predicate that checks if a list is sorted: *predicateGen "sorted" sorted genSortedListwhere sorted :: [a] -> Bool sorted xs = sort xs == xs genSortedList :: Gen [a] genSortedList = sort <$> arbitrary quickspec9Declare a new monomorphic type. The type must implement  and .If the type does not implement , you can use  to declare an observational equivalence function. If the type does not implement , you can use + to declare a custom QuickCheck generator.You do not necessarily need  and + instances for every type. If there is no  (or  instance) for a type, you will not get equations between terms of that type. If there is no  instance (or generator), you will not get variables of that type. quickspecLike 9, but designed to be used with TypeApplications directly.For example, you can add Foo to your signature via:  @Foo  quickspecDeclare a new monomorphic type using observational equivalence. The type must implement  and . quickspecLike 9, but designed to be used with TypeApplications directly.For example, you can add Foo to your signature via:  @Foo  quickspecDeclare a new monomorphic type using observational equivalence, saying how you want variables of that type to be named. quickspecLike 9, but designed to be used with TypeApplications directly.For example, you can add Foo to your signature via:  @Foo ["foo"]  quickspecDeclare a new monomorphic type, saying how you want variables of that type to be named. quickspecLike 4 designed to be used with TypeApplications directly.For example, you can add Foo to your signature via:  @Foo ["foo"]  quickspec7Customize how variables of a particular type are named. quickspecConstrain how variables of a particular type may occur in a term. The default value is  4. quickspec9Declare a typeclass instance. QuickSpec needs to have an  and , instance for each type you want it to test. For example, if you are testing  k v, you will need to add the following two declarations to your signature:  (  :: (Ord A, Ord B)  Ord (Map A B))  (  :: (Arbitrary A, Arbitrary B)  Arbitrary (Map A B)) For a monomorphic type T, you can use " instead, but if you want to use , you can do it like this:  (  :: ()  Ord T)  (  :: ()  Arbitrary T)  quickspecDeclare a generator to be used to produce random values of a given type. This will take precedence over any  instance. quickspec=Declare an arbitrary value to be used by instance resolution. quickspecDeclare some functions as being background functions. These are functions which are not interesting on their own, but which may appear in interesting laws with non-background functions. Declaring background functions may improve the laws you get out. Here is an example, which tests ++ and length , giving 0 and + as background functions: main = quickSpec [ con "++" ((++) :: [A] -> [A] -> [A]), con "length" (length :: [A] -> Int), background [ con "0" (0 :: Int), con "+" ((+) :: Int -> Int -> Int) ] ] quickspecRemove a function or predicate from the signature. Useful in combination with  and friends. quickspecRun QuickCheck on a series of signatures. Tests the functions in the first signature, then adds the functions in the second signature, then adds the functions in the third signature, and so on.This can be useful when you have a core API you want to test first, and a larger API you want to test later. The laws for the core API will be printed separately from the laws for the larger API.%Here is an example which first tests 0 and + and then adds ++ and length: main = quickSpec (series [sig1, sig2]) where sig1 = [ con "0" (0 :: Int), con "+" ((+) :: Int -> Int -> Int) ] sig2 = [ con "++" ((++) :: [A] -> [A] -> [A]), con "length" (length :: [A] -> Int) ] quickspec6Set the maximum size of terms to explore (default: 7). quickspec>Limit how many different function symbols can occur in a term. quickspec?Set how many times to test each discovered law (default: 1000). quickspecSet the maximum value for QuickCheck's size parameter when generating test data (default: 20). quickspec/Set which type polymorphic terms are tested at. quickspecSet how QuickSpec should display its discovered equations (default:  ForHumans).If you'd instead like to turn QuickSpec's output into QuickCheck tests, set this to  ForQuickCheck. quickspecSet how hard QuickSpec tries to filter out redundant equations (default: no limit).If you experience long pauses when running QuickSpec, try setting this number to 2 or 3. quickspecSet the maximum term size QuickSpec will reason about when it filters out redundant equations (default: same as maximum term size).If you get laws you believe are redundant, try increasing this number to 1 or 2 more than the maximum term size. quickspecSet the random number seed used for test case generation. Useful if you want repeatable results. quickspecAutomatically infer types to add to the universe from available type class instances quickspec(Experimental) Check that the discovered laws do not imply any false laws quickspec+A signature containing boolean functions: (), (), , , . quickspec/A signature containing arithmetic operations: 0, 1, (). Instantiate it with e.g. arith ( ::  ). quickspec)A signature containing list operations: [], (:), (). quickspec0A signature containing higher-order functions: () and . Useful for testing  and similar. quickspecThe QuickSpec prelude. Contains boolean, arithmetic and list functions, and function composition. For more precise control over what gets included, see , , ,  and .55 Safe-Inferred /XW?/0123?3210/ !"#$% &' &'()*()*()+(),-./-.0-.1-.234536736836936:36;36;<=>>?@ABCDEFGHIIJKLMNOPQRSTUVWXYZ[\[]^_`abcdefghijklmnopqrstuvwxyz{|}~m34 [-.-.-.-.-.------------------------------------------------------------------363636363636363636363636363636363636363636                                                                                  G#     $quickspec-2.2-IZSjQ5lmka18t2AqwSyTXiQuickSpec.Internal.Type QuickSpecQuickSpec.Internal.TermQuickSpec.InternalQuickSpec.Internal.Terminal'QuickSpec.Internal.Testing.DecisionTree"QuickSpec.Internal.Haskell.ResolveQuickSpec.Internal.UtilsQuickSpec.Internal.PropQuickSpec.Internal.TestingQuickSpec.Internal.Pruning%QuickSpec.Internal.Testing.QuickCheck&QuickSpec.Internal.Pruning.UntypedTwee%QuickSpec.Internal.Pruning.Background QuickSpec.Internal.Pruning.Types-QuickSpec.Internal.Pruning.PartialApplicationQuickSpec.Internal.Pruning.TweeQuickSpec.Internal.Parse QuickSpec.Internal.Explore.Terms"QuickSpec.Internal.Explore.Schemas&QuickSpec.Internal.Explore.Polymorphic'QuickSpec.Internal.Explore.ConditionalsQuickSpec.Internal.ExploreQuickSpec.Internal.HaskellmonoTypeObserveinst Data.ListdeleteinsertData.MapMapbaseData.Typeable.InternalTypeable(QuickCheck-2.14.3-2ZlD5s41ttb557C1ruU8WiTest.QuickCheck.Arbitrary Arbitrary Data.ProxyProxy)constraints-0.13.4-9P1xGiFIKVC77jAV7Jan2AData.ConstraintDictSub:-pretty-1.1.3.6Text.PrettyPrint.HughesPJClass pPrintPrec pPrintListpPrintPretty%twee-lib-2.4.2-FhQPTJEXL9x3sdZy81mG8m Twee.Base EqualsBonus Twee.Pretty prettyPrint termStyle PrettyTerm pPrintTerm TermStyleArityarityWrapperwrapreunwrap UnwrappedInValue valueTypePolyunPolyApplytryApplyTypeView unTypeViewTypedtyp otherTypesDL typeSubst_SymAClassFClassEClassDClassCClassBClassAEDCBATyConArrowStringTypetypeVar isTypeVartypeOftypeRep typeFromTyCon applyType arrowType isArrowType unpackArrowtypeArgstypeRestypeDrop typeArity oneTypeVar defaultToskolemiseTypeVars fromTypeRep fromTyContyCon getDictionary isDictionary dictAritysplitConstrainedType pPrintType typeSubsttypesDLtyVarscast matchTypeapplycanApplypolycanonicaliseTypepolyTyp polyRename polyApplypolyPairpolyListpolyMgupolyFunctionMgu toPolyValuetoValue fromValueunwrapmapValueforValueofValue withValue pairValues wrapFunctor unwrapFunctor bringFunctor$fCoArbitraryTermList$fPrettyTermTyCon $fPrettyTyCon$fLabelledTyCon$fCoArbitraryTerm $fTyped[] $fTypedEither $fTyped(,) $fTypedTerm$fHasTypeViewTerm$fSymbolicTypeView $fApplyTerm $fApplyPoly $fTypedPoly $fApplyValue $fTypedValue $fShowValue$fEqPoly $fOrdPoly $fShowPoly $fPrettyPoly $fEqTyCon $fOrdTyCon $fShowTyCon:+:InlInr MeasureFunsMeasureOrIdIdNotIdSizedsizeSymbolictermsDLsubstVarVvar_tyvar_idTermFun:$::@:matchunifytermsfunsvarsgetAppfreeVaroccoccVarmapVarmapFun flatMapFun eliminateIdsubtermsproperSubterms subtermsFOproperSubtermsFO canonicaliseevalTermdepthmeasure compareFuns $fPrettyVar $fTypedVar$fCoArbitraryVar $fPrettyTerm $fSymbolicf[]$fSymbolicfTerm $fSizedTerm$fOrdMeasureFuns$fEqMeasureFuns$fPrettyTerm:+: $fPretty:+: $fTyped:+: $fSized:+:$fEq:+:$fOrd:+:$fEqTerm $fOrdTerm $fShowTerm $fFunctorTerm$fFoldableTerm$fTraversableTerm$fEqVar$fOrdVar $fShowVar $fGenericVar VariableUseUpToLinear PrintStyle ForHumans ForQuickCheckObserveobserve=~===> Signature signatureContextSigunSig quickSpecquickSpecResult addBackgroundrunSigconcustomConstantliftC instanceOf predicate predicateGenmonoTypemono monoObservemonoTypeObserveWithVarsmonoObserveVarsmonoTypeWithVarsmonoVars variableUse generatorinstFun addInstanceswithPrintFilter backgroundwithoutserieswithMaxTermSizewithMaxCommutativeSizewithMaxFunctions withMaxTestswithMaxTestSizewithPrintStylewithPruningDepthwithPruningTermSize withFixedSeedwithInferInstanceTypeswithConsistencyCheckboolsarithlistsprelude $fMonoidSig$fSemigroupSig $fSignature[]$fSignatureSigTerminal MonadTerminalputTextputTempputLine putStatus clearStatus withStatuswithNullTerminalwithStdioTerminal Statisticsstat_num_test_casesstat_num_testsstat_num_termsResultEqualToDistinct InnerTreeTestCase Singleton DecisionTreedt_tree dt_test_cases dt_evaluateempty addTestCase statisticstypeVars Data.TypeableTypeRepghc-prim GHC.Types arrowTyCon commaTyCon listTyCon dictTyCon Instances is_instancesis_find valueInst findValue findInstance#key keyDefaultreadingfstLenssndLens makeLensAsrepeatM partitionBycollateisSorted isSortedByusortusortBysortBy'usortBy'orElse unbufferedspoonylabelMappendAt antiunifyfixpoint PrettyLevel prettyShow prettyParen prettyNormalText.PrettyPrint.HughesPJDoc zeroWidthTextvcattextspace sizedTextsepsemirparen renderStylerender reduceDocrbrackrbracerationalquotes punctuateptextparensnest maybeQuotes maybeParensmaybeDoubleQuotes maybeBrackets maybeBraceslparenlbracklbraceisEmptyintegerinthsephcathang fullRenderfsepfloatfirstfcatequals doubleQuotesdoublecommacoloncharcatbracketsbraces<+>$+$$$#Text.PrettyPrint.Annotated.HughesPJ TextDetailsPStrStrChrStyleribbonsPerLinemode lineLengthMode ZigZagModePageModeLeftMode OneLineModestyle tupleStyle infixStylepostfixprefiximplicitArguments fixedArity uncurriedcurried invisiblemaybeHighlight highlightboldgreensupply pPrintSet pPrintTuple pPrintEmpty<#>HighlightedTermANSICodeNamedOrdinaryNameEquation:=:Proprhslhs:=>:literalsunitPropmapTerm=== prettyProp prettyPropQCnameVars MonadTesterretesttest TestResult Untestable TestFailed TestPassed testResulttestAnd testImplies WatchPrunerReadOnlyPrunerwithReadOnlyPruner MonadPruner normTheoremsdecodeNormalForm normaliseraddTheorem axiomsUsedprop decodeTheoremtheorems normalise watchPrunerTester Environmentenv_eval env_tests env_configConfigcfg_fixed_seedcfg_max_test_size cfg_num_testslens_num_testslens_max_test_sizelens_fixed_seedrununiformquickCheckTestNormPrunerExtendedSkolemMinimalFunctioncfg_max_term_sizecfg_max_cp_depthlens_max_term_sizelens_max_cp_depth normaliseTweenormalFormsTweeaddTweetoTwee skolemise Background addFunction UntypedTerm TypedTermTaggedFuncTag typingAxiomstagencodePartiallyAppliedPartialpartialtotal smartApply simpleApplyParseparse parsePropKnew DiscoveredTermstm_treetm_termstm_emptytree treeForType initialStateexploreexplore' mostGeneral result_propsRejectedAcceptedSchemas sc_instancessc_instantiated sc_classessc_emptysc_instantiate_singletonsc_useclassesuse instances instantiated instance_ exploreIninstantiateRep instantiate generalitymkVar mostSpecificallUnificationsPolyMunPolyMUniverse univ_typesPolyFunfun_specialised fun_original Polymorphic pm_universe pm_schemasschemasunivpolyFunpolyTerm exploreNoMGU regeneralisetypeInstancesList typeInstances intersectionuniverse inUniverseusefulForUniverseWithConstructorNormal ConstructorClassification clas_pred clas_index clas_trueclas_selectorsclas_test_case PredicateSelectorclassify ConditionalsconditionalsUniverserunConditionalspredTypeconsiderPredicateconsiderConditionalisingconditionallyRedundantconditionallyRedundant' addPredicateconditionalise Enumerator enumerate mapEnumeratorfilterEnumeratorenumerateConstantsenumerateApplicationsfilterUniverse sortTermspPrintSignatureprettyDefinitionprettyACdisambiguatePropType tc_eval_vartc_test_result GHC.ClassesOrdTest.QuickCheck.PropertyEqarbitraryTestCasearbitraryValuationarbitraryObserverarbitraryFunction evalHaskellWarningswarn_no_observerwarn_no_generatorcfg_check_consistencycfg_print_stylecfg_print_filtercfg_backgroundcfg_infer_instance_typescfg_default_to cfg_constants cfg_instancescfg_max_functionscfg_max_commutative_size cfg_max_sizecfg_tweecfg_quickCheckTestCaseWrappedunTestCaseWrapped HasFriendly unfriendlyFriendlyFriendlyPredicateTestCase PredicateableuncrrytruePredicateResultPredicateTestCaseConstant con_is_hole con_classifycon_sizecon_constraintscon_type con_value con_stylecon_nameOrdyNamesgetNamesWrappedObserveData ObserveDataUse NoWarnings OrdInstance baseInstances observeOrdobserveFunction observeObsbaseTypenames findGeneratorfindOrdInstance findObserver constant'isOp selectorsunhideConstraint evalConstantunfriendlyPredicateGenlens_quickCheck lens_twee lens_max_sizelens_max_commutative_sizelens_max_functionslens_instanceslens_constantslens_default_tolens_infer_instance_typeslens_backgroundlens_print_filterlens_print_stylelens_check_consistency defaultConfig instanceTypeswarningsBool||&&notTrueFalseGHC.Num+IntGHC.Base++.idmap