]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`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 [ \ ] ^ _ ` 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{|}~ (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe   (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneIn microsecondsQReturns Nothing if value cannot be evaluated to WHNF in a given number of seconds(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None !"# !"# !"#(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe('Check if a function / operator is infix aisInfix "foo" == False isInfix "(+)" == False isInfix "`foo`" == True isInfix "+" == True)3Returns the precedence of default Haskell operators+Is the string of the form string,3Transform an infix operator into an infix function: 3toPrefix "`foo`" == "foo" toPrefix "+" == "(+)"$%&'()*+,-./0123V$%&'()*+,-./0123$%&'()*+,-./0123(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe4     44(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None56789:56789:56789:(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeSxs +- 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"*;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd+;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcd*;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdE5(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Noneefghijklmnopqrsefghijklmnopqrsefghijklmnopqrsh8(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nonet.Appends two Strings side by side, line by line =beside ["asdf\nqw\n","zxvc\nas"] == "asdfzxvc\n\ \qw as\n"uJAppend two Strings on top of each other, adding line breaks *when needed*.vFormats 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 tuvwtuvw tuvw(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafezHFor a given type, return all *-kinded types. (all non-function types) KtypesIn (typeOf (undefined :: (Int -> Int) -> Int -> Bool)) == [Bool,Int] xyz{|}~8 !"#$%&'()*+,-./0123456789:;<=>?@ABCDExyz{|}~ xyz{|}~(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeFFrom hue, chroma and minFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~F>GHIJNPQRSTUVWXYZ[\]^_`abcdefghijklmnorstuvwxyz{|}~FEGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~F(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None       !"#$%&'()*+,-./0123456789:;<=>?@ABCDE  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~efghijklmnopqrstuvw $%&'(*+,)-./2013;<=>?@AEDBCHIJGFMKLONPQRSTUVWXYZ[\]^_`abcd# !"yz|}~{x4789:56(c) 2016 Colin Runciman$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nonepick a node in a Digraph   (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None0JAn 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" Truevar "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 repetitionsGList 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 itselfRSub-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]5--2(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneFill holes in an expression. Silently skips holes that are not of the right type. Silently discard remaining expressions.5Assign 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).=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."Substitute matching subexpressios.Tsub (x + y) 0 ((x + y) + z) == (0 + z) sub (x + y) 0 (x + (y + z)) == (x + (y + z)))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!List 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) = Nothing0List 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) = Nothing'List matches with preexisting bindings: [0 + 1 `matchWith [(x,0)]` x + y = Just [x=0, y=1] 0 + 1 `matchWith [(x,1)]` x + y = Nothing(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None/01Type information needed to Speculate expressions.NType information needed to Speculate expressions (single type / single class).Usage: ins1 "x" (undefined :: Type) (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None 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.(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None [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]4List 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)] ]CList all possible variable bindings and valuations to an expression DgroundAndBinds ti e == zipWith (,) (grounds ti e) (groundBinds ti e)6Are two expressions equal for a given number of tests?TAre two expressions equal under a given condition for a given number of tests?tAre two expressions equal under a given condition for a given number of tests and a minimum amount of testsCAre two expressions less-than-or-equal for a given number of tests?: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 (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>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)) (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None}(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>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          44 4 (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None"should be compatible with compareE$total order used to "sort" equations2QFinalize a theory by discarding redundant equations. If after finalizing you %), redundant equations might pop-up again.8This 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 .A    !"#$%&'()*+,-./012345678/      !"#$%&'()*+,-./01234567/   % !"0/341#$-.,&)('*+7256  :    !"#$%&'()*+,-./0123456784 (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None9:;<9:;<<;9:9:;<13 (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneHgiven 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.=>?@ABCDEFGHIJKLMNO=>?@ABCDEFGHIJKLMNOA=>?@BCDEFGHIJKLMNO=>?@ABCDEFGHIJKLMNO (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NonePQRSTUVWXYZ[\]^_`abcdefghijPQRSTUVWXYZ[\]^_`abcdefghijPQRSTUVWXYZ[\]^_`abcdefghijPQRSTUVWXYZ[\]^_`abcdefghij (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NonekOList 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]m:List the most general assignment of holes in an expressionn;List the most specific assignment of holes in an expressiono4Computes 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 }pRGiven atomic expressions, compute theory and representative schema expressions.yReturns 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,[]) ]x!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)klmnopqrstuvwxyklmnopqrstuvwxyklmnpotqrsuvwxyklmnopqrstuvwxy(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nonez{|}~z{|}~z}|~{z{|}~(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None0 Arguments 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(intermediary)A show counts of equations, inequalities and conditional equations(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.5~      !"#$-(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None%&'(%&'((c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None[Calls Speculate. See the example above (at the top of the file). Its only argument is an  structure.% !"#$%&'()*+,-./0123456789:;<=>?@ABCDE)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~.(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneHGiven 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 : ; < = > ? @ 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 [ \ ] ^ _ _ ` a b c d e f g h i j k l m n o p q q r s t u v w x y z { | } ~                           !!!!!!!!$!$!$!$!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ! ! ! ! !!!!!!!!!!!!!!!!!!! !!!"!#$!%&!%'!(!()*+*,*-*.*/*0*1*23456!78!79!79:;<<=>?@A!"B!"CD!EF!EG!EH!EI!EJ!"K!"L!"M!"N!"O!"P!"Q!"R!"S!"T!"U!"V!"W!"X!"Y!"Z!"[!"\!"]!"^!"_!"`!"a!"b!"c!"d!"e!"f!"g!"h!"i!"j!kl!km!no!nopqrstuvwxyz{|}~}!%!(!( b                         b    G      !"#$%&'()*+,--./01123456789:;<=>?@ABBCDEFGHHIJKLMNOPQRSTRSURSVRSWRSXRSYRSZRS[RS\RS]RS^RS_RS`RSaRSbRScRSdRSeRSfRSgRShRSiRSjRSkRSlRSmRSnRSoRSpRSqRSrRSsRStRSuRSvRSwRSxRSyRSzRS{RS|RS}RS~RSRSRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR R R R R RR&speculate-0.2.8-DsVlpjOw9d3GGTjGmiJ8UATest.Speculate.Expr.InstanceTest.Speculate.UtilsTest.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.PrettyTest.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.Utils.DigraphTest.Speculate.ExprbaseData.Typeable.InternalTypeRep Data.OldListsortOnfst3snd3trd3fst4snd4trd4fth4curry3curry4uncurry3uncurry4uncurry5uncurry6uncurry7uncurry8uncurry9 uncurry10 uncurry11 uncurry12***catPairstimeoutToNothing fromTimeouttimeoutToFalse timeoutToTruetimeoutToError productsList mapTMaybediscardT partitionTuptoTfilterTS discardTS discardLaterTunquoteatomicouternmostPrecisNegativeLiteralisInfixprecisPrefixisInfixedPrefixtoPrefixprime primeCyclenamesFromTemplate alignRight alignLeftindent splitAtCommas compareIndex withMemory withMemory2memorymemory2 memoryFor memory2For pairsThatcountcountscountsByfirstsnubSort nubSortBy nubMergeBy nubMergeOnnubMerge+++ordIntersectBy ordIntersect nubMerges nubMergesBy nubMergeMap orderedBy orderedOnorderedstrictlyOrderedOnstrictlyOrderedareAllareAnyallLater+-groupOn collectOn collectBy collectWithcollectSndByFstdiscard discardLaterdiscardEarlier discardOthersdiscardByOthers allUniquechainzipWithReverse medianatetakeGreaterHalfaccumpartitionByMarkers undefined1 undefined2issthnreportCountsBybell maybesToMaybemaybe2 iterateUntiliterateUntilLimit showRatiopercentputLines.:..:besideabovetablespaces compareTytyAritytypesIn finalResultTyunFunTy argumentTyresultTyboolTyfunTyConisFunTymkEqnTyExprConstantVar:$constant showConstantvarholeholeOfTy$$ showsPrecExprisTuple unfoldTuple showsOpExpr showOpExpr showPrecExprshowExpreqExprCommuting lexicompareBy lexicomparecompareComplexityThencompareComplexityfalseEevaluateevaltypetyp typeCorrectarityholesvarsatomicConstantshasVarconstslengthEdepthEcountVar countVarsunrepeatedVars isAssignmentsubexprs subexprsVisSubisConstantNamed unfoldApp $fOrdExpr$fEqExpr $fShowExprBindsfillassign assigningsubrenameBymatchmatch2 matchWithunify unification isInstanceOf hasInstanceOfisCanonInstanceOfhasCanonInstanceOf InstancesInstance instanceTypeinseqordeqOrdlistablenameeqWithordWith listableWithisEqisOrdisEqOrdisEqEisOrdEisEqOrdE isListablefindInfonamestiersEeqEltEleEpreludeInstancesdefNames $fOrdInstance $fEqInstance$fShowInstanceequation 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 reductions1normalizedCriticalPairs criticalPairs equivalentequivalentInstanceinsertappend differencecompletededuceorientdeletesimplifycomposecollapsecanonicalizeEqn canonicalEqn canonicalRuleprintThyshowThyfinalEquationsfinalizetheorize theorizeBy initialize defaultKeepdiscardRedundantEquations$fEqThyeqErrors ordErrors eqOrdErrorsinstanceErrorsShy sequationssthyEquationemptyShyupdateSemiEquationsBymapSemiEquations scompareElessergreater simplerThantransConsequenceupdateSEquationsBy stheorizesidesfinalSemiEquationscanonicalizeShyWithcanonicalizeSemiEquationWithChy cequations cimplicationscclassesunThyemptyChyupdateCEquationsBy listImplied listImplieslistEquivalentreduceRootWithreductions1With creductions1 cnormalize cequivalent cIsInstanceOfcinsertcfiltercdiscardcdelete cfinalizecanonicalizeCEqncanonicalizeCEqnWithcanonicalCEqnBy canonicalCEqnfinalCondEquations vassignments expansions mostGeneral mostSpecifictheoryFromAtoms!theoryAndRepresentativesFromAtomsconsiderdistinctFromSchemasclassesFromSchemasequivalencesBetweensemiTheoryFromThyAndRepsconditionalTheoryFromThyAndRepsconditionalEquivalencessubConsequencepsortBy prettyThy prettyChy prettyShyprettyEquationsprettySemiEquationsprettyCondEquationsArgsmaxSizemaxTests constants instances maxSemiSize maxCondSizemaxVars showConstants showEquationsshowSemiequationsshowConditionsshowConstantLawsminTests maxConstantsmaxDepth showCounts showTheoryshowArgsshowHelp evalTimeoutforceextraexclude onlyTypesshowClassesForshowDotquietDotargscomputeMaxSemiSizecomputeMaxCondSizecomputeInstancesshouldShowEquationshouldShowConditionalEquationkeepExprreallyShowConditionsatomstypestimeout compareExpr foreground background prepareArgsgetArgsreport speculate functions1 functions2 functions3 functions4fillings expressionsOfvaluedExpressionsOf Data.TuplefstsndswapuncurrycurryusTimeoutToNothing Data.StringIsString fromStringghc-prim GHC.TypesCharunwordswordsunlineslines 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 GHC.ClassesOrd>=minmax><<=compareOrderingLTEQGTData.Ord comparingDown defaultMemoryfit maxLengthfitR normalizeR normalizeToremoveTrailing isntSpacemkAppTyTypeableTyCon 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 showsTailExprlexicompareConstants isConstantfindBupdateAssignmentsfindBindnaiveUnificationins1 findInfoOr>=\/dropEqRule compareEqnmapRules mapEquations ruleFilter reduceRootgroundJoinableoverlapsclosurecompleteVerbosedeleteEquivalentdeleteGroundJoinablecanonicalizeThycanonicalizeThyWithcanonicalizeEqnWithcanonicalizeRulecanonicalizeRuleWith discardRedundantRulesByEquations-==>--&&-classesFromSchemavassignmentsEqnreholerepresentativesFromAtomsexpand CondEquationallAbout shouldShow2 shouldShow3foregroundConstantsbackgroundConstants allConstantsaboutnotAbout%cmdargs-0.10.17-Ly0hbQJKNTmfKXxfLEQllSystem.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.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.4-LgD5obmxq9nKk7KMiFXeCw Test.LeanCheck.Utils.TypeBindinguint4uint3uint2uint1int4int3int2int1nateithmaybstringcharbooldoublefloatintegerintund>-->>>>>>>>>>>>:->>>>>>>>>>>:> ->>>>>>>>>>>: ->>>>>>>>>>:> ->>>>>>>>>>: ->>>>>>>>>:> ->>>>>>>>>: ->>>>>>>>:> ->>>>>>>>: ->>>>>>>:> ->>>>>>>: ->>>>>>:>->>>>>>:->>>>>:>->>>>>:->>>>:>->>>>:->>>:>->>>:->>:>->>:->:>->:-:>-:Test.LeanCheck.Utils.TypesInt1unInt1Int2unInt2Int3unInt3Int4unInt4Word1unWord1Word2unWord2Word3unWord3Word4unWord4NatunNatNat1unNat1Nat2unNat2Nat3unNat3Nat4unNat4Nat5unNat5Nat6unNat6Nat7unNat7UInt1UInt2UInt3UInt4NoDupBagSetXunXXsunXsTest.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.Basic addWeightofWeightcons12cons11cons10cons9cons8cons7cons6Test.LeanCheck.IOcheckResultFor checkResultcheckForcheckTest.LeanCheck.Core==>existsfailsholdswitness witnessescounterExamplecounterExamplesresults productWith><\\//\/+|suchThatresetdelaycons5cons4cons3cons2cons1cons0 concatMapTconcatTfilterTmapTtiersFractional listIntegraltoTiersListablelisttiersTestablefistfist2fist3fist4