h$gM      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                 (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela  Safe-Inferred(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela  Safe-Inferred speculateFrom hue, chroma and min>(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela  Safe-Inferred & speculatexs +- ys superimposes xs over ys. 1,2,3%+- [0,0,0,0,0,0,0] == [1,2,3,0,0,0,0]x,y,z+- [a,b,c,d,e,f,g] == [x,y,z,d,e,f,g] "asdf" +- "this is a test" == "asdf is a test".  !"#$%&'()*+,-./0123456785(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None >  9:;<=>?@ABC ;<:?=>9@ABC(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None DEFGHI(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela  Safe-Inferred J(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneCK speculate.Appends two Strings side by side, line by line =beside ["asdf\nqw\n","zxvc\nas"] == "asdfzxvc\n\ \qw as\n"L speculateAppend two Strings on top of each other, adding line breaks *when needed*.M speculateFormats 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"KLMN(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela  Safe-Inferred]S speculate'Check if a function / operator is infix isInfix "foo" == False isInfix "(+)" == False isInfix "`foo`" == True isInfix "+" == TrueT speculate3Returns the precedence of default Haskell operatorsV speculateIs the string of the form stringW speculate3Transform an infix operator into an infix function: 3toPrefix "`foo`" == "foo" toPrefix "+" == "(+)"OPQRSTUVWXYZ[\(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela  Safe-Inferred ]^_`abcdefghi_8(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela Nonejklmn(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela Noneo speculateReturns Nothing if value cannot be evaluated to WHNF in a given number of secondsopqrs(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela  Safe-Inferredtuvwxyz{|}~(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None'  !"#$%&'()*+,-./012345678DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~]^_`abcdefghiKLMNtwuxvyz{|}~OPQRSUVWTX[YZ\  "!#$%&'()*+,-./012345678jklmnopqrsJFGHIDE(c) 2016 Colin Runciman$3-Clause BSD (see the file LICENSE) Rudy Matela NoneR (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None23& (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None  speculateList all possible valuations of an expression (potentially infinite). In pseudo-Haskell: take 3 $ grounds (lookupTiers preludeInstances) ((x + x) + y) == [(0 + 0) + 0, (0 + 0) + 1, (1 + 1) + 0]4Note this function will return an empty list when a  instance is not found in the  list. speculate4List all possible variable bindings to an expression take 3 $ groundBinds (lookupTiers preludeInstances) ((x + x) + y) == [ [("x",0),("y",0)] , [("x",0),("y",1)] , [("x",1),("y",0)] ] speculate6Are two expressions equal for a given number of tests? speculateAre two expressions equal under a given condition for a given number of tests? speculateAre two expressions equal under a given condition for a given number of tests and a minimum amount of tests speculateAre two expressions less-than-or-equal for a given number of tests? speculate:Are two expressions less-than for a given number of tests? speculateAre two expressions inequal for *all* variable assignments? Note this is different than  not . equal. speculateUnder a maximum number of tests, returns the ratio for which an expression holds true. speculate:Is a boolean expression true for all variable assignments? speculateIs an expression ALWAYS false? This is *NOT* the same as not true.  (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None!y  9:;<=>?@ABC(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None#13(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None) speculate: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. speculateStrict order between expressions loosely as defined in TRAAT p124 (KBO) Reversed K >| for Knuth, sorry Bendix. speculateWeight 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 . speculateWeight 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 speculate!To be used alongside weightExcept speculate.Dershowitz reduction order as defined in TRAAT|> a D for Dershowitz&This is not a simplification order on   s. speculateReturns  when an  5ession has either a functional type or functional iables. funny xx = False funny one = False funny idE = True funny (ff one) = True speculateReturns  when an  :ession has no functional return type and no functional iables. serious xx = True serious one = True serious idE = False serious (ff one) = False  444 (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None,+ speculate"should be compatible with compareE speculate$total order used to "sort" equations speculateFinalize a theory by discarding redundant equations. If after finalizing you ), redundant equations might pop-up again. speculateThis 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 ...4 (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None/ speculategiven 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. (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None/ (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None0 (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None6 speculateList all variable assignments for a given type and list of variables. speculateList all variable assignments for a given number of variables. It only assign variables to holes (variables with "" as its name). > expansions preludeInstances 2 '(_ + _ + ord _) [ (x + x) + ord c :: Int , (x + x) + ord d :: Int , (x + y) + ord c :: Int , (x + y) + ord d :: Int , (y + x) + ord c :: Int , (y + x) + ord d :: Int , (y + y) + ord c :: Int , (y + y) + ord d :: Int ] speculate4Computes a theory from atomic expressions. Example: > theoryFromAtoms 5 compare (const True) (equal preludeInstances 100) > [hole (undefined :: Int),constant "+" ((+) :: Int -> Int -> Int)] Thy { rules = [ (x + y) + z == x + (y + z) ] , equations = [ y + x == x + y , y + (x + z) == x + (y + z) , z + (x + y) == x + (y + z) , z + (y + x) == x + (y + z) ] , canReduceTo = (|>) , closureLimit = 2 , keepE = keepUpToLength 5 } speculateGiven atomic expressions, compute theory and representative schema expressions. speculateIs 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)  9:;<=>?@ABC(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela None3C! speculateArguments to Speculate speculate&maximum size of considered expressions speculate#maximum number of test for each law speculate0constants considered when generating expressions speculate#typeclass instance information for Eq, Ord and Listable speculate#maximum size of inqualities RHS/LHS speculate$maximum size of considered condition speculatemaximum number of variables allowed in inequalities and conditional equations speculaterepeat constants on output speculatewhether to show equations speculatewhether to show inequalties speculate%whether to show conditional equations speculate&whether to show laws with no variables speculate:automatically include constants taken from tiers of values speculate(intermediary) minimum number of tests for passing postconditions in function of maximum number of tests speculate(intermediary) maximum nubmer of constants allowed when considering expressions speculate(intermediary)( maximum depth of considered expressions speculate(intermediary) show counts of equations, inequalities and conditional equations speculate(debug) whether to show raw theory speculate(debug) show _this_ args before running speculate (advanced)& whether to show the command line help speculate (advanced)+ timeout when evaluating ground expressions speculate (advanced) ignore errors speculate (advanced) unused, user-defined meaning speculate (advanced)3 exclude this symbols from signature before running speculate (advanced)? only allow those types at top-level equations / semi-equations speculate (advanced)( show equivalence classes of expressions speculate (advanced)7 whether to show a Graphviz dotfile with an Ord lattice speculate (advanced) whether to show a Graphviz dotfiel with an Ord lattice (less verbose) speculateDefault arguments to Speculate speculateAre all constants in an expression about a list of constants? Examples in pseudo-Haskell: x + y `allAbout` [(+)] == True x + y == z `allAbout` [(+)] == False x + y == z `allAbout` [(+),(==)] == True speculate A special   value. When provided on the - list, makes all the following constants  constants. speculate A special   value. When provided on the , list, makes all the following constants  constants. Background constants can appear in laws about other constants, but not by themselves.4(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneEv(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneFw speculateCalls Speculate. See the example above (at the top of the file). Its only argument is an  structure.  5  (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneL speculateThis function can be used to define an Eq instance for functions based on testing and equality of returned values, like so: instance (Listable a, Eq b) => Eq (a -> b) where (==) = areEqualFor 100 speculateThis function can be used to define an Ord instance for functions based on testing and ordering of returned values, like so: instance (Listable a, Ord b) => Ord (a -> b) where compare = compareFor 100(c) 2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneL(c) 2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela NoneL !"#$%#$&#$'#$(#$)#$*#$+#,-#./#01#0234534634789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                    #############$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$#$##################,#,#,#,#,#,#,#,########.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#.#####################0#       ! ! ! !                                                                    U323333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333343434343434343333333333333333333333333333333333333333333333333&speculate-0.4.4-GtOzBIurp6PAJifyrKaMBKTest.Speculate.UtilsTest.SpeculateTest.Speculate.Expr.CoreTest.Speculate.Expr.InstanceTest.Speculate.Expr.EquateTest.Speculate.Expr.GroundTest.Speculate.SanityTest.Speculate.Reason.OrderTest.Speculate.ReasonTest.Speculate.SemiReasonTest.Speculate.CondReasonTest.Speculate.PrettyTest.Speculate.EngineTest.Speculate.ArgsTest.Speculate.ReportTest.Speculate.FunctionTest.Speculate.Function.A1000Test.Speculate.Function.A100Test.Speculate.Utils.ClassTest.Speculate.Utils.ColourTest.Speculate.Utils.ListTest.Speculate.Utils.MemoizeTest.Speculate.Utils.Ord Test.Speculate.Utils.PrettyPrintTest.Speculate.Utils.StringTest.Speculate.Utils.MiscTest.Speculate.Utils.TiersTest.Speculate.Utils.TimeoutTest.Speculate.Utils.TupleTest.Speculate.Utils.DigraphTest.Speculate.Exprbase Data.OldListsortOn$express-0.1.4-AuKBO6kNCcb18ascH3QBFsData.Express.Instances mkNameWithmkOrdLessEqualmkOrdmkEq reifyEqOrdreifyOrdreifyEqData.Express.HoleholeData.Express.CoreExprData.Express.NamenameName&leancheck-0.9.3-1sKCvqTVi3M636RaP3sUTxTest.LeanCheck.StatscountsOncountsBycounts pairsThatcountfirstshalvenubSort nubSortBy nubMergeBy nubMergeOnnubMerge+++ordIntersectBy ordIntersect nubMerges nubMergesBy nubMergeMap orderedBy orderedOnorderedstrictlyOrderedOnstrictlyOrderedareAllareAnyallLater+-groupOn collectOn collectBy collectWithcollectSndByFstdiscard discardLaterdiscardEarlier discardOthersdiscardByOthers allUniquechainzipWithReverse medianatetakeGreaterHalfaccumpartitionByMarkers!Binds fastCompare lexicompare lexicompareByunrepeatedVars isAssignmentisConstantNamedunify unificationisCanonInstanceOfhasCanonInstanceOf withMemory withMemory2memorymemory2 memoryFor memory2For compareIndexbesideabovetablespacesunquoteatomicouternmostPrecisNegativeLiteralisInfixprecisPrefixisInfixedPrefixtoPrefixprime alignRight alignLeftindent splitAtCommas undefined1 undefined2thnreportCountsBy maybesToMaybemaybe2 iterateUntiliterateUntilLimit showRatiopercentputLines.:..: productsList mapTMaybeuptoTfilterTS discardTStimeoutToNothing fromTimeouttimeoutToFalse timeoutToTruetimeoutToErrorfst3snd3trd3fst4snd4trd4fth4curry3curry4uncurry3uncurry4uncurry5uncurry6uncurry7uncurry8uncurry9 uncurry10 uncurry11 uncurry12***catPairs InstancesreifyInstances1reifyInstances reifyListable mkListable isListable isListableT lookupTiers lookupTiersTholeOfTy maybeHoleOfTypreludeInstances unEquation isEquation unComparisonmkConditionalEquationunConditionalEquationgrounds groundBindsequal condEqual condEqualM lessOrEquallessinequal trueRatioisTrueisFalseeqErrors ordErrors eqOrdErrorsinstanceErrors|>|>|kboByweight weightExceptgtExcept|>dwoByfunnyseriousThyrules equations canReduceTocompareE closureLimitkeepEokThy updateRulesByupdateEquationsBy|==|emptyThykeepUpToLength keepMaxOf normalize normalizeEisNormal reductions1normalizedCriticalPairs criticalPairs equivalentequivalentInstanceinsertappendcompletededuceorientdeletesimplifycomposecollapsecanonicalizeEqn canonicalEqn canonicalRuleprintThyshowThyfinalEquationsfinalizetheorize theorizeBy initialize defaultKeepdiscardRedundantEquations$fEqThyShy sequationssthyEquationemptyShyupdateSemiEquationsBymapSemiEquations scompareElessergreater simplerThantransConsequenceupdateSEquationsBy stheorizesidesfinalSemiEquationscanonicalizeShyWithcanonicalizeSemiEquationWithChy cequations cimplicationscclassesunThyemptyChyupdateCEquationsBy listImplied listImplieslistEquivalentreduceRootWithreductions1With creductions1 cnormalize cequivalent cIsInstanceOfcinsertcfiltercdiscardcdelete cfinalizecanonicalizeCEqncanonicalizeCEqnWithcanonicalCEqnBy canonicalCEqnfinalCondEquations prettyThy prettyChy prettyShyprettyEquationsprettySemiEquationsprettyCondEquationsexpansionsOfTypeexpansionsWith expansionstheoryFromAtomsrepresentativesFromAtoms!theoryAndRepresentativesFromAtomsconsiderdistinctFromSchemasclassesFromSchemasclassesFromSchemasAndVariablesequivalencesBetweensemiTheoryFromThyAndRepsconditionalTheoryFromThyAndRepsconditionalEquivalencessubConsequencepsortByArgsmaxSizemaxTests constants instances maxSemiSize maxCondSizemaxVars showConstants showEquationsshowSemiequationsshowConditionsshowConstantLaws autoConstantsminTests maxConstantsmaxDepth showCounts showTheoryshowArgsshowHelp evalTimeoutforceextraexclude onlyTypesshowClassesForshowDotquietDotargscomputeMaxSemiSizecomputeMaxCondSizecomputeInstancesshouldShowEquationshouldShowConditionalEquationkeepExprreallyShowConditionsatomstypesforegroundConstantsbackgroundConstantsallAboutabouttimeout compareExprconstant showConstant foreground background prepareArgsgetArgsreport speculate funToList areEqualFor compareFor$fOrd->$fEq->ClassmaprepfromRepmergesOn mergesThatmergefromHCMColorColourRGBshowRGB coerceRatiomodulofrac.+..-..*.blackwhiteredgreenbluecyanmagentayellowvioletorangelime aquamarineazureindigogreygrey1grey2grey3grey4grey5grey6grey7grey8grey9makeGreyrgbcmychromahue0hue intensityvalue lightness saturation saturationHSV saturationHSL saturationHSIfromRGBfromCMYfromHSVfromHSLfromHCLmixmixHSVprimary'primary secondarytertiaryisGreynotGrey isOppositeToData.Typeable.InternalTypeableghc-prim GHC.TypesTyCon Data.TypeabletypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1 rnfTypeReptypeRepFingerprint typeRepTyCon typeRepArgs splitTyConAppmkFunTy funResultTygcast2gcast1gcasteqTcast showsTypeReptypeReptypeOfTypeReprnfTyContyConFingerprint tyConName tyConModule tyConPackage Data.ProxyProxyData.Type.Equality:~:Refl:~~:HReflData.Express.CanonfastMostSpecificVariationfastMostGeneralVariationfastCanonicalVariationsmostSpecificCanonicalVariationmostGeneralCanonicalVariationcanonicalVariations isCanonicalcanonicalization canonicalizeisCanonicalWithcanonicalizationWithcanonicalizeWithpreludeNameInstances findValidApp validApps listVarsWith lookupNames lookupNamemkComparisonLEmkComparisonLT mkEquation mkComparisonisEqOrdisOrdisEqisEqOrdTisOrdTisEqTlookupComparisonmkName reifyNameData.Express.Match isSubexprOf hasInstanceOf isInstanceOf matchWithmatchData.Express.Express.DerivederiveExpressCascadingderiveExpressIfNeeded deriveExpressData.Express.ExpressExpressexprData.Express.Foldunfoldfold unfoldTriofoldTrio unfoldPairfoldPairfoldAppfilllistVarsAsTypeOflistVarsnubHolesholesisHole holeAsTypeOf varAsTypeOfData.Express.Map renameVarsBy////- mapSubexprs mapConstsmapVars mapValuesheightdepthsizearitynubVarsvars nubConstsconsts nubValuesvalues nubSubexprssubexprsisAppisValueisVarisConstisGroundhasVar unfoldAppcompareComplexityshowExpr showPrecExpr showOpExpr toDynamicevlevalevaluateisFun isWellTyped isIllTypedmtypetyptypvar$$valValue:$Data.Express.Utils.Typeable->:: typesInListtypesIn mkCompareTymkComparisonTyisFunTyfunTyCon orderingTyintTyboolTy elementTyresultTy argumentTyunFunTy finalResultTytyArity compareTyData.Express.Name.DerivederiveNameCascadingderiveNameIfNeeded deriveNamenamesData.Express.Utils.StringvariableNamesFromTemplate GHC.ClassesOrd<<=>maxmin>=compareOrderingGTLTEQData.Ord comparingDowngetDown Data.StringIsString fromStringCharunwordswordsunlineslines Data.Char isSeparatorisNumberisMarkisLetter digitToIntGHC.Read readLitChar lexLitChar GHC.UnicodetoTitletoUppertoLowerisLowerisUpperisPrint isControl isAlphaNumisAlphaisSymbol isPunctuation isHexDigit isOctDigitisDigitisSpace isAsciiUpper isAsciiLowerisLatin1isAsciigeneralCategoryGeneralCategory NotAssigned PrivateUse SurrogateParagraphSeparator LineSeparatorSpace OtherSymbolModifierSymbolCurrencySymbol MathSymbolOtherPunctuation FinalQuote InitialQuoteClosePunctuationOpenPunctuationDashPunctuationConnectorPunctuation OtherNumber LetterNumber DecimalNumber EnclosingMarkSpacingCombiningMarkNonSpacingMark OtherLetterModifierLetterTitlecaseLetterLowercaseLetterUppercaseLetterFormatControlGHC.CharchrGHC.Show intToDigit showLitCharGHC.BaseordString Data.TuplefstsndswapuncurrycurryDigraphemptysuccspredsisNodeisEdgefilter fromEdgesnarrowTest.LeanCheck.CoreListable-==>--&&-True&cmdargs-0.10.21-KlHphs6sBhIECkIRkNdEOMSystem.Console.CmdArgs.ExplicitflagsVerbosityflagNumericVersion flagVersionflagHelpFormatflagHelpSimpleprocessValueIO processValue processArgs$System.Console.CmdArgs.Explicit.HelphelpText HelpFormat HelpFormatZshHelpFormatBash HelpFormatAllHelpFormatDefault HelpFormatOne(System.Console.CmdArgs.Explicit.CompleteComplete CompleteDir CompleteValue CompleteFile'System.Console.CmdArgs.Explicit.Processprocess$System.Console.CmdArgs.Explicit.TypeflagBoolflagArgflagReqflagOptflagNonemodesmode modeEmpty remapUpdateremap2 checkMode fromFlagOpt modeFlags modeModestoGroup fromGroup parseBoolHelpFlagHelpGroup groupNamed groupUnnamed groupHiddenModemodeGroupFlagsmodeArgsmodeHelpSuffixmodeHelp modeExpandAt modeReform modeCheck modeValuemodeGroupModes modeNamesFlagInfoFlagNone FlagOptRareFlagReqFlagOptUpdateFlagflagHelpflagType flagValue flagNamesflagInfoArg argRequireargValueargTypeRemapremap)System.Console.CmdArgs.Explicit.SplitJoin splitArgsjoinArgs,System.Console.CmdArgs.Explicit.ExpandArgsAt expandArgsAt Test.LeanCheck.Utils.TypeBindinguint4uint3uint2uint1word4word3word2word1int4int3int2int1natnaturaleithmayborderingstringcharboolrationaldoublefloatintegerintund>-->>>>>>>>>>>>:->>>>>>>>>>>:> ->>>>>>>>>>>: ->>>>>>>>>>:> ->>>>>>>>>>: ->>>>>>>>>:> ->>>>>>>>>: ->>>>>>>>:> ->>>>>>>>: ->>>>>>>:> ->>>>>>>: ->>>>>>:>->>>>>>:->>>>>:>->>>>>:->>>>:>->>>>:->>>:>->>>:->>:>->>:->:>->:-:>-:Test.LeanCheck.Utils.TypesInt1unInt1Int2unInt2Int3unInt3Int4unInt4Word1unWord1Word2unWord2Word3unWord3Word4unWord4Natural unNaturalNatunNatNat1unNat1Nat2unNat2Nat3unNat3Nat4unNat4Nat5unNat5Nat6unNat6Nat7unNat7UInt1UInt2UInt3UInt4NoDupBagSetMapXunXXsunSpaceLowerunLowerUpperunUpperAlphaunAlphaDigitunDigitAlphaNum unAlphaNumLetterunLetterSpacesunSpacesLowersunLowersUppersunUppersAlphasunAlphasDigitsunDigits AlphaNums unAlphaNumsLetters unLettersTest.LeanCheck.Utils.Operators neverIdentityidentity idempotent comparisonstrictTotalOrder totalOrderstrictPartialOrder partialOrder equivalence asymmetric antisymmetric symmetric irreflexive reflexive transitive symmetric2 distributive associative commutative|==|$==$okNumokNumNonNegativeokEqOrdokOrdokEqisNeverIdentity isIdentity isIdempotent isComparisonisStrictTotalOrder isTotalOrderisStrictPartialOrderisPartialOrder isEquivalence isAsymmetricisAntisymmetric isSymmetric isIrreflexive isReflexive isTransitive isFlippedisRightDistributiveOverisLeftDistributiveOverisDistributiveOver isAssociative isCommutative|||||||&&&&&&&&&&&&=======Test.LeanCheck.Tiers listsOfLengthsetsOfbagsOf noDupListsOf normalizeTdeleteTproductslistsOfproductMaybeWith product3With noDupListConsmapConssetConsbagCons classifyOn classifyByclassifyconditionStatsTconditionStats classStatsT classStatsTest.LeanCheck.IOcheckResultFor checkResultcheckForcheckTest.LeanCheck.DerivederiveListableCascadingderiveListableTest.LeanCheck.Basic addWeightofWeightcons12cons11cons10cons9cons8cons7cons6==>existsfailsholdswitness witnessescounterExamplecounterExamplesresults productWith><\\//\/+|suchThatresetdelaycons5cons4cons3cons2cons1cons0 concatMapTconcatTfilterTmapT tiersFloatingtiersFractional listIntegraltoTierslisttiersTestable