!DE Sd      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & '()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safedefghij(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe)k speculateFrom hue, chroma and min>lmnopqrstuvwxyz{|}~k(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe& 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,zU+- [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 <rudy@matela.com.br>None Y@ speculateFill holes in an expression. Silently skips holes that are not of the right type. Silently discard remaining expressions.      !"#$%&'()* +,-./0123456789:;<=>?@A B9:;<=>?@ABCD ;<:?=>9@ABCD(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None$EFGHIJ(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe&CDEFGHIJKLMNOPQK(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None=6L speculate.Appends two Strings side by side, line by line =beside ["asdf\nqw\n","zxvc\nas"] == "asdfzxvc\n\ \qw as\n"M speculateJAppend two Strings on top of each other, adding line breaks *when needed*.N 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"R speculate;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]S speculate:normalize makes all list the same length by adding a value @normalize ["asdf","qw","er"] == normalize ["asdf","qw ","er "]T speculate0Given a list of lists returns the maximum lengthLMNO(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeDT speculate'Check if a function / operator is infix aisInfix "foo" == False isInfix "(+)" == False isInfix "`foo`" == True isInfix "+" == TrueU speculate3Returns the precedence of default Haskell operatorsW speculateIs the string of the form stringX speculate3Transform an infix operator into an infix function: 3toPrefix "`foo`" == "foo" toPrefix "+" == "(+)"TUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~PQRSTUVWXYZ[\](c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeG ^_`abcdefghij`8(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneIklmno(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneMN speculateIn microsecondsp speculateQReturns Nothing if value cannot be evaluated to WHNF in a given number of secondspqrst(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeOuvwxyz{|}~(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneQ&CDEFGHIJUVWKLMNXYZ[\]^_`OPQabcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./012345678EFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~s^_`abcdefghijLMNOuxvywz{|}~PQRSTVWXUY\Z[]  "!#$%&'()*+,-./012345678klmnopqrstKGHIJEF(c) 2016 Colin Runciman$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneXY speculatepick a node in a Digraph (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None12Z?& (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None\(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nones  speculate[List all possible valuations of an expression (potentially infinite). In pseudo-Haskell: jtake 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? speculateTAre two expressions equal under a given condition for a given number of tests? speculatetAre two expressions equal under a given condition for a given number of tests and a minimum amount of tests speculateCAre two expressions less-than-or-equal for a given number of tests? speculate:Are two expressions less-than for a given number of tests? speculate[Are two expressions inequal for *all* variable assignments? Note this is different than  not . equal. speculateYUnder a maximum number of tests, returns the ratio for which an expression holds true. speculate:Is a boolean expression true for all variable assignments? speculateCIs 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 <rudy@matela.com.br>Noneu       !"#$%&'()* +,-./0123456789:;<=>?@A B9:;<=>?@ABCD(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Noney13(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None  speculate;Greater than or equal number of occurences of each variable 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. speculateGStrict 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. afunny 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. iserious 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 <rudy@matela.com.br>None{ speculate"should be compatible with compareE speculate$total order used to "sort" equations speculateQFinalize 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 <rudy@matela.com.br>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 <rudy@matela.com.br>None           (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None[ (c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None8 speculateEList 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 ] speculate:List the most general assignment of holes in an expression speculate;List the most specific assignment of holes in an expression 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 } speculateRGiven atomic expressions, compute theory and representative schema expressions. speculateyReturns all classes of expressions that can be build from expression schemas (single variable expressions). Examples: > classesFromSchema preludeInstances thy 2 (i_ -+- i_) [ (x + x :: Int,[]) , (x + y :: Int,[]) , (y + x :: Int,[]) , (y + y :: Int,[]) ]% speculate!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)      !"#$%&'()* +,-./0123456789:;<=>?@A B9:;<=>?@ABCD !"#$%&! "#$%&(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None2!' 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/ speculateMmaximum number of variables allowed in inequalities and conditional equations0 speculaterepeat constants on output1 speculatewhether to show equations2 speculatewhether to show inequalties3 speculate%whether to show conditional equations4 speculate&whether to show laws with no variables5 speculate:automatically include constants taken from tiers of values6 speculate(intermediary)` minimum number of tests for passing postconditions in function of maximum number of tests7 speculate(intermediary)A maximum nubmer of constants allowed when considering expressions8 speculate(intermediary)( maximum depth of considered expressions9 speculate(intermediary)A 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 runningA speculate (advanced)? only allow those types at top-level equations / semi-equationsB speculate (advanced)( show equivalence classes of expressionsC speculate (advanced)7 whether to show a Graphviz dotfile with an Ord latticeD speculate (advanced)F whether to show a Graphviz dotfiel with an Ord lattice (less verbose)E speculateDefault arguments to SpeculateQ 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` [(+),(==)] == TrueW speculate A special   value. When provided on the +- list, makes all the following constants W constants.X speculate A special   value. When provided on the +, list, makes all the following constants Xg constants. Background constants can appear in laws about other constants, but not by themselves.'(><1)*+,-./023456789:;=?@ABCDEFGHIJKLMNOPQRSTUVWXYZ4'(><1)*+,-./023456789:;=?@ABCDEUVWXZFGHNMTKSIJLOPRQY(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneX[[(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None\ speculate[Calls Speculate. See the example above (at the top of the file). Its only argument is an ' structure.}       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"'(><1)*+,-./023456789:;=?@ABCDEUVWXZ[\5\'(><1)*+,-./023456789:;=?@ABCDE UVWX [Z(c) 2016-2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None^ speculate~This function can be used to define an Eq instance for functions based on testing and equality of returned values, like so: Iinstance (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: Minstance (Listable a, Ord b) => Ord (a -> b) where compare = compareFor 100]^_]^_(c) 2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None(c) 2019 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None O# !"#$%#$&#$'#$(#$)#$*#$+#,-#./#01#0234534634789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                      ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K LMMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                   #########$#$#$#$#$#$#$#$#$#$#$#$ #$ #$ #$ #$ #$#$#$############ #!#"###$#%#,&#,'#,(#,)#,*#,+#,,#-.#-/#-0#-1#-2#-3#-4#.5#.6#.7#.8#.9#.:#.;#.<#.=#.>#.?#.@#.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[#Z\#Z]#Z^#Z_#Z`#Za#Zb#Zc#Zd#Ze#Zf#Zg#Zh#Zi#Zj#Zk#lm#ln#lo#0p#qrstsusvswsxsyszs{|}~      ! ! ! !                                                                    U3      2 !"#$%&'()*+,,-./012234567898:;<3=>3=?3=@3=A3=B3=C3=D3=E3=F3=G3=H3=I3=J3=K3=L3=M3=N3=O3=P3=Q3=R3=S3=T3=U3=V3=W3=X3=Y3=Z3=[3=\3=]3=^3=_3=`3=a3=b3=c3=d3=e3=f3=g3=h3=i3=j3=k3=l3=m3=n3=o3=p3=q3rs3rs3rt3ru3ru3rv3rw3rw3rx3ry3ry3rz3r{3r{3r|3r}3r}3r~3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r3r333333333333333333333333333333333333333333333333333333333333333333333334343434343434 3  3  3  3 3333333333333333 3!3"3#3$3%3&3'3(3)3*3+3,3-3.3/303132333435363738393:3;3<3=>&speculate-0.4.2-5rUqJ0JaSKs4jUxL92r5pvTest.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.3-K9BKASYKZZn3u7DyQKFWYDData.Express.Instances mkNameWithmkOrdLessEqualmkOrdmkEq reifyEqOrdreifyOrdreifyEqData.Express.HoleholeData.Express.CoreExprData.Express.NamenameName&leancheck-0.9.3-2sXNdM3HBluLND2va2AV7cTest.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 isAssignmentisConstantNamedfillunify 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 expansions mostGeneral mostSpecifictheoryFromAtomsrepresentativesFromAtoms!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.CanonfastCanonicalVariationscanonicalVariations 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 unfoldPairfoldPairfoldApplistVarsAsTypeOflistVarsnubHolesholesisHole holeAsTypeOf varAsTypeOfData.Express.Map renameVarsBy////- mapSubexprs mapConstsmapVars mapValuesheightdepthsizearitynubVarsvars nubConstsconsts nubValuesvalues nubSubexprssubexprsisAppisValueisVarisConstisGroundhasVar unfoldAppcompareComplexityshowExpr showPrecExpr showOpExpr toDynamicevlevalevaluate isWellTyped isIllTypedmtypetyptypvar$$valValue:$Data.Express.Utils.Typeable->:: typesInListtypesIn mkCompareTymkComparisonTyisFunTyfunTyCon orderingTyintTyboolTy elementTyresultTy argumentTyunFunTy finalResultTytyArity compareTyData.Express.Name.DerivederiveNameCascadingderiveNameIfNeeded deriveNamenamesData.Express.Utils.StringvariableNamesFromTemplate GHC.ClassesOrd>=minmax><compare<=OrderingLTEQGTData.Ord comparingDownfit maxLength 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.BaseordStringusTimeoutToNothing Data.TuplefstsndswapuncurrycurrypickDigraphemptysuccspredsisNodeisEdgefilter fromEdgesnarrowTest.LeanCheck.CoreListable-==>--&&->=\/TrueclassesFromSchema%cmdargs-0.10.20-2I5EC3CdzQ7qCXt6V31JgSystem.Console.CmdArgs.ExplicitflagsVerbosityflagNumericVersion flagVersionflagHelpFormatflagHelpSimpleprocessValueIO 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 parseBoolHelpFlagHelpGroup groupUnnamed groupHidden groupNamedModemodeGroupModes modeNames modeValue modeCheck modeReform modeExpandAtmodeHelpmodeHelpSuffixmodeArgsmodeGroupFlagsFlagInfoFlagReqFlagOpt FlagOptRareFlagNoneUpdateFlag flagNamesflagInfo flagValueflagTypeflagHelpArgargValueargType argRequireRemapremap)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