!|Rd      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc#(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe!_d speculateFrom hue, chroma and min>efghijklmnopqrstuvwxyz{|}~d(c) 2016-2017 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".5(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe)e(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,(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneCk speculate.Appends two Strings side by side, line by line =beside ["asdf\nqw\n","zxvc\nas"] == "asdfzxvc\n\ \qw as\n" speculateJAppend two Strings on top of each other, adding line breaks *when needed*. 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" 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] speculate:normalize makes all list the same length by adding a value @normalize ["asdf","qw","er"] == normalize ["asdf","qw ","er "] speculate0Given a list of lists returns the maximum length(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeJ speculate'Check if a function / operator is infix aisInfix "foo" == False isInfix "(+)" == False isInfix "`foo`" == True isInfix "+" == True speculate3Returns the precedence of default Haskell operators speculateIs the string of the form string speculate3Transform an infix operator into an infix function: 3toPrefix "`foo`" == "foo" toPrefix "+" == "(+)"V(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneM8(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneO(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneS speculateIn microseconds speculateQReturns 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>SafeUU     !(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeY speculateHFor a given type, return all *-kinded types. (all non-function types) KtypesIn (typeOf (undefined :: (Int -> Int) -> Int -> Bool)) == [Bool,Int]/      !"#$%&'() !(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None\S      !"#$%&'()      !      !"(c) 2016 Colin Runciman$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Noned* speculatepick a node in a Digraph +,-./01234(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None1" speculateJAn encoded Haskell functional-application expression for use by Speculate.& speculateEncode 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])' speculateA shorthand for & to be used on values that are 5 instances. Examples: yshowConstant 0 = constant "0" 0 showConstant 'a' = constant "'a'" 'a' showConstant True = constant "True" True( speculatevar "x" (undefined :: Ty) returns a variable of type Ty named "x") speculate(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.+ speculate6 an "$ application if the types match, 7 otherwise.5 speculate)Compare two expressiosn lexicographicallyd1st their type arity; 2nd their type; 3rd var < constants < apps 4th lexicographic order on names6 speculateCompares 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 .7 speculateCompares 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.9 speculate6G the value of an expression when possible (correct type, no holes), 7 otherwise.: speculateeEvaluates an expression when possible (correct type, no holes). Returns a default value otherwise.; speculatetThe type of an expression. This raises errors, but those should not happen if expressions are smart-constructed.< speculatezetyp returns either: the Right type a Left expression with holes with the structure of the I'll typed expression> speculateType arity of an "? speculate4List types holes (unamed variables) in an expression@ speculate$List all variables in an expression.8 speculate?List all variables in an expression, in order, with repetitionsC speculateGList terminal constants in an expression. This does not repeat values.D speculateBReturns the length of an expression. In term rewriting terms: |s|E speculate+Returns the maximum depth of an expression.F speculate1Number of occurrences of holes with a given type.G speculateONumber of occurrences of a given variable name. In term rewriting terms: |s|_xK speculate-Non-variable sub-expressions of an expression#This includes the expression itselfL speculateRSub-expressions of an expression including variables and the expression itself.M speculateIs a subexpression of.9 speculateFMake substitutions on subexpressions, variables have to match exactly!O speculateUnfold function application: ((((f :$ e1) :$ e2) :$ e3) = [f,e1,e2,e3]."#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNO."#$%&'()*+9:;<=>?@CAKLMBO-.NDEFGHIJ5476821,0/3(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneFT speculateFill holes in an expression. Silently skips holes that are not of the right type. Silently discard remaining expressions.U speculate5Assign 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).V speculate=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.W speculate"Substitute matching subexpressios.Tsub (x + y) 0 ((x + y) + z) == (0 + z) sub (x + y) 0 (x + (y + z)) == (x + (y + z))X speculate)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!Y speculateList 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) = NothingZ speculate0List 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[ speculate'List matches with preexisting bindings: [0 + 1 `matchWith [(x,0)]` x + y = Just [x=0, y=1] 0 + 1 `matchWith [(x,1)]` x + y = NothingSTUVWXYZ[\]^_`aSTUVWXYZ[\]^_`a(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None01b speculate1Type information needed to Speculate expressions.c speculateNType information needed to Speculate expressions (single type / single class).: speculateUsage: ins1 "x" (undefined :: Type) !bcdefghijklmnopqrstuvwxyz{|}~ bcdfglhmijnkevwyzor|{psqtxu}~!(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None speculate 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  speculate[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] speculate4List 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)] ] speculateCList all possible variable bindings and valuations to an expression DgroundAndBinds ti e == zipWith (,) (grounds ti e) (groundBinds ti e) 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. speculate:Is a boolean expression true for all variable assignments? speculate:List variable bindings for which an expression holds true. speculateYUnder a maximum number of tests, returns the ratio for which an expression holds true. speculateBIs 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 speculate-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ݤ!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneQ;1<3 (c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneZ= 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 Dershowitz444 (c) 2016-2017 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-2017 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-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None9        (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,  speculateOList 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] 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:;<=>?@ABCDEFGHIJKLMNOSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$% !"#$%(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None1V!& 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 equations/ speculaterepeat constants on output0 speculatewhether to show equations1 speculatewhether to show inequalties2 speculate%whether to show conditional equations3 speculate&whether to show laws with no variables4 speculate:automatically include constants taken from tiers of values5 speculate(intermediary)` minimum number of tests for passing postconditions in function of maximum number of tests6 speculate(intermediary)A maximum nubmer of constants allowed when considering expressions7 speculate(intermediary)( maximum depth of considered expressions8 speculate(intermediary)A show counts of equations, inequalities and conditional equations9 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-equationsA speculate (advanced)( show equivalence classes of expressionsB speculate (advanced)7 whether to show a Graphviz dotfile with an Ord latticeC speculate (advanced)F whether to show a Graphviz dotfiel with an Ord lattice (less verbose)D speculateDefault arguments to Speculate? 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` [(+),(==)] == TrueP speculate A special " value. When provided on the *- list, makes all the following constants P constants.Q speculate A special " value. When provided on the *, list, makes all the following constants Qg constants. Background constants can appear in laws about other constants, but not by themselves.@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&'>=;0()*+,-./123456789:<?@ABCDEFGHIJKLMNOPQRS.&'>=;0()*+,-./123456789:<?@ABCDPQSEFGMLOJNHIKR(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneZiTT(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None]U speculate[Calls Speculate. See the example above (at the top of the file). Its only argument is an & structure.4      !"#$%&'()  !"#$%&'()*+,-./012345876;:9>=<A@?DCBGFEJIHMLKPONSRQVUTYXW\[Z_^]ba`edchgfijklnmporqtswvuyxz{|}~"&')bfghlmw&'>=;0()*+,-./123456789:<?@ABCDPQSTUU&'>=;0()*+,-./123456789:<?@ABCD"&')PQbfghlmwTS  !"#$%&'()*+,-./012345876;:9>=<A@?DCBGFEJIHMLKPONSRQVUTYXW\[Z_^]ba`edchgfijklnmporqtswvuyxz{|}~(c) 2016-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nonepo[ speculateHGiven 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\ 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 SpeculateVWXYZ[\VWXYZ[\(c) 2016-2018 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Noney^ 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) 2018 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Nonez(c) 2018 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None|N$%&$'()*+)*,)*-)*.)*/)*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)_a)_b)_c)_c)_d)_e)_e)_f)_g)_g)_h)_i)_i)_j)_k)_k)_l)_m)_m)_n)_o)_o)_p)_q)_q)_r)_s)_s)_t)_u)_u)_v)_w)_w)_x)_y)_y)_z)_{)_{)_|)_})_})_~)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_)_))))))))))))))))))))))))))))))))))))))))))                ! " # $ % & ' ( ) * +!,!-!.!/!0!1!2!3!4!5!6789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxxyz{|}~                                                                                                         !"#$%&'()*+,-./01234567789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqpqrstuvwxyz{|}~$$$$$$'$'$'$'$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ $ $ $ $ $$$$$$|$$$$$$$ $%!$%"$%#$%$$%%$%&$%'$%($%)$%*$%+$%,$%-$%.$%/$%0$%1$%2$%3$%4$%5$%6$7$8$9$:$;$<=$<=$>?$>@$>A$>B"C"D"E"F"G"H"I"J""K"L$M$N$OPlQ R S TUVWXYWXZWX[WX\WX]WX^WX_WX`WaWbcWdeWfgWhiWhjWklWkmWknWkoWkpWkqWkrWksWktWkuWkvWkwWkxWkyWkzWk{Wk|Wa}Wa~WaWaWdWdWdWdWdWdWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWkWk)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))&speculate-0.3.4-C4S7eP3fMRJIjiEsIyN4SoTest.Speculate.Expr.InstanceTest.Speculate.UtilsTest.SpeculateTest.Speculate.Expr.CoreTest.Speculate.Expr.MatchTest.Speculate.Expr.EquateTest.Speculate.Expr.GroundTest.Speculate.Expr.CanonTest.Speculate.SanityTest.Speculate.Reason.OrderTest.Speculate.ReasonTest.Speculate.SemiReasonTest.Speculate.CondReasonTest.Speculate.PrettyTest.Speculate.EngineTest.Speculate.ArgsTest.Speculate.ReportTest.Speculate.MiscTest.Speculate.FunctionTest.Speculate.Function.A1000Test.Speculate.Function.A100Test.Speculate.Utils.ColourTest.Speculate.Utils.ListTest.Speculate.Utils.ClassTest.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.TypeableTest.Speculate.Utils.DigraphTest.Speculate.Exprbase Data.TypeableTypeRep Data.OldListsortOn&leancheck-0.7.2-EPNsNkdnB3GGru5dgPw3pa Test.LeanCheck.Utils.TypeBindinguint4uint3uint2uint1word4word3word2word1int4int3int2int1natnaturaleithmayborderingstringcharboolrationaldoublefloatintegerintund>-->>>>>>>>>>>>:->>>>>>>>>>>:> ->>>>>>>>>>>: ->>>>>>>>>>:> ->>>>>>>>>>: ->>>>>>>>>:> ->>>>>>>>>: ->>>>>>>>:> ->>>>>>>>: ->>>>>>>:> ->>>>>>>: ->>>>>>:>->>>>>>:->>>>>:>->>>>>:->>>>:>->>>>:->>>:>->>>:->>:>->>:->:>->:-:>-:Test.LeanCheck.Utils.TypesunInt1Int1unInt2Int2unInt3Int3unInt4Int4unWord1Word1unWord2Word2unWord3Word3unWord4Word4 unNaturalNaturalunNatNatunNat1Nat1unNat2Nat2unNat3Nat3unNat4Nat4unNat5Nat5unNat6Nat6unNat7Nat7UInt1UInt2UInt3UInt4NoDupBagSetMapunXXXsTest.LeanCheck.Utils.Operators|==|$==$okNumokEqOrdokOrdokEq neverIdentityidentity idempotentstrictTotalOrder totalOrderstrictPartialOrder partialOrder equivalence asymmetric antisymmetric symmetric irreflexive reflexive transitive symmetric2 distributive associative commutative|||||||&&&&&&&=======Test.LeanCheck.StatscountsOncountsBycounts classifyOn classifyByclassifyconditionStatsTconditionStats classStatsT classStats pairsThatcountfirstshalvenubSort nubSortBy nubMergeBy nubMergeOnnubMerge+++ordIntersectBy ordIntersect nubMerges nubMergesBy nubMergeMap orderedBy orderedOnorderedstrictlyOrderedOnstrictlyOrderedareAllareAnyallLater+-groupOn collectOn collectBy collectWithcollectSndByFstdiscard discardLaterdiscardEarlier discardOthersdiscardByOthers allUniquechainzipWithReverse medianatetakeGreaterHalfaccumpartitionByMarkers! withMemory withMemory2memorymemory2 memoryFor memory2For compareIndexbesideabovetablespacesunquoteatomicouternmostPrecisNegativeLiteralisInfixprecisPrefixisInfixedPrefixtoPrefixprime primeCyclenamesFromTemplate alignRight alignLeftindent splitAtCommas undefined1 undefined2issthnreportCountsBybell maybesToMaybemaybe2 iterateUntiliterateUntilLimit showRatiopercentputLines.:..: productsList mapTMaybeuptoTfilterTS discardTStimeoutToNothing fromTimeouttimeoutToFalse timeoutToTruetimeoutToErrorfst3snd3trd3fst4snd4trd4fth4curry3curry4uncurry3uncurry4uncurry5uncurry6uncurry7uncurry8uncurry9 uncurry10 uncurry11 uncurry12***catPairs compareTytyAritytypesIn finalResultTyunFunTy argumentTyresultTyboolTyfunTyConisFunTymkEqnTyExprConstantVar:$constant showConstantvarholeholeOfTy$$ showsPrecExprisTuple unfoldTuple showsOpExpr showOpExpr showPrecExprshowExpreqExprCommuting lexicompareBy lexicomparecompareComplexityThencompareComplexityfalseEevaluateevaltypetyp typeCorrectarityholesvarsatomicConstantshasVarconstslengthEdepthE countHolescountVar countVarsunrepeatedVars isAssignmentsubexprs subexprsVisSubisConstantNamed unfoldApp $fOrdExpr$fEqExpr $fShowExprBindsfillassign assigningsubrenameBymatchmatch2 matchWithunify unification isInstanceOf hasInstanceOfisCanonInstanceOfhasCanonInstanceOf InstancesInstance instanceTypeinseqordeqOrdlistablenameeqWithordWith listableWithisEqisOrdisEqOrdisEqEisOrdEisEqOrdE isListablefindInfonamestiersEeqEiqEltEleEpreludeInstancesdefNames $fOrdInstance $fEqInstance$fShowInstanceequation phonyEquation unEquation isEquationuselessEquationusefulEquation inequality comparisonLT comparisonLE unComparison implication unImplicationusefulImplicationconditionalEquationunConditionalEquationusefulConditionalEquationconditionalComparisonLEconditionalComparisonLTunConditionalComparisongrounds groundBindsgroundAndBindsequal condEqual condEqualM lessOrEquallessinequaltrue trueBinds trueRatiofalsecanonicalizeWith canonicalize canonicalWitheqErrors ordErrors eqOrdErrorsinstanceErrors|>|>|kboByweight weightExceptgtExcept|>dwoByThyrules equations canReduceTocompareE closureLimitkeepEokThy updateRulesByupdateEquationsBy|==|emptyThykeepUpToLength keepMaxOf normalize normalizeEisNormal reductions1normalizedCriticalPairs criticalPairs equivalentequivalentInstanceinsertappend differencecompletededuceorientdeletesimplifycomposecollapsecanonicalizeEqn canonicalEqn canonicalRuleprintThyshowThyfinalEquationsfinalizetheorize theorizeBy initialize defaultKeepdiscardRedundantEquations$fEqThyShy sequationssthyEquationemptyShyupdateSemiEquationsBymapSemiEquations scompareElessergreater simplerThantransConsequenceupdateSEquationsBy stheorizesidesfinalSemiEquationscanonicalizeShyWithcanonicalizeSemiEquationWithChy cequations cimplicationscclassesunThyemptyChyupdateCEquationsBy listImplied listImplieslistEquivalentreduceRootWithreductions1With creductions1 cnormalize cequivalent cIsInstanceOfcinsertcfiltercdiscardcdelete cfinalizecanonicalizeCEqncanonicalizeCEqnWithcanonicalCEqnBy canonicalCEqnfinalCondEquations prettyThy prettyChy prettyShyprettyEquationsprettySemiEquationsprettyCondEquations vassignmentsexpansionsOfTypeexpansionsWith expansions mostGeneral mostSpecifictheoryFromAtomsrepresentativesFromAtoms!theoryAndRepresentativesFromAtomsconsiderdistinctFromSchemasclassesFromSchemasclassesFromSchemasAndVariablesequivalencesBetweensemiTheoryFromThyAndRepsconditionalTheoryFromThyAndRepsconditionalEquivalencessubConsequencepsortByArgsmaxSizemaxTests constants instances maxSemiSize maxCondSizemaxVars showConstants showEquationsshowSemiequationsshowConditionsshowConstantLaws autoConstantsminTests maxConstantsmaxDepth showCounts showTheoryshowArgsshowHelp evalTimeoutforceextraexclude onlyTypesshowClassesForshowDotquietDotargscomputeMaxSemiSizecomputeMaxCondSizecomputeInstancesshouldShowEquationshouldShowConditionalEquationkeepExprreallyShowConditionsatomstypestimeout compareExpr foreground background prepareArgsgetArgsreport speculate functions1 functions2 functions3 functions4fillings expressionsOfvaluedExpressionsOf funToList areEqualFor compareFor $fOrd(->)$fEq(->)fromHCMColorColourRGBshowRGB coerceRatiomodulofrac.+..-..*.blackwhiteredgreenbluecyanmagentayellowvioletorangelime aquamarineazureindigogreygrey1grey2grey3grey4grey5grey6grey7grey8grey9makeGreyrgbcmychromahue0hue intensityvalue lightness saturation saturationHSV saturationHSL saturationHSIfromRGBfromCMYfromHSVfromHSLfromHCLmixmixHSVprimary'primary secondarytertiaryisGreynotGrey isOppositeToClassmaprepfromRepmergesOn mergesThatmergeghc-prim GHC.ClassesOrd>=minmax><<=compare GHC.TypesOrderingLTEQGTData.Ord comparingDownfit maxLength Data.StringIsString fromStringCharunwordswordsunlineslines Data.Char isSeparatorisNumberisMarkisLetter digitToIntGHC.Read readLitChar lexLitChar GHC.UnicodetoTitletoUppertoLowerisLowerisUpperisPrint isControl isAlphaNumisAlphaisSymbol isPunctuation isHexDigit isOctDigitisDigitisSpace isAsciiUpper isAsciiLowerisLatin1isAsciigeneralCategoryGeneralCategoryControlUppercaseLetterLowercaseLetterTitlecaseLetterModifierLetter OtherLetterNonSpacingMarkSpacingCombiningMark EnclosingMark DecimalNumber LetterNumber OtherNumberConnectorPunctuationDashPunctuationOpenPunctuationClosePunctuation InitialQuote FinalQuoteOtherPunctuation MathSymbolCurrencySymbolModifierSymbol OtherSymbolSpace LineSeparatorParagraphSeparatorFormat Surrogate PrivateUse NotAssignedGHC.CharchrGHC.Show intToDigit showLitCharGHC.BaseStringusTimeoutToNothing Data.TuplefstsndswapuncurrycurryData.Typeable.InternalTypeableTyContypeOf7typeOf6typeOf5typeOf4typeOf3typeOf2typeOf1 rnfTypeReptypeRepFingerprint typeRepTyCon typeRepArgs splitTyConAppmkFunTy funResultTygcast2gcast1gcasteqTcast showsTypeReptypeReptypeOfrnfTyContyConFingerprint tyConName tyConModule tyConPackage Data.ProxyProxyData.Type.Equality:~:Refl:~~:HReflpickDigraphemptysuccspredsisNodeisEdgefilter fromEdgesnarrowShowJustNothingrepVarsins1-==>--&&->=\/classesFromSchemaallAbout&cmdargs-0.10.20-DuSx78jNQymI404wla4i2pSystem.Console.CmdArgs.ExplicitflagHelpFormatflagHelpSimpleflagNumericVersion flagVersionflagsVerbosity processArgs processValueprocessValueIO(System.Console.CmdArgs.Explicit.Complete,System.Console.CmdArgs.Explicit.ExpandArgsAt expandArgsAt$System.Console.CmdArgs.Explicit.HelphelpText'System.Console.CmdArgs.Explicit.Processprocess)System.Console.CmdArgs.Explicit.SplitJoinjoinArgs splitArgs$System.Console.CmdArgs.Explicit.Type checkModeflagArgflagBoolflagNoneflagOptflagReq fromFlagOpt fromGroupmode modeEmpty modeFlags modeModesmodes parseBoolremap2 remapUpdatetoGroupComplete CompleteDir CompleteFile CompleteValue HelpFormat HelpFormatAllHelpFormatBashHelpFormatDefault HelpFormatOne HelpFormatZshArg argRequireargTypeargValueFlagflagHelpflagInfo flagNamesflagType flagValueFlagHelpFlagInfoFlagNoneFlagOpt FlagOptRareFlagReqGroup groupHidden groupNamed groupUnnamedHelpModemodeArgs modeCheck modeExpandAtmodeGroupFlagsmodeGroupModesmodeHelpmodeHelpSuffix modeNames modeReform modeValueNameRemapremapUpdateTest.LeanCheck.Tiers listsOfLengthsetsOfbagsOf noDupListsOf normalizeTdeleteTproductslistsOfproductMaybeWith product3With noDupListConsmapConssetConsbagConsTest.LeanCheck.IOcheckResultFor checkResultcheckForcheckTest.LeanCheck.DerivederiveListableCascadingderiveListableTest.LeanCheck.Basic addWeightofWeightcons12cons11cons10cons9cons8cons7cons6Test.LeanCheck.Core==>existsfailsholdswitness witnessescounterExamplecounterExamplesresults productWith><\\//\/+|suchThatresetdelaycons5cons4cons3cons2cons1cons0 concatMapTconcatTfilterTmapTtiersFractional listIntegraltoTiersListablelisttiersTestable