!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None&'7K . Safe"# None&'+,-01;<=>?CEFKOQTVQGFunctions for re-wrapping an   value. @Wrap up a value which has the same existential type as this one. ?Unwrap a value which has the same existential type as this one. pThe unwrapped value. Consists of the value itself (with an existential type) and functions to wrap it up again.-Dynamic values inside an applicative functor.For example, a value of type  Value Maybe represents a Maybe something.ZRepresents a forall-quantifier over all the type variables in a type. Wrapping a term in PolyC normalises the type by alpha-renaming type variables canonically.The  instance for = does unification to handle applying a polymorphic function./Typed things that support function application.!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 .A wrapper for using the  machinery on types.$A class for things that have a type. The type.#Types that appear elsewhere in the Q, for example, types of subterms. Should return everything which is affected by C."Substitute for all type variables."A polymorphic type of kind Symbol.'A type constructor.(The function type constructor (->).)%An ordinary Haskell type constructor.*\A string. Can be used to represent miscellaneous types that do not really exist in Haskell.+A (possibly polymorphic) type.3All type variables that are defined in this module.,A type variable.-#Check if a type is a type variable..Construct a type from a ./Construct a type from a .0Turn a ' into a type.1+Function application for type constructors. For example, happlyType (typeRep (Proxy :: Proxy [])) (typeRep (Proxy :: Proxy Int)) == typeRep (Proxy :: Proxy [Int]).2Construct a function type.32Decompose a function type into (argument, result).6For multiple-argument functions, unpacks one argument.4!The arguments of a function type.5The result of a function type.6MGiven the type of a function, returns the type of applying that function to n? arguments. Crashes if the type does not have enough arguments.7(How many arguments does a function take?8#Unify all type variables in a type.92Replace all type variables with a particular type.:JMake a type ground by replacing all type variables with Skolem constants.;Construct a type from a .< Construct a ' type from a  Data.Typeable .Some built-in type consructors.Some built-in type consructors.Some built-in type consructors.Some built-in type consructors.=Get the outermost ' of a .>Check if a type is of the form  c, and if so, return c.?Check if a type is of the form  c.@/Count how many dictionary arguments a type has.A.Split a type into constraints and normal type.B&Pretty-print a type. Differs from the 3 instance by printing type variables in lowercase.C'Substitute for all type variables in a .DAll types that occur in a .E#All type variables that occur in a .FCast a S to a target type. Succeeds if the target type is an instance of the current type.GBCheck if the second argument is an instance of the first argument.H6Apply 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 .I3Check if a function can be applied to its argument.JBuild a .K/Alpha-rename type variables in a canonical way.L0Get the polymorphic type of a polymorphic value.MnRename the type variables of the second argument so that they don't overlap with those of the first argument.NGRename the type variables of both arguments so that they don't overlap.OGRename the type variables of both arguments so that they don't overlap.PFRename the type variables of all arguments so that they don't overlap.Q+Find the most general unifier of two types.R-Convert an ordinary value to a dynamic value.S Construct a .TDeconstruct a .UDUnwrap a value to get at the thing inside, with an existential type.V"Apply a polymorphic function to a .W"Apply a polymorphic function to a .X0Apply a polymorphic function that returns a non- result to a .Y0Apply a polymorphic function that returns a non- result to a .Z*Apply a polymorphic function to a pair of s.W  !"#$%&')*(+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]Y+'()*=<&%$#"! ,-./01;234567?>A@BCDEFGHI89:KRJLMNOPQSTU  VWXYZ[\]   "#$%&'()*H NoneQVT   NoneU/   None%+368;<=>?AFSTdkeu{A sum type. Intended to be used to build the type of function symbols. Comes with instances that are useful for QuickSpec.x A helper for z.zA standard term ordering - size, skeleton, generality. Satisfies the property: if measure (schema t) < measure (schema u) then t < u.}&A class for things that contain terms.~5A different list of all terms contained in the thing./Apply a substitution to all terms in the thing.*A variable, which has a type and a number. A typed term./Is a term an application (i.e. not a variable)?Is a term a variable?All terms contained in a }.$All function symbols appearing in a }4, in order of appearance, with duplicates included.All variables appearing in a }4, in order of appearance, with duplicates included.,Compute the number of a variable which does not appear in the }.4Count how many times a given function symbol occurs.-Count how many times a given variable occurs.Map a function over variables.6Find all subterms of a term. Includes the term itself.>Find all subterms of a term. Does not include the term itself.Renames variables so that they appear in a canonical order. Also makes sure that variables of different types have different numbers.FEvaluate a term, given a valuation for variables and function symbols.%Compute the term ordering for a term. A helper for z.!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~uvwxyz{|}~/}~{|zxyuvwuvwxy{|}~None 36;<=>?FSTo544 None &'7;=>?ApM None &'7;=>?AKp  None "#;<=>?Kq None"#&';<=>?Kdr None ;<=>?KSTsNone "#;<=>?KVt None "#&';<=>?KduxNone&';<=>?vNone "#3;<=>?KvNone"#<OwJNone "#;<=>?NOy-;Instantiate a schema by making all the variables different.None"#&';<=>?KQVz           None "#3;<=>?KOST{!"#$%&'()*+,-./0123456789!#"$ %&'+,*)(,-./0None<| :;<=>?@ABCD:;<None"#&'+-7;<=>?AFOQSTV E>A test case is everything you need to evaluate a Haskell term.FEvaluate a variable. Returns Nothing if no  instance was found.G:Apply an observation function to get a value implementing H . Returns Nothing if no observer was found.cA typeclass for types which support observational equality, typically used for types that have no H 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 X declares a monomorphic type with an observation function. For polymorphic types, use  to declare the  instance.4For an example of using observational equality, see  Lhttps://github.com/nick8325/quickspec/tree/master/examples/PrettyPrinting.hsPrettyPrinting.hs.FMake 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.IGenerate a random test case.J%Generate a random variable valuation.KGenerate a random observation.L4Generate a random function. Should be in QuickCheck.M*Evaluate a Haskell term in an environment.NQDeclare a predicate with a given name and value. The predicate should have type  ... -> Bool.POPQRSTUVWXYZ[\]^_`abcdefgEhGFijklmnopqrstuvwxyIJKz{LM|}~N OPWVUTSRQXYZ[]\^ _gfedcba`EhFGijklmnopqrsNone +<>?AQSTVS.Type class constraints as first class citizens<A class of things that can be used as a QuickSpec signature.!Convert the thing to a signature. A signature.=Run QuickSpec. See the documentation at the top of this file.;Run QuickSpec, returning the list of discovered properties.xDeclare a constant with a given name and value. If the constant you want to use is polymorphic, you can use the types &, %, $, #, "! to monomorphise it, for example: *constant "reverse" (reverse :: [A] -> [A])GQuickSpec will then understand that the constant is really polymorphic.Lift a constrained type to a $ type which QuickSpec can work with0Add an instance of a type class to the signaturecDeclare a predicate with a given name and value. The predicate should be a function which returns p. It will appear in equations just like any other constant, but will also be allowed to appear as a condition. For example:  sig = [  "delete" ( :: Int -> [Int] -> [Int]),  "insert" (T :: Int -> [Int] -> [Int]), predicate "member" (member :: Int -> [Int] -> Bool) ] 9Declare a new monomorphic type. The type must implement H and .YDeclare a new monomorphic type using observational equivalence. The type must implement  and .WDeclare a new monomorphic type, saying how you want variables of that type to be named.7Customize how variables of a particular type are named.9Declare a typeclass instance. QuickSpec needs to have an H and , instance for each type you want it to test. For example, if you are testing  k vI, 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)) Declare 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) ] ]ORemove a function or predicate from the signature. Useful in combination with  and friends.Run 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 [sig1, sig2] where sig1 = [ con "0" (0 :: Int), con "+" ((+) :: Int -> Int -> Int) ] sig2 = [ con "++" ((++) :: [A] -> [A] -> [A]), con "length" (length :: [A] -> Int) ]6Set the maximum size of terms to explore (default: 7).?Set how many times to test each discovered law (default: 1000)._Set the maximum value for QuickCheck's size parameter when generating test data (default: 20)./Set which type polymorphic terms are tested at.SSet how hard QuickSpec tries to filter out redundant equations (default: no limit).YIf you experience long pauses when running QuickSpec, try setting this number to 2 or 3.Set the maximum term size QuickSpec will reason about when it filters out redundant equations (default: same as maximum term size).qIf you get laws you believe are redundant, try increasing this number to 1 or 2 more than the maximum term size.aSet the random number seed used for test case generation. Useful if you want repeatable results.UAutomatically infer types to add to the universe from available type class instances+A signature containing boolean functions: (), (), , , ./A signature containing arithmetic operations: 0, 1, (). Instantiate it with e.g. arith ( ::  ).)A signature containing list operations: [], (:), ().0A signature containing higher-order functions: () and . Useful for testing  and similar.The QuickSpec prelude. Contains boolean, arithmetic and list functions, and function composition. For more precise control over what gets included, see , , ,  and .."#$%&/&%$#" !"#$%&%&'()'()'(*'(+,,-./01234567789:;<=>?@ABCDEFGHIJIKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Z     I13DEFGH !"#$%&'()*+,-./01234556789:9;9<9=9>9?9@9A9B9C9D9E9F9G9H9I9J9K9L9M9N9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9\9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9lmnmompmqmrmsmsmtmumvmwmxmymzm{ | } ~                                                  5      !"#$%&'(()*+,-./012 3456789:;<=>?@AABCDEFFGHIJKLMNOOPPQRRSSTTUVWXYZ[\]^_`abcdeefghijklmnopq r 3s 3t 3u v wxy z{|{}{~{$quickspec-2.1-5fSNb7X5HLABGdHB0i89utQuickSpec.Type QuickSpecQuickSpec.TermQuickSpec.TerminalQuickSpec.Testing.DecisionTreeQuickSpec.Haskell.ResolveQuickSpec.UtilsQuickSpec.PropQuickSpec.TestingQuickSpec.PruningQuickSpec.Testing.QuickCheckQuickSpec.Pruning.UntypedTweeQuickSpec.Pruning.BackgroundQuickSpec.Pruning.TypesQuickSpec.Pruning.TweeQuickSpec.Parse$QuickSpec.Explore.PartialApplicationQuickSpec.Explore.TermsQuickSpec.Explore.SchemasQuickSpec.Explore.PolymorphicQuickSpec.Explore.ConditionalsQuickSpec.ExploreQuickSpec.HaskellmonoTypeObserveinst Data.ListdeleteinsertData.MapMapbaseData.Typeable.InternalTypeable(QuickCheck-2.10.1-BUFYQzp5Pjm7JbQeTzW89lTest.QuickCheck.Arbitrary Arbitrary Data.ProxyProxy'constraints-0.10-8EDr8M62baYIrdFVxMCmYVData.ConstraintDictSub:-Wrapperwrapreunwrap UnwrappedInValue valueTypePolyunPolyApplytryApplyTypeView unTypeViewTypedtyp otherTypesDL typeSubst_SymAClassFClassEClassDClassCClassBClassAEDCBATyConArrowStringTypetypeVar isTypeVartypeOftypeRep typeFromTyCon applyType arrowType unpackArrowtypeArgstypeRestypeDrop typeArity oneTypeVar defaultToskolemiseTypeVars fromTypeRep fromTyContyCon getDictionary isDictionary dictAritysplitConstrainedType pPrintType typeSubsttypesDLtyVarscast matchTypeapplycanApplypolycanonicaliseTypepolyTyp polyRename polyApplypolyPairpolyListpolyMgu toPolyValuetoValue fromValueunwrapmapValueforValueofValue withValue pairValues wrapFunctor unwrapFunctor bringFunctor$fCoArbitraryTermList$fPrettyTermTyCon $fPrettyTyCon$fCoArbitraryTerm $fTyped[] $fTypedEither $fTyped(,) $fTypedTerm$fHasTypeViewTerm$fSymbolicTypeView $fApplyTerm $fApplyPoly $fTypedPoly $fApplyValue $fTypedValue $fShowValue $fEqTyCon $fOrdTyCon $fShowTyCon$fEqPoly $fOrdPoly $fShowPoly $fPrettyPoly:+:InlInr MeasureFunsMeasureSizedsizeSymbolictermsDLsubstVarVvar_tyvar_idTermAppisAppisVartermsfunsvarsfreeVaroccoccVarmapVarsubtermsproperSubterms canonicaliseevalTermmeasure compareFuns $fPrettyVar $fTypedVar $fPrettyTerm $fSymbolicf[]$fSymbolicfTerm $fSizedTerm$fOrdMeasureFuns$fEqMeasureFuns$fPrettyTerm:+: $fPretty:+: $fTyped:+: $fArity:+: $fSized:+:$fEqVar$fOrdVar $fShowVar $fGenericVar$fCoArbitraryVar$fEqTerm $fOrdTerm $fShowTerm $fFunctorTerm$fEq:+:$fOrd:+:Observeobserve==> Signature signatureSig quickSpecquickSpecResultconliftC instanceOf predicatemonoTypemonoTypeWithVars backgroundwithoutserieswithMaxTermSize withMaxTestswithMaxTestSizewithPruningDepthwithPruningTermSize withFixedSeedwithInferInstanceTypesboolsarithlistsprelude $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 statistics%twee-lib-2.1.5-CHKxerxFTACC9u4f7x8l0u Twee.BasetypeVars Data.TypeableTypeRepghc-prim GHC.Types arrowTyCon commaTyCon listTyCon dictTyConpretty-1.1.3.3Text.PrettyPrint.HughesPJClassPrettyvalue Instances is_instancesis_find valueInst findValue findInstance#key keyDefaultreadingfstLenssndLens makeLensAsrepeatM partitionBycollateisSorted isSortedByusortusortBysortBy'usortBy'orElse unbufferedspoonylabelMappendAt prettyParen prettyShow prettyNormal PrettyLevel pPrintPrecpPrint pPrintListText.PrettyPrint.HughesPJ fullRender renderStylerenderfirstfsepfcatcatsep<+>$+$$$ punctuatehangnestvcathsephcat reduceDocmaybeDoubleQuotes maybeQuotes maybeBraces maybeBrackets maybeParensbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecoloncommasemiisEmpty zeroWidthText sizedTextptexttextcharDoc#Text.PrettyPrint.Annotated.HughesPJstyle TextDetailsStrChrPStrStylemode lineLengthribbonsPerLineModePageMode ZigZagModeLeftMode OneLineModeArityarity EqualsBonus Twee.Pretty tupleStyle infixStylepostfixprefiximplicitArguments fixedArity uncurriedcurried invisiblesupply pPrintSet pPrintTuple pPrintEmpty<#> prettyPrint PrettyTerm termStyle TermStyle pPrintTermNamedNameFun PrettyArity prettyArityEquation:=:Prop:=>:rhslhsliteralsunitPropmapFun=== prettyPropnameVars MonadTestertest WatchPrunerReadOnlyPrunerwithReadOnlyPruner MonadPruner normaliseradd normalise watchPrunerConfigcfg_fixed_seedcfg_max_test_size cfg_num_testsTester Environmentenv_eval env_tests env_configlens_num_testslens_max_test_sizelens_fixed_seedrununiformquickCheckTestcfg_max_term_sizecfg_max_cp_depthPrunerlens_max_term_sizelens_max_cp_depth normaliseTweenormalFormsTweeaddTweetoTwee skolemisefromTwee Background addFunction UntypedTerm TypedTermTaggedTagFunc typingAxiomstagencodedecodeParseparse parsePropPartiallyAppliedPartialgetTotalpartialtotal simpleApplyevalPartiallyAppliedTermstm_treetm_termstm_emptyKnew Discoveredtree treeForType initialStateexploreexplore' mostGeneralSchemas sc_instancessc_instantiated sc_classessc_emptysc_instantiate_singletonRejectedAccepted result_propsclasses instantiated instances instance_ exploreIninstantiateRep instantiate generality mostSpecificallUnificationsUniverse univ_typesPolyFun fun_originalfun_specialised Polymorphic pm_schemas pm_universePolyMunPolyMschemasunivpolyFunpolyTerm exploreNoMGU regeneralise typeInstances intersectionuniverse inUniverseusefulForUniverseWithConstructorNormal ConstructorClassification PredicateSelectorFunction clas_pred clas_index clas_trueclas_selectorsclas_test_caseclassify ConditionalsconditionalsUniverserunConditionalspredTypeconsiderPredicateconsiderConditionalisingconditionallyRedundantconditionallyRedundant' addPredicateconditionalise Enumerator enumerate mapEnumeratorfilterEnumeratorenumerateConstantsenumerateApplicationsfilterUniverse sortTermspPrintSignature tc_eval_vartc_test_result GHC.ClassesOrdarbitraryTestCasearbitraryValuationarbitraryObserverarbitraryFunction evalHaskellcfg_infer_instance_typescfg_default_to cfg_constants cfg_instances cfg_max_sizecfg_tweecfg_quickCheckTestCaseWrappedunTestCaseWrapped PredicateableuncrryPredicateTestCaseConstant con_classifycon_sizecon_constraintscon_type con_valuecon_pretty_arity con_stylecon_nameOrdyNamesgetNamesWrappedObserveData ObserveData NoWarnings baseInstances observeOrdobserveFunction observeObsbaseTypenames findGenerator findObserver constant'isOp selectorsunhideConstraint evalConstant genSuchThattruetrueTermWarningswarn_no_observerwarn_no_generatorlens_quickCheck lens_twee lens_max_sizelens_instanceslens_constantslens_default_tolens_infer_instance_types defaultConfig instanceTypeswarningsBool||&&notTrueFalseGHC.Num+IntGHC.Base++.idmapContextunSig