G}-      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $%&'()*+,Safe-./0123456789:;<=>?@ABCDEF-./0123456789:;<=>?@A-./0123456789:;<=>?@ANoneGIn microsecondsHQReturns Nothing if value cannot be evaluated to WHNF in a given number of secondsGHIJKLHIJKLGHIJKLNoneMNOPQRSTMNOPQRSTMNOPQRSTSafeU'Check if a function / operator is infix aisInfix "foo" == False isInfix "(+)" == False isInfix "`foo`" == True isInfix "+" == TrueV3Returns the precedence of default Haskell operatorsWIs the string of the form stringX3Transform an infix operator into an infix function: 3toPrefix "`foo`" == "foo" toPrefix "+" == "(+)"YZ[UV\WX]^_`abcUdefghijklmnopqrstuvwxyz{|}~YZ[UV\WX]^_`abcYZ[UV\WX]^_`abcSafeNoneSafexs +- ys superimposes xs over ys. 1,2,3%+- [0,0,0,0,0,0,0] == [1,2,3,0,0,0,0]x,y,zU+- [a,b,c,d,e,f,g] == [x,y,z,d,e,f,g] "asdf" +- "this is a test" == "asdf is a test")*)5None8None.Appends two Strings side by side, line by line =beside ["asdf\nqw\n","zxvc\nas"] == "asdfzxvc\n\ \qw as\n"JAppend two Strings on top of each other, adding line breaks *when needed*.Formats a table. Examples: table "l l l" [ ["asdf", "qwer", "zxvc\nzxvc"] , ["0", "1", "2"] , ["123", "456\n789", "3"] ] == "asdf qwer zxvc\n\ \ zxvc\n\ \0 1 2\n\ \123 456 3\n\ \ 789\n" table "r l l" [ ["asdf", "qwer", "zxvc\nzxvc"] , ["0", "1", "2"] , ["123", "456\n789", "3"] ] == "asdf qwer zxvc\n\ \ zxvc\n\ \ 0 1 2\n\ \ 123 456 3\n\ \ 789\n" table "r r l" [ ["asdf", "qwer", "zxvc\nzxvc"] , ["0", "1", "2"] , ["123", "456\n789", "3"] ] == "asdf qwer zxvc\n\ \ zxvc\n\ \ 0 1 2\n\ \ 123 456 3\n\ \ 789\n";Fits a list to a certain width by appending a certain value fit ' ' 6 "str" == "str "  fit 0 6 [1,2,3] == [1,2,3,0,0,0]:normalize makes all list the same length by adding a value @normalize ["asdf","qw","er"] == normalize ["asdf","qw ","er "]0Given a list of lists returns the maximum length  SafeHFor a given type, return all *-kinded types. (all non-function types) KtypesIn (typeOf (undefined :: (Int -> Int) -> Int -> Bool)) == [Bool,Int]      7 !"#$%&'()*+,-./0123456789           Safe:From hue, chroma and minF;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst:uvwxyz{|}~>;<=>BDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcfghijklmnopqrst:uvwxyz{|}E;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst:uvwxyz{|}~SafeNoneBCdef !"#$%&'()*+,-./0123456789ghijklmnopqrstuvwxyz{|}~DEF-./0123456789:;<=>?@AHIJKLMNOPQRSTYZ[UV\WX]^_`abc     Nonepick a node in a Digraph   NoneJAn encoded Haskell functional-application expression for use by Speculate.Encode a constant Haskell expression for use by Speculate. It takes a string representation of a value and a value, returning an  . Examples: constant "0" 0 constant "'a'" 'a' constant "True" True constant "id" (id :: Int -> Int) constant "(+)" ((+) :: Int -> Int -> Int) constant "sort" (sort :: [Bool] -> [Bool])A shorthand for  to be used on values that are  instances. Examples: yshowConstant 0 = constant "0" 0 showConstant 'a' = constant "'a'" 'a' showConstant True = constant "True" True var "x" (undefined :: Ty) returns a variable of type Ty named "x" (intended for advanced users)hole (undefined :: Ty) returns a hole of type Ty@By convention, a Hole is a variable named with the empty string.  an $ application if the types match,  otherwise.)Compare two expressiosn lexicographicallyd1st their type arity; 2nd their type; 3rd var < constants < apps 4th lexicographic order on namesCompares two expressions first by their complexity: 1st length; 2nd number of variables (more variables is less complex); 3nd sum of number of variable occurrences; 4th their depth; 5th normal .Compares two expressions first by their complexity: 1st length; 2nd number of variables (more variables is less complex); 3nd sum of number of variable occurrences; 4th their depth; 5th lexicompare.G the value of an expression when possible (correct type, no holes),  otherwise.eEvaluates an expression when possible (correct type, no holes). Returns a default value otherwise.tThe type of an expression. This raises errors, but those should not happen if expressions are smart-constructed.zetyp returns either: the Right type a Left expression with holes with the structure of the I'll typed expressionType arity of an 4List types holes (unamed variables) in an expression$List all variables in an expression.?List all variables in an expression, in order, with repetitions"GList terminal constants in an expression. This does not repeat values.#BReturns the length of an expression. In term rewriting terms: |s|$+Returns the maximum depth of an expression.%ONumber of occurrences of a given variable name. In term rewriting terms: |s|_x)-Non-variable sub-expressions of an expression#This includes the expression itself*RSub-expressions of an expression including variables and the expression itself.+Is a subexpression of.FMake substitutions on subexpressions, variables have to match exactly!-Unfold function application: ((((f :$ e1) :$ e2) :$ e3) = [f,e1,e2,e3]3  !"#$%&'()*+,-./0+  !"#$%&'()*+,-+ " )*+!-,#$%&'( 0  !"#$%&'()*+,-./0None2Fill holes in an expression. Silently skips holes that are not of the right type. Silently discard remaining expressions.35Assign all occurences of a variable in an expression.Examples in pseudo-Haskell: iassign "x" (10) (x + y) = (10 + y) assign "y" (y + z) ((x + y) + (y + z)) = (x + (y + z)) + ((y + z) + z)eThis respects the type (won't change occurrences of a similarly named variable of a different type).4=Assign all occurrences of several variables in an expression.+For single variables, this works as assign: sx + y `assigning` [("x",10)] = (10 + y) ((x + y) + (y + z)) `assigning` [("y",y+z)] = (x + (y + z)) + ((y + z) + z) Note this is not equivalent to foldr (uncurry assign)E. Variables inside expressions being assigned will not be assigned.5"Substitute matching subexpressios.Tsub (x + y) 0 ((x + y) + z) == (0 + z) sub (x + y) 0 (x + (y + z)) == (x + (y + z))6)Primeify variable names in an expression. renameBy (++ "'") (x + y) = (x' + y') renameBy (++ "'") (y + (z + x)) = (y' + (z' + x')) renameBy (++ "1") abs x = abs x1 renameBy (++ "2") abs (x + y) = abs (x2 + y2)Note this will affect holes!7List matches if possible 0 + 1 `match` x + y = Just [x=0, y=1] 0 + (1 + 2) `match` x + y = Just [x=0, y=1 + 2] 0 + (1 + 2) `match` x + (y + y) = Nothing (x + x) + (1 + 2) `match` x + (y + y) = Nothing80List matches of pairs of expressions if possible M(0,1) `match2` (x,y) = Just [x=0, y=1] (0,1+2) `match2` (x,y+y) = Nothing9'List matches with preexisting bindings: [0 + 1 `matchWith [(x,0)]` x + y = Just [x=0, y=1] 0 + 1 `matchWith [(x,1)]` x + y = Nothing123456789:;<=>?123456789:;<=>?123456789:;<=>?123456789:;<=>?None@1Type information needed to Speculate expressions.ANType information needed to Speculate expressions (single type / single class).Usage: ins1 "x" (undefined :: Type)!@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]!@ABCEDFGHIJKLMNOPQRSTUVWXYZ[\]!@ABCDEGHLIMJKNFVWYOR[ZPSQTXU\]@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]Noneb Given an equation encoded as an A. Checks if both sides of an equation are the same. If the * is not an equation, this raises an error.^_`abcdefghijklmno^_`abcdefghijklmno^`abc_defghijklnmo^_`abcdefghijklmnoNone p[List all possible valuations of an expression (potentially infinite). In pseudo-Haskell: \take 3 $ grounds preludeInstances ((x + x) + y) == [(0 + 0) + 0, (0 + 0) + 1, (1 + 1) + 0]q4List all possible variable bindings to an expression take 3 $ groundBinds preludeInstances ((x + x) + y) == [ [("x",0),("y",0)] , [("x",0),("y",1)] , [("x",1),("y",0)] ]rCList all possible variable bindings and valuations to an expression DgroundAndBinds ti e == zipWith (,) (grounds ti e) (groundBinds ti e)s6Are two expressions equal for a given number of tests?tTAre two expressions equal under a given condition for a given number of tests?utAre two expressions equal under a given condition for a given number of tests and a minimum amount of testsvCAre two expressions less-than-or-equal for a given number of tests?w:Are two expressions less-than for a given number of tests?x[Are two expressions inequal for *all* variable assignments? Note this is different than  not . equal.y:Is a boolean expression true for all variable assignments?z:List variable bindings for which an expression holds true.{YUnder a maximum number of tests, returns the ratio for which an expression holds true.|BIs an expression ALWAYS false? This is *NOT* the same as not true pqrstuvwxyz{| pqrstuvwxyz{| pqrsvwxy|tuz{ pqrstuvwxyz{|None}-Canonicalize variable names in an expression. canonicalize (x + y) = (x + y) canonicalize (y + x) = (x + y) canonicalize (y + (z + x)) = (x + (y + z)) canonicalize ((w + z) + (z + x)) = ((x + y) + (y + z)) canonicalize (y + abs y) = (x + abs x) canonicalize ((y + x) == (x + y)) = ((x + y) == (y + x))}~}~~}}~None}  !"#$%&'()*+,-123456789:;<=>?@ABCEDFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None;Greater than or equal number of occurences of each variable:Strict order between expressions as defined in TRAAT p103. 7s > t iff |s| > |t| and , for all x in V, |s|_x > |t|_x=This is perhaps the simplest order that can be used with KBC.GStrict order between expressions loosely as defined in TRAAT p124 (KBO) Reversed K >| for Knuth, sorry Bendix.Weight function for kboBy:Variables weigh 1-Nullary functions weigh 1 (a.k.a. constants)N-ary functions weigh 0Unary functions weigh 1This is the weight when using .Weight function for kboBy:Variables weigh 1-Nullary functions weigh 1 (a.k.a. constants)N-ary functions weigh 0>Unary functions weigh 1 except for the one given as argument!To be used alongside weightExcept.Dershowitz reduction order as defined in TRAAT|> a D for Dershowitz  444None"should be compatible with compareE$total order used to "sort" equationsQFinalize a theory by discarding redundant equations. If after finalizing you ), redundant equations might pop-up again.This instance is as efficient as it gets, but, this function will not detect equality when rules and equations are in a different order (or repeated). See .B00;4 None13 Nonegiven a semi-equation (inequality), simplerThan restricts the Shy (SemiTheory) into only equations simpler than the given semi-equation or that are instances of simpler equations.half-baked example:x + 1 is simpler than x + y and it is returned.  (1 + 1) + 1 is more complex than x + y5 but it is returned as well as it is an instance of x + 1. None NoneOList all relevant variable assignments in an expresssion. In pseudo-Haskell: vassignments (0 + x) == [0 + x] vassignments (0 + 0) == [0 + 0] vassignments (0 + _) == [0 + x] vassignments (_ + _) == [x + x, x + y] vassignments (_ + (_ + ord _)) == [x + (x + ord c), x + (y + ord c)]sYou should not use this on expression with already assinged variables (undefined, but currently defined behavior): 'vassignments (ii -+- i_) == [ii -+- ii]:List the most general assignment of holes in an expression;List the most specific assignment of holes in an expression!Is the equation a consequence of substitution? > subConsequence (x == y) (x + y) (x + x) == True > subConsequence (x <= y) (x + y) (x + x) == False -- not sub > subConsequence (abs x == abs y) (abs x) (abs y) == True > subConsequence (abs x == 1) (x + abs x) (20) == False (artificial)  !"#$%&'()*+,-123456789:;<=>?@ABCEDFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ NoneArguments to Speculate&maximum size of considered expressions#maximum number of test for each law0constants considered when generating expressions#typeclass instance information for Eq, Ord and Listable#maximum size of inqualities RHS/LHS$maximum size of considered conditionMmaximum number of variables allowed in inequalities and conditional equationsrepeat constants on outputwhether to show equationswhether to show inequalties%whether to show conditional equations&whether to show laws with no variables(intermediary)` minimum number of tests for passing postconditions in function of maximum number of tests(intermediary)A maximum nubmer of constants allowed when considering expressions(intermediary)( maximum depth of considered expressions (debug) whether to show raw theory (debug) show _this_ args before running  (advanced)& whether to show the command line help  (advanced)+ timeout when evaluating ground expressions  (advanced) ignore errors (advanced) unused, user-defined meaning (advanced)3 exclude this symbols from signature before running (advanced)? only allow those types at top-level equations / semi-equations (advanced)( show equivalence classes of expressions (advanced)7 whether to show a Graphviz dotfile with an Ord lattice (advanced)F whether to show a Graphviz dotfiel with an Ord lattice (less verbose)Default arguments to SpeculateZAre all constants in an expression about a list of constants? Examples in pseudo-Haskell: lx + y `allAbout` [(+)] == True x + y == z `allAbout` [(+)] == False x + y == z `allAbout` [(+),(==)] == True  A special  value. When provided on the - list, makes all the following constants   constants.! A special  value. When provided on the , list, makes all the following constants !g constants. Background constants can appear in laws about other constants, but not by themselves.4      !"#|           !"#,      !#"      !"#None$$$$None%[Calls Speculate. See the example above (at the top of the file). Its only argument is an  structure.% !"#$%&'()*+,-./0123456789 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ @GHILMW      !#$%-%       !@GHILMW$#%None+HGiven a list of atomic expressions, enumerate experssions by applicationNOTE: for now, very inneficientUThis function exists solely for documentation and will never actually be useful, as: mapT fst $ classesRWill return as expressions that are semantially different (and is more efficient)7Eventually this function will be removed from Speculate,]Given a list of atomic expressinos, enumerated expressions of a given type by application.#Never will be actually useful, see +.7Eventually this functino will be removed from Speculate &'()*+,&'()*+,&'()*+, &'()*+, !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                        ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_ `a `b `c `d `efghijklmnopqrstuvwxyz{|}~                                                                    k e          !"#$%&'()*+,-./01234 !5 !67 89 8: 8; 8< 8= !> !? !@ !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 ![ !\ !] ^_ ^` ab abcdefghijklmnopqrstuvwxyz{|}~   W                     !!"#$%&'()*+,-./012234567889:;<=>?@ABCDBCEBCFBCGBCHBCIBCJBCKBCLBCMBCNBCOBCPBCQBCRBCSBCTBCUBCVBCWBCXBCYBCZBC[BC\BC]BC^B_`B_`B_aB_bB_bB_cB_dB_dB_eB_fB_fB_gB_hB_hB_iB_jB_jB_kB_lB_lB_mB_nB_nB_oB_pB_pB_qB_rB_rB_sB_tB_tB_uB_vB_vB_wB_xB_xB_yB_zB_zB_{B_|B_|B_}B_~B_~B_B_B_B_B_BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBfBBB&speculate-0.2.0-E2XLTTHZNFE1j1hoeB8DXfTest.Speculate.Expr.TypeInfoTest.Speculate.Expr.CoreTest.Speculate.Expr.MatchTest.Speculate.Expr.EquateTest.Speculate.Expr.GroundTest.Speculate.Expr.CanonTest.Speculate.Reason.OrderTest.Speculate.ReasonTest.Speculate.SanityTest.Speculate.SemiReasonTest.Speculate.CondReasonTest.Speculate.EngineTest.Speculate.ArgsTest.Speculate.ReportTest.SpeculateTest.Speculate.MiscTest.Speculate.Utils.TupleTest.Speculate.Utils.TimeoutTest.Speculate.Utils.TiersTest.Speculate.Utils.StringTest.Speculate.Utils.OrdTest.Speculate.Utils.MemoizeTest.Speculate.Utils.ListTest.Speculate.Utils.Misc Test.Speculate.Utils.PrettyPrintTest.Speculate.Utils.TypeableTest.Speculate.Utils.ColourTest.Speculate.Utils.ClassTest.Speculate.UtilsTest.Speculate.Utils.DigraphTest.Speculate.ExprbaseData.Typeable.InternalTypeRepboolTymkEqnTyExprConstantVar:$constant showConstantvarholeholeOfTy$$ showsPrecExpr showsOpExpr showOpExpr showPrecExprshowExpreqExprCommuting lexicompareBy lexicomparecompareComplexityThencompareComplexityfalseEevaluateevaltypetyp typeCorrectarityholesvarsatomicConstantshasVarconstslengthEdepthEcountVar countVarsunrepeatedVars isAssignmentsubexprs subexprsVisSubisConstantNamed unfoldApp $fOrdExpr$fEqExpr $fShowExprBindsfillassign assigningsubrenameBymatchmatch2 matchWithunify unification isInstanceOf hasInstanceOfisCanonInstanceOfhasCanonInstanceOf InstancesInstanceEqOrdListableNames instanceTypeinseqordeqOrdlistableeqWithordWith listableWithisEqisOrdisEqOrdisEqEisOrdEisEqOrdE isListablefindInfonamestiersEeqEltEleEpreludeInstancesdefNamesequation phonyEquation unEquation isEquationuselessEquationusefulEquation comparisonLT comparisonLE unComparison implication unImplicationusefulImplicationconditionalEquationunConditionalEquationusefulConditionalEquationconditionalComparisonLEconditionalComparisonLTunConditionalComparisongrounds groundBindsgroundAndBindsequal condEqual condEqualM lessOrEquallessinequaltrue trueBinds trueRatiofalsecanonicalizeWith canonicalize canonicalWith|>|>|kboByweight weightExceptgtExcept|>dwoByThyrules equations canReduceTocompareE closureLimitkeepEokThy updateRulesByupdateEquationsBy|==|emptyThykeepUpToLength keepMaxOf normalize normalizeEisNormal reductions1 reductionsOnormalizedCriticalPairs criticalPairs equivalentequivalentInstanceinsertappend differencecompletededuceorientdeletesimplifycomposecollapsecanonicalizeEqn canonicalEqn canonicalRuleprintThyshowThy prettyThyfinalizetheorize theorizeBy initialize defaultKeepdiscardRedundantEquations$fEqThyeqErrors ordErrors eqOrdErrorsinstanceErrorsShy sequationssthyEquationemptyShyupdateSemiEquationsBymapSemiEquations scompareElessergreater simplerThantransConsequenceupdateSEquationsBy stheorizesides prettyShycanonicalizeShyWithcanonicalizeSemiEquationWithChy cequations cimplicationscclassesunThyemptyChyupdateCEquationsBy listImplied listImplieslistEquivalentreduceRootWithreductions1With creductions1 cnormalize cequivalent cIsInstanceOfcinsertcfiltercdiscardcdelete cfinalizecanonicalizeCEqncanonicalizeCEqnWithcanonicalCEqnBy canonicalCEqn prettyChy vassignments expansions mostGeneral mostSpecifictheoryFromAtoms!theoryAndRepresentativesFromAtomsconsiderdistinctFromSchemasclassesFromSchemasequivalencesBetweensemiTheoryFromThyAndRepsconditionalTheoryFromThyAndRepsconditionalEquivalencessubConsequencepsortByArgsmaxSizemaxTests constants instances maxSemiSize maxCondSizemaxVars showConstants showEquationsshowSemiequationsshowConditionsshowConstantLawsminTests maxConstantsmaxDepth showTheoryshowArgsshowHelp evalTimeoutforceextraexclude onlyTypesshowClassesForshowDotquietDotargscomputeMaxSemiSizecomputeMaxCondSizecomputeInstancesshouldShowEquationshouldShowConditionalEquationkeepExprreallyShowConditionsatomstypestimeout compareExpr foreground background prepareArgsgetArgsreport speculate functions1 functions2 functions3 functions4fillings expressionsOfvaluedExpressionsOffst3snd3trd3fst4snd4trd4fth4curry3curry4uncurry3uncurry4uncurry5uncurry6uncurry7uncurry8uncurry9 uncurry10 uncurry11 uncurry12***catPairs Data.TuplefstsndswapuncurrycurryusTimeoutToNothingtimeoutToNothing fromTimeouttimeoutToFalse timeoutToTruetimeoutToError productsList mapTMaybediscardT partitionTuptoTfilterTS discardTS discardLaterTisInfixprecisInfixedPrefixtoPrefixunquoteatomicouternmostPrecisPrefixprime primeCyclenamesFromTemplate alignRight alignLeftindent splitAtCommas Data.StringIsString fromStringghc-prim GHC.TypesChar Data.OldListunwordswordsunlineslines Data.Char isSeparatorisNumberisMarkisLetter digitToIntGHC.Read readLitChar lexLitChar GHC.UnicodetoTitletoUppertoLowerisLowerisUpperisPrint isControl isAlphaNumisAlphaisSymbol isPunctuation isHexDigit isOctDigitisDigitisSpace isAsciiUpper isAsciiLowerisLatin1isAsciigeneralCategoryGeneralCategoryFormatControlUppercaseLetterLowercaseLetterTitlecaseLetterModifierLetter OtherLetterNonSpacingMarkSpacingCombiningMark EnclosingMark DecimalNumber LetterNumber OtherNumberConnectorPunctuationDashPunctuationOpenPunctuationClosePunctuation InitialQuote FinalQuoteOtherPunctuation MathSymbolCurrencySymbolModifierSymbol OtherSymbolSpace LineSeparatorParagraphSeparator Surrogate PrivateUse NotAssignedGHC.CharchrGHC.Show intToDigit showLitCharGHC.BaseString compareIndex GHC.Classes>=minmax><<=compareOrderingLTEQGTData.Ord comparingDown defaultMemory withMemory withMemory2memorymemory2 memoryFor memory2For+- pairsThatcountcountscountsByfirstsnubSort nubSortBy nubMergeBy nubMergeOnnubMerge+++ordIntersectBy ordIntersect nubMerges nubMergeMap orderedBy orderedOnorderedstrictlyOrderedOnstrictlyOrderedareAllareAnyallLatergroupOn collectOn collectBy collectWithcollectSndByFstdiscard discardLaterdiscardEarlier discardOthersdiscardByOthers allUniquechainzipWithReverse medianatetakeGreaterHalfaccumpartitionByMarkerssortOn undefined1 undefined2issthnreportCountsBybell maybesToMaybemaybe2 iterateUntiliterateUntilLimit showRatiopercentputLines.:..:besideabovetablefit maxLengthfitR normalizeR normalizeToremoveTrailingspaces isntSpacetypesIntyArity finalResultTyunFunTy argumentTyresultTyfunTyConisFunTymkAppTyTypeableTyCon Data.Typeablegcast2gcast1gcasteqTcast rnfTypeRep showsTypeReptypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1typeOftypeRep typeRepArgs typeRepTyCon funResultTy splitTyConAppmkFunTy mkTyConApptypeRepFingerprintrnfTyConmkTyCon3tyConFingerprint tyConString tyConName tyConModule tyConPackage Typeable1 Typeable2 Typeable3 Typeable4 Typeable5 Typeable6 Typeable7Data.Type.Equality:~:Refl Data.ProxyProxyfromHCMColorColourRGBshowRGBhexRatiohex coerceNum coerceRatiomod1modulofrac.+..-..*.blackwhiteredgreenbluecyanmagentayellowvioletorangelime aquamarineazureindigogreygrey1grey2grey3grey4grey5grey6grey7grey8grey9makeGreyrgbcmymaximinichromahue0hue intensityvalue lightness saturation saturationHSV saturationHSL saturationHSIfromRGBfromCMYfromHSVfromHSLfromHCLmixmixHSVprimary'primary secondarytertiaryisGreynotGrey isOppositeTo $fNumColour $fShowColourClassmaprepfromRepmergesOn mergesThatmergepickDigraphemptysuccspredsisNodeisEdgefiltersubgraph invsubgraph fromEdgesnarrowShowJustNothingrepVars compareTylexicompareConstants isConstantfindBupdateAssignmentsins1name findInfoOr>=\/dropEqRule compareEqnmapRules mapEquations ruleFilter reduceRootgroundJoinableoverlapsclosurecompleteVerbosedeleteEquivalentdeleteGroundJoinablecanonicalizeThycanonicalizeThyWithcanonicalizeEqnWithcanonicalizeRulecanonicalizeRuleWith discardRedundantRulesByEquations-==>--&&-vassignmentsEqnreholerepresentativesFromAtomsexpandclassesFromSchemaallAbout shouldShow2 shouldShow3foregroundConstantsbackgroundConstants allConstantsaboutnotAbout&cmdargs-0.10.15-JRUcdKHDUbpIEkB6uA7BJdSystem.Console.CmdArgs.ExplicitflagsVerbosityflagNumericVersion flagVersionflagHelpFormatflagHelpSimple processValue processArgs$System.Console.CmdArgs.Explicit.HelphelpText HelpFormatHelpFormatDefault HelpFormatOne HelpFormatAllHelpFormatBash HelpFormatZsh(System.Console.CmdArgs.Explicit.CompleteComplete CompleteValue CompleteFile CompleteDir,System.Console.CmdArgs.Explicit.ExpandArgsAt expandArgsAt'System.Console.CmdArgs.Explicit.Processprocess)System.Console.CmdArgs.Explicit.SplitJoin splitArgsjoinArgs$System.Console.CmdArgs.Explicit.TypeflagBoolflagArgflagReqflagOptflagNonemodesmode modeEmpty remapUpdateremap2 checkMode fromFlagOpt modeFlags modeModestoGroup fromGroup parseBoolNameHelpFlagHelpGroup groupUnnamed groupHidden groupNamedModemodeGroupModes modeNames modeValue modeCheck modeReform modeExpandAtmodeHelpmodeHelpSuffixmodeArgsmodeGroupFlagsFlagInfoFlagReqFlagOpt FlagOptRareFlagNoneUpdateFlag flagNamesflagInfo flagValueflagTypeflagHelpArgargValueargType argRequireRemapremapputArgswarnMissingInstancesreportClassesFor reportDot&leancheck-0.6.1-LbCDkv8og849213l1Ftsyz Test.LeanCheck.Utils.TypeBindinguint4uint3uint2uint1int4int3int2int1nateithmaybstringcharbooldoublefloatintegerintund>-->>>:->>:>->>:->:>->:-:>-:Test.LeanCheck.Utils.TypesInt1unInt1Int2unInt2Int3unInt3Int4unInt4Word1unWord1Word2unWord2Word3unWord3Word4unWord4NatunNatNat1unNat1Nat2unNat2Nat3unNat3Nat4unNat4Nat5unNat5Nat6unNat6Nat7unNat7UInt1UInt2UInt3UInt4Test.LeanCheck.Utils.Operators|==|$==$okEqOrdokOrdokEq neverIdentityidentity idempotentstrictTotalOrder totalOrderstrictPartialOrder partialOrder equivalence asymmetric antisymmetric symmetric irreflexive reflexive transitive symmetric2 distributive associative commutative|||||||&&&&&&&=======Test.LeanCheck.Tiers listsOfLengthsetsOfbagsOf noDupListsOf normalizeTdeleteTproductslistsOfproductMaybeWith product3With noDupListConssetConsbagConsTest.LeanCheck.DerivederiveListableCascadingderiveListableTest.LeanCheck.Basiccons12cons11cons10cons9cons8cons7cons6Test.LeanCheck.IOcheckResultFor checkResultcheckForcheckTest.LeanCheck.Core==>existsfailsholdswitness witnessescounterExamplecounterExamplesresults productWith><\\//\/+|suchThat addWeightofWeightcons5cons4cons3cons2cons1cons0 concatMapTconcatTfilterTmapTtiersFractional listIntegraltoTierslisttiersTestablefistfist2fist3fist4