G}-      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $%&'()*+,None-./0123./0123-./0123Safe456789:;<=>?@ABC44NoneDIn microsecondsEQReturns Nothing if value cannot be evaluated to WHNF in a given number of secondsDEFGHIEFGHIDEFGHINoneJKLMNOPQJKLMNOPQJKLMNOPQSafeRxs +- 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")STUVWXYZ[\]^_`abcdefghiRjklmnopqrstuvwxyz*{STUVWXYZ[\]^_`abcdefghiRjklmnopqrstuvwxyz)STUVWXYZ[\]^_`abcdefghiRjklmnopqrstuvwxyz]5Safe|HFor a given type, return all *-kinded types. (all non-function types) KtypesIn (typeOf (undefined :: (Int -> Int) -> Int -> Bool)) == [Bool,Int] }|~7}|~ }|~Safe'Check if a function / operator is infix aisInfix "foo" == False isInfix "(+)" == False isInfix "`foo`" == True isInfix "+" == True3Returns the precedence of default Haskell operatorsIs the string of the form string3Transform an infix operator into an infix function: 3toPrefix "`foo`" == "foo" toPrefix "+" == "(+)"USafe               None.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  !"%#&'$()* !)  !"%#&'$()*None+,-./0123456789+,-./0123456789+,-./0123456789.8Safe:;<=>?@:;<=>?@:;<=>?@SafeAFrom hue, chroma and minFBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{A|}~>BCDEIKLMNOPQRSTUVWXYZ[\]^_`abcdefghijmnopqrstuvwxyz{A|}~EBCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{A|}~None56789:;<=>?@{ABC./01234EFGHIJKLMNOPQSTUVWXYZ[\]^_`abcdefghiRjklmnopqrstuvwxyz}|~      !)+,-./0123456789Nonepick 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[\]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))^_`^_`_^`^_`Nonee 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.abcdefghijklmnopqrabcdefghijklmnopqracdefbghijklmnoqprabcdefghijklmnopqrNone s[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]t4List 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)] ]uCList all possible variable bindings and valuations to an expression DgroundAndBinds ti e == zipWith (,) (grounds ti e) (groundBinds ti e)v6Are two expressions equal for a given number of tests?wTAre two expressions equal under a given condition for a given number of tests?xtAre two expressions equal under a given condition for a given number of tests and a minimum amount of testsyCAre two expressions less-than-or-equal for a given number of tests?z:Are two expressions less-than for a given number of tests?{[Are two expressions inequal for *all* variable assignments? Note this is different than  not . equal.|:Is a boolean expression true for all variable assignments?}: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 stuvwxyz{|}~ stuvwxyz{|}~ stuvyz{|wx}~ stuvwxyz{|}~None}  !"#$%&'()*+,-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|,None13 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  444 None"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 .B     00;     4 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{|}~ !"# !"# !"#None$$$$None%[Calls Speculate. See the example above (at the top of the file). Its only argument is an  structure.% !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST UVWXYZ[\]^_`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 : ; < = > ? @ ABCDEFGHIJKLMNOPQRSTeSTUSTVSTWSTXSTYSTZST[S\]S\^S\_S\` ab ac acdefghijklmnopqrstuvwxyz{|}~  ! !S\      ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! ! !      S\                                                         ! " # $ % & '( )* )+ ,k ,-./0123456789:;<=>?@AB CD CE CF CG CHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ ) , ,W      ! "#$ % &  ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < =>?@ABCDBCfBCEBCFBGHBGIBGJBGKBGLBGMBGNBGOBGPBGQBGRBGSBGTBUVBUWBUXBUYBZ[BZ\BC]BC^BC_BC`BCaBCbBCcBCdBCeBCfBCgBChBCiBCjBCkBClBCmBCnBCoBCpBCqBCrBCsBCtBCuBCvBCwBCxBCyBCzB{|B{}B{~B{B{B{B{BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB&speculate-0.2.2-L1gyTyzPATV8aGGlnrC18ITest.Speculate.Expr.TypeInfoTest.Speculate.Expr.CoreTest.Speculate.Expr.MatchTest.Speculate.Expr.CanonTest.Speculate.Expr.EquateTest.Speculate.Expr.GroundTest.Speculate.ArgsTest.Speculate.SanityTest.Speculate.Reason.OrderTest.Speculate.ReasonTest.Speculate.SemiReasonTest.Speculate.CondReasonTest.Speculate.EngineTest.Speculate.ReportTest.SpeculateTest.Speculate.MiscTest.Speculate.Utils.MemoizeTest.Speculate.Utils.OrdTest.Speculate.Utils.TimeoutTest.Speculate.Utils.TiersTest.Speculate.Utils.ListTest.Speculate.Utils.TypeableTest.Speculate.Utils.StringTest.Speculate.Utils.Tuple Test.Speculate.Utils.PrettyPrintTest.Speculate.Utils.MiscTest.Speculate.Utils.ClassTest.Speculate.Utils.ColourTest.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 isListablefindInfonamestiersEeqEltEleEpreludeInstancesdefNamescanonicalizeWith canonicalize canonicalWithequation phonyEquation unEquation isEquationuselessEquationusefulEquation comparisonLT comparisonLE unComparison implication unImplicationusefulImplicationconditionalEquationunConditionalEquationusefulConditionalEquationconditionalComparisonLEconditionalComparisonLTunConditionalComparisongrounds groundBindsgroundAndBindsequal condEqual condEqualM lessOrEquallessinequaltrue trueBinds trueRatiofalseArgsmaxSizemaxTests constants instances maxSemiSize maxCondSizemaxVars showConstants showEquationsshowSemiequationsshowConditionsshowConstantLawsminTests maxConstantsmaxDepth showTheoryshowArgsshowHelp evalTimeoutforceextraexclude onlyTypesshowClassesForshowDotquietDotargscomputeMaxSemiSizecomputeMaxCondSizecomputeInstancesshouldShowEquationshouldShowConditionalEquationkeepExprreallyShowConditionsatomstypestimeout compareExpr foreground background prepareArgsgetArgseqErrors ordErrors eqOrdErrorsinstanceErrors|>|>|kboByweight weightExceptgtExcept|>dwoByThyrules equations canReduceTocompareE closureLimitkeepEokThy updateRulesByupdateEquationsBy|==|emptyThykeepUpToLength keepMaxOf normalize normalizeEisNormal reductions1 reductionsOnormalizedCriticalPairs criticalPairs equivalentequivalentInstanceinsertappend differencecompletededuceorientdeletesimplifycomposecollapsecanonicalizeEqn canonicalEqn canonicalRuleprintThyshowThy prettyThyfinalizetheorize theorizeBy initialize defaultKeepdiscardRedundantEquations$fEqThyShy sequationssthyEquationemptyShyupdateSemiEquationsBymapSemiEquations scompareElessergreater simplerThantransConsequenceupdateSEquationsBy stheorizesides prettyShycanonicalizeShyWithcanonicalizeSemiEquationWithChy cequations cimplicationscclassesunThyemptyChyupdateCEquationsBy listImplied listImplieslistEquivalentreduceRootWithreductions1With creductions1 cnormalize cequivalent cIsInstanceOfcinsertcfiltercdiscardcdelete cfinalizecanonicalizeCEqncanonicalizeCEqnWithcanonicalCEqnBy canonicalCEqn prettyChy vassignments expansions mostGeneral mostSpecifictheoryFromAtoms!theoryAndRepresentativesFromAtomsconsiderdistinctFromSchemasclassesFromSchemasequivalencesBetweensemiTheoryFromThyAndRepsconditionalTheoryFromThyAndRepsconditionalEquivalencessubConsequencepsortByreport speculate functions1 functions2 functions3 functions4fillings expressionsOfvaluedExpressionsOf defaultMemory withMemory withMemory2memorymemory2 memoryFor memory2For compareIndexghc-prim GHC.Classes>=minmax><<=compare GHC.TypesOrderingLTEQGTData.Ord comparingDownusTimeoutToNothingtimeoutToNothing fromTimeouttimeoutToFalse timeoutToTruetimeoutToError productsList mapTMaybediscardT partitionTuptoTfilterTS discardTS discardLaterT+- pairsThatcountcountscountsByfirstsnubSort nubSortBy nubMergeBy nubMergeOnnubMerge+++ordIntersectBy ordIntersect nubMerges nubMergeMap orderedBy orderedOnorderedstrictlyOrderedOnstrictlyOrderedareAllareAnyallLatergroupOn collectOn collectBy collectWithcollectSndByFstdiscard discardLaterdiscardEarlier discardOthersdiscardByOthers allUniquechainzipWithReverse medianatetakeGreaterHalfaccumpartitionByMarkers Data.OldListsortOntypesIntyArity 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.ProxyProxyisInfixprecisInfixedPrefixtoPrefixunquoteatomicouternmostPrecisPrefixprime primeCyclenamesFromTemplate alignRight alignLeftindent splitAtCommas Data.StringIsString fromStringCharunwordswordsunlineslines 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.BaseStringfst3snd3trd3fst4snd4trd4fth4curry3curry4uncurry3uncurry4uncurry5uncurry6uncurry7uncurry8uncurry9 uncurry10 uncurry11 uncurry12***catPairs Data.Tuplefstsndswapuncurrycurrybesideabovetablefit maxLengthfitR normalizeR normalizeToremoveTrailingspaces isntSpace undefined1 undefined2issthnreportCountsBybell maybesToMaybemaybe2 iterateUntiliterateUntilLimit showRatiopercentputLines.:..:ClassmaprepfromRepmergesOn mergesThatmergefromHCMColorColourRGBshowRGBhexRatiohex coerceNum coerceRatiomod1modulofrac.+..-..*.blackwhiteredgreenbluecyanmagentayellowvioletorangelime aquamarineazureindigogreygrey1grey2grey3grey4grey5grey6grey7grey8grey9makeGreyrgbcmymaximinichromahue0hue intensityvalue lightness saturation saturationHSV saturationHSL saturationHSIfromRGBfromCMYfromHSVfromHSLfromHCLmixmixHSVprimary'primary secondarytertiaryisGreynotGrey isOppositeTo $fNumColour $fShowColourpickDigraphemptysuccspredsisNodeisEdgefiltersubgraph invsubgraph fromEdgesnarrowShowJustNothingrepVars compareTylexicompareConstants isConstantfindBupdateAssignmentsins1name findInfoOrallAbout shouldShow2 shouldShow3foregroundConstantsbackgroundConstants allConstantsaboutnotAbout&cmdargs-0.10.14-CJAOGiZkh3OIu1n8WPqRj9System.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.Processprocess$System.Console.CmdArgs.Explicit.TypeflagBoolflagArgflagReqflagOptflagNonemodesmode modeEmpty remapUpdateremap2 checkMode fromFlagOpt modeFlags modeModestoGroup fromGroup parseBoolNameHelpFlagHelpGroup groupUnnamed groupHidden groupNamedModemodeGroupModes modeNames modeValue modeCheck modeReform modeExpandAtmodeHelpmodeHelpSuffixmodeArgsmodeGroupFlagsFlagInfoFlagReqFlagOpt FlagOptRareFlagNoneUpdateFlag flagNamesflagInfo flagValueflagTypeflagHelpArgargValueargType argRequireRemapremap,System.Console.CmdArgs.Explicit.ExpandArgsAt expandArgsAt)System.Console.CmdArgs.Explicit.SplitJoin splitArgsjoinArgs-==>--&&->=\/dropEqRule compareEqnmapRules mapEquations ruleFilter reduceRootgroundJoinableoverlapsclosurecompleteVerbosedeleteEquivalentdeleteGroundJoinablecanonicalizeThycanonicalizeThyWithcanonicalizeEqnWithcanonicalizeRulecanonicalizeRuleWith discardRedundantRulesByEquationsvassignmentsEqnreholerepresentativesFromAtomsexpandclassesFromSchemaputArgswarnMissingInstancesreportClassesFor reportDot&leancheck-0.6.0-8thySoWzbQu9g5WkkzOyhHTest.LeanCheck.CoreTestablelisttiersTest.LeanCheck.TierssetsOfsetConsproductsproductMaybeWith product3With normalizeT noDupListsOf noDupListCons listsOfLengthlistsOfdeleteTbagsOfbagConsTest.LeanCheck.IOcheckResultFor checkResultcheckForcheckTest.LeanCheck.DerivederiveListableCascadingderiveListable witnesseswitnesstoTierstiersFractionalsuchThatresults productWithofWeightmapT listIntegralholdsfilterTfailsexistscounterExamplescounterExamplecons5cons4cons3cons2cons1cons0concatT concatMapT addWeight\\//\/><==>+|Test.LeanCheck.Basiccons9cons8cons7cons6cons12cons11cons10Test.LeanCheck.Utils.TypesWord4unWord4Word3unWord3Word2unWord2Word1unWord1UInt4UInt3UInt2UInt1Nat7unNat7Nat6unNat6Nat5unNat5Nat4unNat4Nat3unNat3Nat2unNat2Nat1unNat1NatunNatInt4unInt4Int3unInt3Int2unInt2Int1unInt1 Test.LeanCheck.Utils.TypeBindingunduint4uint3uint2uint1stringnatmaybintegerint4int3int2int1intfloateithdoublecharbool>-->>>:->>:>->>:->:>->:-:>-:Test.LeanCheck.Utils.Operators||||||||= transitive totalOrder symmetric2 symmetricstrictTotalOrderstrictPartialOrder reflexive partialOrderokOrdokEqOrdokEq neverIdentity irreflexiveidentity idempotent equivalence distributive commutative asymmetric associative antisymmetric=|========$&&&&&&&$=fistfist2fist3fist4