!:l      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None&'8M n   Safe"#    None&',-.12=>?@AEHMSVX]H quickspecFunctions for re-wrapping an  value. quickspec@Wrap 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. quickspecpThe 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. quickspecZRepresents 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. 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 "Q, for example, types of subterms. Should return everything which is affected by O.% quickspec"Substitute for all type variables.& quickspec"A polymorphic type of kind Symbol.2 quickspecA type constructor.3 quickspecThe function type constructor (->).4 quickspec%An ordinary Haskell type constructor.5 quickspec\A string. Can be used to represent miscellaneous types that do not really exist in Haskell.6 quickspecA (possibly polymorphic) type.  quickspec3All type variables that are defined in this module.7 quickspecA type variable.8 quickspec#Check if a type is a type variable.9 quickspecConstruct a type from a .: quickspecConstruct a type from a .; quickspecTurn a 2 into a type.< quickspec+Function application for type constructors. For example, happlyType (typeRep (Proxy :: Proxy [])) (typeRep (Proxy :: Proxy Int)) == typeRep (Proxy :: Proxy [Int]).= quickspecConstruct a function type.> quickspec Is a given type a function type?? quickspec2Decompose a function type into (argument, result).6For multiple-argument functions, unpacks one argument.@ quickspec!The arguments of a function type.A quickspecThe result of a function type.B quickspecMGiven the type of a function, returns the type of applying that function to n? arguments. Crashes if the type does not have enough arguments.C quickspec(How many arguments does a function take?D quickspec#Unify all type variables in a type.E quickspec2Replace all type variables with a particular type.F quickspecJMake a type ground by replacing all type variables with Skolem constants.G quickspecConstruct a type from a !.H quickspec Construct a 2 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.I quickspecGet the outermost 2 of a .J quickspecCheck if a type is of the form  c, and if so, return c.K quickspecCheck if a type is of the form  c.L quickspec/Count how many dictionary arguments a type has.M quickspec.Split a type into constraints and normal type.N quickspec&Pretty-print a type. Differs from the  3 instance by printing type variables in lowercase.O quickspec'Substitute for all type variables in a ".P quickspecAll types that occur in a ".Q quickspec#All type variables that occur in a ".R quickspecCast a "S to a target type. Succeeds if the target type is an instance of the current type.S quickspecBCheck if the second argument is an instance of the first argument.T 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 .U quickspec3Check if a function can be applied to its argument.V quickspecBuild a .W quickspec/Alpha-rename type variables in a canonical way.X quickspec0Get the polymorphic type of a polymorphic value.Y quickspecnRename the type variables of the second argument so that they don't overlap with those of the first argument.Z quickspecGRename the type variables of both arguments so that they don't overlap.[ quickspecGRename the type variables of both arguments so that they don't overlap.\ quickspecFRename the type variables of all arguments so that they don't overlap.] quickspec+Find the most general unifier of two types.^ quickspec-Convert an ordinary value to a dynamic value._ quickspec Construct a .` quickspecDeconstruct a .a quickspecDUnwrap a value to get at the thing inside, with an existential type.b quickspec"Apply a polymorphic function to a .c quickspec"Apply a polymorphic function to a .d quickspec0Apply a polymorphic function that returns a non- result to a .e quickspec0Apply a polymorphic function that returns a non- result to a .f quickspec*Apply a polymorphic function to a pair of s.X !"#$%&'()*+,-./0124536789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghiX62453IH10/.-,+*)('&789:;<G=>?@ABCKJMLN"#$%OPQRS !TUDEFW^VXYZ[\]_`abcdefghiT NoneSXa'()*+,-.Noneaw/0123456789:;<=>?@ABCDENone%,479=>?@ACHUVgz quickspec{A 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. 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. 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. quickspecFEvaluate a term, given a valuation for variables and function symbols. quickspec%Compute the term ordering for a term. quickspec A helper for .FGHIJ KLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  2   None 47=>?@AHUV~5544 None &'8=?@AC5 None &'8=?@ACM  None"#=>?@AMk None "#&'=>?@AMgRNone =>?@AMUV None "#=>?@AMX None "#4=>?@AMg None "#&'=>?@AMg2None&'=>?@ANone"#> None"#=>?@AP* quickspecBConstrains 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.      !"None"#&'=>?@AMSXQ#    #$%&'()*+,-./0123456789:;<=>None "#4=>?@AMUVt?@ABCDEFGHIJKLMNOPQRSTUVWNone>XYZ[\]^_`abcdeNone"#&',.8=>?@ACHSUVX quickspec%How QuickSpec should style equations.f quickspec>A test case is everything you need to evaluate a Haskell term.g quickspecEvaluate a variable. Returns Nothing if no  instance was found.h quickspec:Apply an observation function to get a value implementing i . Returns Nothing if no observer was found. quickspeccA typeclass for types which support observational equality, typically used for types that have no i 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. quickspecFMake 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 j, but using the  typeclass instead of k.l quickspecGenerate a random test case.m quickspec%Generate a random variable valuation.n quickspecGenerate a random observation.o quickspec4Generate a random function. Should be in QuickCheck.p quickspec*Evaluate a Haskell term in an environment.q quickspecQDeclare a predicate with a given name and value. The predicate should have type  ... -> Bool. Uses an explicit generator.r quickspecQDeclare a predicate with a given name and value. The predicate should have type  ... -> Bool.astuvwxyz{|}~fhglmnopqrNone ,>@ACSUVXk* quickspec.Type class constraints as first class citizens quickspec<A class of things that can be used as a QuickSpec signature. quickspec!Convert the thing to a signature. quickspec A signature. quickspec=Run QuickSpec. See the documentation at the top of this file. quickspec;Run QuickSpec, returning the list of discovered properties. quickspec-Add some properties to the background theory. quickspecxDeclare a constant with a given name and value. If the constant you want to use is polymorphic, you can use the types 1, 0, /, ., -! to monomorphise it, for example: *constant "reverse" (reverse :: [A] -> [A])GQuickSpec 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 quickspeccDeclare 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) ]  quickspeccDeclare 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. quickspec9Declare a new monomorphic type. The type must implement i and . quickspecLike 9, but designed to be used with TypeApplications directly.For example, you can add Foo to your signature via:  @Foo  quickspecYDeclare 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  quickspecwDeclare 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"]  quickspecWDeclare 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. quickspecXConstrain 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 iA and | Declare a typeclass instance. QuickSpec needs to have an i 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))  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) ] ] quickspecORemove 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?Set how many times to test each discovered law (default: 1000). quickspec_Set the maximum value for QuickCheck's size parameter when generating test data (default: 20). quickspec/Set which type polymorphic terms are tested at. quickspecDSet how QuickSpec should display its discovered equations (default:  ForHumans).UIf you'd instead like to turn QuickSpec's output into QuickCheck tests, set this to  ForQuickCheck. quickspecSSet 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. quickspecSet 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. quickspecaSet the random number seed used for test case generation. Useful if you want repeatable results. quickspecUAutomatically infer types to add to the universe from available type class instances 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 .22None ,>@ACSUVX <-./01<10/.- !"#$% &' &'()*()*()+(),-./-.0-.1-.234536736836936:36;36;<<=>?@ABCDEFGGHIJKLMNOPQRSTUVWXYZY[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     k !"#$%%&'()*+,-.//012345346 789:Y;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[-.\-.]-.^-._-._-`a-`b-`c-`d-`e-`f-`g-`h-`i-`j-`k-`l-`m-`n-`o-`p-`q-`r-`s-`t-`u-`v-`w-`x-`y-`z-`{-`|-`}-`~-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`-`---------------3636363636363636363636363636                                                             E).)      !!"#$%&'()*+,-./0123456789:;4<==>?@ABCDEFGGHIJKLMNOPQR-ST9UV#W9UXYZ[\]^^_`abcdefghijkllmnopqqrstuvwx-yyzz{||}}~~9:9U9U9U9:9: 9:    &quickspec-2.1.4-K7RHmHihpJXAcYe0rS25k0QuickSpec.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.1-IqiFngERTXR1loN1el8aePTest.QuickCheck.Arbitrary Arbitrary Data.ProxyProxy'constraints-0.12-9r4GNEjfdu11xgOuzOy6H1Data.ConstraintDictSub:-pretty-1.1.3.6Text.PrettyPrint.HughesPJClass pPrintListpPrint pPrintPrecPretty"twee-lib-2.2-5O2RgoqsfkFtBhspcstCh Twee.Base EqualsBonus Twee.Pretty prettyPrint termStyle PrettyTerm pPrintTerm TermStyleWrapperwrapreunwrap UnwrappedInValue valueTypePolyunPolyApplytryApplyTypeView unTypeViewTypedtyp otherTypesDL typeSubst_SymAClassFClassEClassDClassCClassBClassAEDCBATyConArrowStringTypetypeVar isTypeVartypeOftypeRep typeFromTyCon applyType arrowType isArrowType 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_idTermFun:$::@:matchunifytermsfunsvarsgetAppfreeVaroccoccVarmapVarsubtermsproperSubterms subtermsFOproperSubtermsFO canonicaliseevalTermdepthmeasure compareFuns $fPrettyVar $fTypedVar$fCoArbitraryVar $fPrettyTerm $fSymbolicf[]$fSymbolicfTerm $fSizedTerm$fOrdMeasureFuns$fEqMeasureFuns$fPrettyTerm:+: $fPretty:+: $fTyped:+: $fSized:+:$fEqVar$fOrdVar $fShowVar $fGenericVar$fEqTerm $fOrdTerm $fShowTerm $fFunctorTerm$fEq:+:$fOrd:+: VariableUseUpToLinear PrintStyle ForHumans ForQuickCheckObserveobserve=~===> Signature signatureContextSigunSig quickSpecquickSpecResult addBackgroundrunSigconcustomConstantliftC instanceOf predicate predicateGenmonoTypemono monoObservemonoTypeObserveWithVarsmonoObserveVarsmonoTypeWithVarsmonoVars variableUseinstFun addInstanceswithPrintFilter backgroundwithoutserieswithMaxTermSizewithMaxCommutativeSize withMaxTestswithMaxTestSizewithPrintStylewithPruningDepthwithPruningTermSize 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 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 prettyParen prettyShow prettyNormal PrettyLevelText.PrettyPrint.HughesPJ fullRender renderStylerenderfirstfsepfcatcatsep<+>$+$$$ punctuatehangnestvcathsephcat reduceDocmaybeDoubleQuotes maybeQuotes maybeBraces maybeBrackets maybeParensbracesbracketsparens doubleQuotesquotesrationaldoublefloatintegerintrbracelbracerbracklbrackrparenlparenequalsspacecoloncommasemiisEmpty zeroWidthText sizedTextptexttextcharDoc#Text.PrettyPrint.Annotated.HughesPJstyle TextDetailsStrChrPStrStylemode lineLengthribbonsPerLineModePageMode ZigZagModeLeftMode OneLineMode tupleStyle infixStylepostfixprefiximplicitArguments fixedArity uncurriedcurried invisiblesupply pPrintSet pPrintTuple pPrintEmpty<#>NamedOrdinaryNameEquation:=:Prop:=>:rhslhsliteralsunitPropmapFun=== prettyProp prettyPropQCnameVars MonadTestertest WatchPrunerReadOnlyPrunerwithReadOnlyPruner MonadPruner normaliseradd normalise watchPrunerTester Environmentenv_eval env_tests env_configConfigcfg_fixed_seedcfg_max_test_size cfg_num_testslens_num_testslens_max_test_sizelens_fixed_seedrununiformquickCheckTestNormPrunercfg_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' mostGeneralRejectedAccepted result_propsSchemas sc_instancessc_instantiated sc_classessc_emptysc_instantiate_singletonsc_useclassesuse instances instantiated instance_ exploreIninstantiateRep instantiate generalitymkVar mostSpecificallUnificationsPolyMunPolyMUniverse univ_typesPolyFun fun_originalfun_specialised Polymorphic pm_schemas pm_universeschemasunivpolyFunpolyTerm exploreNoMGU regeneralisetypeInstancesList typeInstances intersectionuniverse inUniverseusefulForUniverseWithConstructorNormal ConstructorClassification PredicateSelectorFunction clas_pred clas_index clas_trueclas_selectorsclas_test_caseclassify ConditionalsconditionalsUniverserunConditionalspredTypeconsiderPredicateconsiderConditionalisingconditionallyRedundantconditionallyRedundant' addPredicateconditionalise Enumerator enumerate mapEnumeratorfilterEnumeratorenumerateConstantsenumerateApplicationsfilterUniverse sortTermspPrintSignatureprettyDefinitionprettyACdisambiguatePropType tc_eval_vartc_test_result GHC.ClassesOrdTest.QuickCheck.PropertyEqarbitraryTestCasearbitraryValuationarbitraryObserverarbitraryFunction evalHaskellWarningswarn_no_observerwarn_no_generatorcfg_print_stylecfg_print_filtercfg_backgroundcfg_infer_instance_typescfg_default_to cfg_constants cfg_instancescfg_max_commutative_size cfg_max_sizecfg_tweecfg_quickCheckTestCaseWrappedunTestCaseWrapped PredicateableuncrryPredicateTestCaseConstant con_classifycon_sizecon_constraintscon_type con_value con_stylecon_nameOrdyNamesgetNamesWrappedObserveData ObserveDataUse NoWarnings OrdInstance baseInstances observeOrdobserveFunction observeObsbaseTypenames findGeneratorfindOrdInstance findObservermakeQuickcheckFun constant'isOp selectorsunhideConstraint evalConstanttruetrueTermlens_quickCheck lens_twee lens_max_sizelens_max_commutative_sizelens_instanceslens_constantslens_default_tolens_infer_instance_typeslens_backgroundlens_print_filterlens_print_style defaultConfig instanceTypeswarningsBool||&&notTrueFalseGHC.Num+IntGHC.Base++.idmap