!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJK 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) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe" values are functions of / arguments that return boolean values, e.g.:  Bool  Listable a => a -> Bool  Listable a => a -> a -> Bool  Int -> Bool  String -> [Int] -> Bool A type is R when there exists a function that is able to list (ideally all of) its values.*Ideally, instances should be defined by a  function that returns a (potentially infinite) list of finite sub-lists (tiers): the first sub-list contains elements of size 0, the second sub-list contains elements of size 1 and so on. Size here is defined by the implementor of the type-class instance./For algebraic data types, the general form for  is btiers = cons<N> ConstructorA \/ cons<N> ConstructorB \/ ... \/ cons<N> ConstructorZwhere N0 is the number of arguments of each constructor A...Z.*Instances can be alternatively defined by ". In this case, each sub-list in 2 is a singleton list (each succeeding element of  has +1 size). The function  from Test.LeanCheck.Derive7 can automatically derive instances of this typeclass.A S instance for functions is also available but is not exported by default. Import Test.LeanCheck.Function. if you need to test higher-order properties.Takes a list of values xsX and transform it into tiers on which each tier is occupied by a single element from xs. To convert back to a list, just . Tiers of 7 values. Can be used as a default implementation of  for  types. Tiers of 6 values. This can be used as the implementation of  for  types. over tiers  tiers  tiers of tiers  over tiers 2Given a constructor with no arguments, returns  of all possible applications of this constructor. Since in this case there is only one possible application (to no arguments), only a single value, of size/weight 0, will be present in the resulting list of tiers. Given a constructor with one  argument, return ` of applications of this constructor. By default, returned values will have size/weight of 1.Given a constructor with two  arguments, return ` of applications of this constructor. By default, returned values will have size/weight of 1.:Returns tiers of applications of a 3-argument constructor.:Returns tiers of applications of a 4-argument constructor.:Returns tiers of applications of a 5-argument constructor.Test.LeanCheck.Basic defines  up to &. Those are exported by default from Test.LeanCheck1, but are hidden from the Haddock documentation.wResets the weight of a constructor (or tiers) Typically used as an infix constructor when defining Listable instances: cons<N> `ofWeight` <W>Be careful: do not apply  0 to recursive data structure constructors. In general this will make the list of size 0 infinite, breaking the tier invariant (each tier must be finite).,Adds to the weight of tiers of a constructor&Tiers of values that follow a property cons<N> `suchThat` conditionoLazily interleaves two lists, switching between elements of the two. Union/sum of the elements in the lists. #[x,y,z] +| [a,b,c] == [x,a,y,b,z,c]/Append tiers --- sum of two tiers enumerations. =[xs,ys,zs,...] \/ [as,bs,cs,...] = [xs++as,ys++bs,zs++cs,...]JInterleave tiers --- sum of two tiers enumerations. When in doubt, use  instead. =[xs,ys,zs,...] \/ [as,bs,cs,...] = [xs+|as,ys+|bs,zs+|cs,...](Take a tiered product of lists of tiers. [t0,t1,t2,...] >< [u0,u1,u2,...] = [ t0**u0 , t0**u1 ++ t1**u0 , t0**u2 ++ t1**u1 ++ t2**u0 , ... ... ... ... ] where xs ** ys = [(x,y) | x <- xs, y <- ys]Example: [[0],[1],[2],...] >< [[0],[1],[2],...] == [ [(0,0)] , [(1,0),(0,1)] , [(2,0),(1,1),(0,2)] , [(3,0),(2,1),(1,2),(0,3)] ... ],Take a tiered product of lists of tiers.  can be defined by , as: 4productWith f xss yss = map (uncurry f) $ xss >< yssList all results of a Q property. Each result is a pair of a list of strings and a boolean. The list of strings is a printable representation of one possible choice of argument values for the property. Each boolean paired with such a list indicates whether the property holds for this choice. The outer list is potentially infinite and lazily evaluated.?Lists all counter-examples for a number of tests to a property,2Up to a number of tests to a property, returns ! the first counter-example or  if there is none. LcounterExample 100 $ \xs -> [] `union` xs == (xs::[Int]) -- > Just ["[0,0]"]:Lists all witnesses up to a number of tests to a property,2Up to a number of tests to a property, returns  the first witness or  if there is none.Does a property hold up to a number of test values? 1holds 1000 $ \xs -> length (sort xs) == length xs Does a property fail for a number of test values? (fails 1000 $ \xs -> xs ++ ys == ys ++ xs!There existsT an assignment of values that satisfies a property up to a number of test values? exists 1000 $ \x -> x > 10"JBoolean implication operator. Useful for defining conditional properties: 4prop_something x y = condition x y ==> something x y)Instances for ; sixtuples up to 12-tuples are exported by default form Test.LeanCheckO but are hidden from Haddock documentation. These instances are defined in Test.LeanCheck.Basic., ?list :: [(Int,Int)] = [(0,0), (0,1), (1,0), (0,-1), (1,1), ...]7  !"#$%&'()*+,-./0123#  !"# !  "4  !"#$%&'()*+,-./01235778"0(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe4&Checks a property printing results on stdout > check $ \xs -> sort (sort xs) == sort (xs::[Int]) +++ OK, passed 200 tests. > check $ \xs ys -> xs `union` ys == ys `union` (xs::[Int]) *** Failed! Falsifiable (after 4 tests): [] [0,0]5DCheck a property for a given number of tests printing results on stdout6(Check a property printing results on stdout and returning  on success.JThere is no option to silence this function: for silence, you should use .7DCheck a property for a given number of tests printing results on stdout and returning  on success.JThere is no option to silence this function: for silence, you should use . 4567456745674567(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe::(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Safe;<=>?@ABCDEFGHIJ*  !";<=>?@A;<=>?@A;<=>?@ABCDEFGHIJ(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneK Derives a  instance for a given type .Consider the following Stack datatype: (data Stack a = Stack a (Stack a) | EmptyWriting deriveListable ''Stack(will automatically derive the following  instance: Tinstance Listable a => Listable (Stack a) where tiers = cons2 Stack \/ cons0 Empty Needs the TemplateHaskell extension.LSame as K4 but does not warn when instance already exists (K is preferable).M Derives a  instance for a given type 3 cascading derivation of type arguments as well.gGiven a type name, return the number of arguments taken by that type. Examples in partially broken TH: arity ''Int === Q 0 arity ''Int->Int === Q 0 arity ''Maybe === Q 1 arity ''Either === Q 2 arity ''Int-> === Q 1ZThis works for Data's and Newtype's and it is useful when generating typeclass instances.KLMKLMKLMKLM(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>SafeN[Given a constructor that takes a list, return tiers of applications of this constructor./This is basically a type-restricted version of  . You should use  6 instead: this serves more as an illustration of how P and O work (see source).OqGiven a constructor that takes a bag of elements (as a list), lists tiers of applications of this constructor.For example, a Bag represented as a list.  bagCons BagPqGiven a constructor that takes a set of elements (as a list), lists tiers of applications of this constructor.A naive  instance for the  (of Data.Set) would read: Sinstance Listable a => Listable (Set a) where tiers = cons0 empty \/ cons2 insertThe above instance has a problem: it generates repeated sets. A more efficient implementation that does not repeat sets is given by:  tiers = setCons fromListAlternatively, you can use f direclty.QvGiven a constructor that takes a list with no duplicate elements, return tiers of applications of this constructor.ULike , but over 3 lists of tiers.VLike , but over 3 lists of tiers.W@Take the product of lists of tiers by a function returning a  value discarding  values.XbTakes as argument tiers of element values; returns tiers of pairs with distinct element values..When argument tiers have no repeated elements: 9distinctPairs xss = xss >< xss `suchThat` uncurry (/=)YX by a given function: 6distinctPairsWith f = mapT (uncurry f) . distinctPairsZTakes as argument tiers of element values; returns tiers of unordered pairs where, in enumeration order, the first element is less than or equal to the second.The name of this function is perhaps a misnomer. But in mathematics, an unordered pair is a pair where you don't care about element order, e.g.:  (1,2) = (2,1)r. This function will enumerate canonical versions of such pairs where the first element is less than the second.AThe returned element pairs can be seen as bags with two elements."When argument tiers are listed in : 9distinctPairs xss = xss >< xss `suchThat` uncurry (<=)[Z by a given function: 8unorderedPairsWith f = mapT (uncurry f) . unorderedPairs\Takes as argument tiers of element values; returns tiers of unordered pairs where, in enumeration order, the first element is strictly less than the second.AThe returned element pairs can be seen as sets with two elements."When argument tiers are listed in : 8distinctPairs xss = xss >< xss `suchThat` uncurry (<)]Z by a given function: HunorderedDistinctPairsWith f = mapT (uncurry f) . unorderedDistinctPairs^QTakes as argument tiers of element values; returns tiers of lists of elements. listsOf [[]] == [[[]]] listsOf [[x]] == [ [[]] , [[x]] , [[x,x]] , [[x,x,x]] , ... ] listsOf [[x],[y]] == [ [[]] , [[x]] , [[x,x],[y]] , [[x,x,x],[x,y],[y,x]] , ... ]_CTakes the product of N lists of tiers, producing lists of length N.Alternatively, takes as argument a list of lists of tiers of elements; returns lists combining elements of each list of tiers. products [xss] = mapT (:[]) xss products [xss,yss] = mapT (\(x,y) -> [x,y]) (xss >< yss) products [xss,yss,zss] = product3With (\x y z -> [x,y,z]) xss yss zss`3Delete the first occurence of an element in a tier.3For tiers without repetitions, the following holds: ,deleteT x = normalizeT . (`suchThat` (/= x))aNNormalizes tiers by removing an empty tier from the end of a list of tiers. 3normalizeT [xs0,xs1,...,xsN,[]] = [xs0,xs1,...,xsN]/Note this will only remove a single empty tier: 9normalizeT [xs0,xs1,...,xsN,[],[]] = [xs0,xs1,...,xsN,[]]bConcatenate tiers of maybesd_Takes as argument tiers of element values; returns tiers of lists with no repeated elements. vnoDupListsOf [[0],[1],[2],...] == [ [[]] , [[0]] , [[1]] , [[0,1],[1,0],[2]] , [[0,2],[2,0],[3]] , ... ]ewTakes as argument tiers of element values; returns tiers of size-ordered lists of elements possibly with repetition. bagsOf [[0],[1],[2],...] = [ [[]] , [[0]] , [[0,0],[1]] , [[0,0,0],[0,1],[2]] , [[0,0,0,0],[0,0,1],[0,2],[1,1],[3]] , [[0,0,0,0,0],[0,0,0,1],[0,0,2],[0,1,1],[0,3],[1,2],[4]] , ... ]fqTakes as argument tiers of element values; returns tiers of size-ordered lists of elements without repetition. setsOf [[0],[1],[2],...] = [ [[]] , [[0]] , [[1]] , [[0,1],[2]] , [[0,2],[3]] , [[0,3],[1,2],[4]] , [[0,1,2],[0,4],[1,3],[5]] , ... ].Can be used in the constructor of specialized  instances. For  (from Data.Set), we would have: Tinstance Listable a => Listable (Set a) where tiers = mapT fromList $ setsOf tiersgTLists tiers of choices. Choices are pairs of values and tiers excluding that value. choices [[False,True]] == [[(False,[[True]]),(True,[[False]])]] choices [[1],[2],[3]] == [ [(1,[[],[2],[3]])] , [(2,[[1],[],[3]])] , [(3,[[1],[2],[]])] ].Each choice is sized by the extracted element.Like g, but allows a custom function.hLike gM but lists tiers of non-decreasing (ascending) choices. Used to construct e values. MbagChoices [[False,True]] = [ [(False,[[False,True]]), (True,[[True]])] ] ~bagChoices [[1],[2],[3],...] = [ [(1,[[1],[2],[3],...])] , [(2,[[ ],[2],[3],...])] , [(3,[[ ],[ ],[3],...])] , ... ]Like h but customized by a function.iLike gE but lists tiers of strictly ascending choices. Used to construct f values. setChoices [[False,True]] == [[(False,[[True]]),(True,[[]])]] setChoices [[1],[2],[3]] == [ [(1,[[],[2],[3]])] , [(2,[[],[],[3]])] , [(3,[[],[],[]])] ]Like i but customized by a function.jTakes as argument an integer length and tiers of element values; returns tiers of lists of element values of the given length. listsOfLength 3 [[0],[1],[2],[3],[4]...] = [ [[0,0,0]] , [[0,0,1],[0,1,0],[1,0,0]] , [[0,0,2],[0,1,1],[0,2,0],[1,0,1],[1,1,0],[2,0,0]] , ... ] NOPQRSTUVWXYZ[\]^_`abcdefghijNOPQRSTUVWXYZ[\]^_`abcdefghijNPOQRSTUVW^efd_jXYZ[\]`abcgih NOPQRSTUVWXYZ[\]^_`abcdefghij(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None<  !"4567;<=>?@AKMOPQVW^_`adefj< !"4567 ;<=>?@A `aKMPOQVW^fed_j(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NonerTakes a value and a function. Ignores the value. Binds the argument of the function to the type of the value.kTransforms a value into  that value or  on some errors:ArithExceptionArrayException ErrorCallPatternMatchFaillTransforms a value into  that value or  on error.klmnopqrstuvwA "4567;<=>?@AKMOPQVW^_`adefjklmnopqrstuvw pqrsutvwokmnlklmnopqrstuvw(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None|-Natural numbers modulo 7: 0, 1, 2, 3, 4, 5, 6*Natural numbers modulo 6: 0, 1, 2, 3, 4, 5'Natural numbers modulo 5: 0, 1, 2, 3, 4$Natural numbers modulo 4: 0, 1, 2, 3!Natural numbers modulo 3: 0, 1, 2Natural numbers modulo 2: 0, 1Natural numbers modulo 1: 0:Natural numbers (including 0): 0, 1, 2, 3, 4, 5, 6, 7, ...+Internally, this type is represented as an . So, it is limited by the  of .QFour-bit unsigned integers: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 153Three-bit unsigned integers: 0, 1, 2, 3, 4, 5, 6, 7%Two-bit unsigned integers: 0, 1, 2, 3!Single-bit unsigned integer: 0, 1QFour-bit signed integers: -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 75Three-bit signed integers: -4, -3, -2, -1, 0, 1, 2, 3%Two-bit signed integers: -2, -1, 0, 1!Single-bit signed integers: -1, 0xyz{|}~      !"#$%&'()*+,-./0123456789      !"#$%&'()*4xyz{|}~4|}~{zyxxyz{|}~      !"#$%&'()*+,-./0123456789      !"#$%&'()* (c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None KvType restricted version of const that forces its first argument to have the same type as the second. A symnonym to ::  value -: ty = value :: Ty Examples: P 10 -: int = 10 :: Int undefined -: 'a' >- 'b' = undefined :: Char -> CharLvType restricted version of const that forces the argument of its first argument to have the same type as the second: - f -:> ty = f -: ty >- und = f :: Ty -> aExample: 9 abs -:> int = abs -: int >- und = abs :: Int -> IntMtType restricted version of const that forces the result of its first argument to have the same type as the second. - f ->: ty = f -: und >- ty = f :: a -> TyN}Type restricted version of const that forces the second argument of its first argument to have the same type as the second. :f ->:> ty = f -: und -> ty -> und = f :: a -> Ty -> bOType restricted version of const that forces the result of the result of its first argument to have the same type as the second. :f ->>: ty = f -: und -> und -> ty = f :: a -> b -> TyP|Type restricted version of const that forces the third argument of its first argument to have the same type as the second.QType restricted version of const that forces the result of the result of the result of its first argument to have the same type as the second.RReturns an undefined functional value that takes an argument of the type of its first argument and return a value of the type of its second argument. $ty >- ty = (undefined :: Ty -> Ty) Examples: r'a' >- 'b' = char >- char = (undefined :: Char -> Char) int >- bool >- int = undefined :: Int -> Bool -> IntSShorthand for undefined[It might be better to just use ;KLMNOPQRSTUVWXYZ[\]^_`abcdeKLMNOPQRSTUVWXYZ[\]^_`abcdeKLMNOPQSRXTUVWYZ[\]^b_c`dae;KLMNOPQRSTUVWXYZ[\]^_`abcdeK1L1M1N1O1P1Q1R9  (c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneffK values are those for which we can return a list of functional bindings.As a user, you probably want k and l..Non functional instances should be defined by: 8instance ShowFunction Ty where tBindings = tBindingsShowh*A functional binding in a showable format.iGiven a f= value, return a list of bindings for printing. Examples: .bindings True == [([],True)] bindings (id::Int) == [(["0"],"0"), (["1"],"1"), (["-1"],"-1"), ... bindings (&&) == [ (["False","False"], "False") , (["False","True"], "False") , (["True","False"], "False") , (["True","True"], "True") ]j2A default implementation of tBindings for already < -able types.k,Given a number of patterns to show, shows a f value. 6showFunction undefined True == "True" showFunction 3 (id::Int) == "\\x -> case x of\n\ \ 0 -> 0\n\ \ 1 -> 1\n\ \ -1 -> -1\n\ \ ...\n" showFunction 4 (&&) == "\\x y -> case (x,y) of\n\ \ (False,False) -> False\n\ \ (False,True) -> False\n\ \ (True,False) -> False\n\ \ (True,True) -> True\n"<This can be used as an implementation of show for functions: Zinstance (Show a, Listable a, ShowFunction b) => Show (a->b) where show = showFunction 8l-Same as showFunction, but has no line breaks. BshowFunction 2 (id::Int) == "\\x -> case x of 0 -> 0; 1 -> 1; ..."=uisUndefined checks if a function is totally undefined. When it is not possible to check all values, it returns false2fghij>?@ABCkl=Dmnopqrstuvwxyz{|}~fghijklklhifgj1fghij>?@ABCkl=Dmnopqrstuvwxyz{|}~ (c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None (c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None"Is a given operator commutative?  x + y = y + x holds n $ commutative (+) 4fails n $ commutative union -- union [] [0,0] = [0]"Is a given operator associative? x + (y + z) = (x + y) + z5Does the first operator, distributes over the second?1Are two operators flipped versions of each other? Qholds n $ (<) `symmetric2` (>) -:> int holds n $ (<=) `symmetric2` (>=) -:> int Qfails n $ (<) `symmetric2` (>=) -:> int fails n $ (<=) `symmetric2` (>) -:> intIs a given relation transitive?'An element is always related to itself.An element is never related to itself.EIs a given relation symmetric? This is a type-restricted version of .]Is a given relation antisymmetric? Not to be confused with "not symmetric" and "assymetric".]Is a given relation asymmetric? Not to be confused with "not symmetric" and "antissymetric"."Is the given function idempotent?  f (f x) == x 2holds n $ idempotent abs holds n $ idempotent sort fails n $ idempotent negate#Is the given function an identity? f x == x Xholds n $ identity (+0) holds n $ identity (sort :: [()]) holds n $ identity (not . not))Is the given function never an identity? f x /= x holds n $ neverIdentity not Cfails n $ neverIdentity negate -- yes, fails: negate 0 == 0, hah!4Note: this is not the same as not being an identity.8Equal under, a ternary operator with the same fixity as E. x =$ f $= y = f x = f y n[1,2,3,4,5] =$ take 2 $= [1,2,4,8,16] -- > True [1,2,3,4,5] =$ take 3 $= [1,2,4,8,16] -- > False [1,2,3] =$ sort $= [3,2,1] -- > True 42 =$ (`mod` 10) $= 16842 -- > True 42 =$ (`mod` 9) $= 16842 -- > False 'a' =$ isLetter $= 'b' -- > True 'a' =$ isLetter $= '1' -- > FalseSee !Check if two lists are equal for n1 values. This operator has the same fixity of E. (xs =| n |= ys = take n xs == take n ys V[1,2,3,4,5] =| 2 |= [1,2,4,8,16] -- > True [1,2,3,4,5] =| 3 |= [1,2,4,8,16] -- > FalseSee "FG  "FG 4433G3224444(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>Noneoxyz{|}~KLMNOPQRSTUVWXYZ[\]^_`abcde (c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneGiven a list of domain values, and tiers of codomain values, return tiers of lists of ordered pairs of domain and codomain values.6Technically: tiers of left-total functional relations.Given tiers of input values and tiers of output values, return tiers with all possible lists of input-output pairs. Those represent functional relations.HReturns a function given by a list of input-output pairs. The result is wrapped in a maybe value. The output for bound inputs is , a value. The output for unbound inputs is .AReturns a partial function given by a list of input-output pairs.FNOTE: This function *will* return undefined values for unbound inputs.IMReturns a function given by a list of input-output pairs and a default value.JHIJHI(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None(c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None 9 (c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>None   (c) 2015-2017 Rudy Matela$3-Clause BSD (see the file LICENSE) Rudy Matela <rudy@matela.com.br>NoneKcheck if a list is orderedL7check if a list is ordered by a given ordering functionM@check if a list is strictly ordered by a given ordering functionNchecks if the first n" elements on tiers are ordered by cmp. ,(n `seriesOrderedBy`) comparing (id :: Type)KOLPMQRSNTUVWXYZ[\]^_KOLPMQUVWXYZ\]^_KOLPMQRSNTUVWXYZ[\]^_S9 N9 T9 [9 ` !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~:;79685      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHI 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 { | } ~                                                           ]^_` !"#$%&'()*+,-./0123456789:;<=> ?@A B C D E F G H IJ K L M N OPQRSTUVWXYZ[\]^_`abcd&leancheck-0.6.2-6IVGN0lIs8fFZoCjcfypt2Test.LeanCheck.CoreTest.LeanCheck.IOTest.LeanCheck.Function.EqTest.LeanCheck.BasicTest.LeanCheck.DeriveTest.LeanCheck.TiersTest.LeanCheck.ErrorTest.LeanCheck.Utils.Types Test.LeanCheck.Utils.TypeBinding$Test.LeanCheck.Function.ShowFunctionTest.LeanCheck.Function.ShowTest.LeanCheck.Utils.Operators$Test.LeanCheck.Function.ListsOfPairs"Test.LeanCheck.Function.CoListable Test.LeanCheck.Function.PeriodicderiveListablecons6cons12TestLean.CheckholdsTest.LeanCheckData.SetSetTest.LeanCheck.UtilsTest.LeanCheck.FunctionTest.LeanCheck.InvariantsTestable resultiersListabletierslisttoTiers listIntegraltiersFractionalmapTfilterTconcatT concatMapTcons0cons1cons2cons3cons4cons5ofWeight addWeightsuchThat+|\/\\//>< productWithresultscounterExamplescounterExample witnesseswitnessfailsexists==>$fTestable(->)$fTestableBool$fListableOrdering$fListableDouble$fListableFloat $fListable[]$fListable(,,,,)$fListable(,,,)$fListable(,,) $fListable(,)$fListableEither$fListableMaybe$fListableBool$fListableChar$fListableInteger $fListableInt $fListable()checkcheckFor checkResultcheckResultFor $fEqResult $fShowResult$fEq(->)cons7cons8cons9cons10cons11$fListableWord$fListableRatio$fListable(,,,,,,,,,,,)$fListable(,,,,,,,,,,)$fListable(,,,,,,,,,)$fListable(,,,,,,,,)$fListable(,,,,,,,)$fListable(,,,,,,)$fListable(,,,,,)deriveListableIfNeededderiveListableCascadinglistConsbagConssetCons noDupListCons maybeCons0 maybeCons1 maybeCons2product3 product3WithproductMaybeWith distinctPairsdistinctPairsWithunorderedPairsunorderedPairsWithunorderedDistinctPairsunorderedDistinctPairsWithlistsOfproductsdeleteT normalizeT catMaybesT mapMaybeT noDupListsOfbagsOfsetsOfchoices bagChoices setChoices listsOfLengtherrorToNothinganyErrorToNothing errorToFalse errorToTrue fromErrorUInt4UInt3UInt2UInt1Nat7unNat7Nat6unNat6Nat5unNat5Nat4unNat4Nat3unNat3Nat2unNat2Nat1unNat1NatunNatWord4unWord4Word3unWord3Word2unWord2Word1unWord1Int4unInt4Int3unInt3Int2unInt2Int1unInt1$fListableNat7$fListableNat6$fListableNat5$fListableNat4$fListableNat3$fListableNat2$fListableNat1 $fListableNat$fListableWord4$fListableWord3$fListableWord2$fListableWord1$fListableInt4$fListableInt3$fListableInt2$fListableInt1 $fEnumNat7 $fEnumNat6 $fEnumNat5 $fEnumNat4 $fEnumNat3 $fEnumNat2 $fEnumNat1 $fEnumNat $fEnumWord4 $fEnumWord3 $fEnumWord2 $fEnumWord1 $fEnumInt4 $fEnumInt3 $fEnumInt2 $fEnumInt1 $fBoundedNat7 $fBoundedNat6 $fBoundedNat5 $fBoundedNat4 $fBoundedNat3 $fBoundedNat2 $fBoundedNat1$fBoundedWord4$fBoundedWord3$fBoundedWord2$fBoundedWord1 $fBoundedInt4 $fBoundedInt3 $fBoundedInt2 $fBoundedInt1$fIntegralNat7$fIntegralNat6$fIntegralNat5$fIntegralNat4$fIntegralNat3$fIntegralNat2$fIntegralNat1 $fIntegralNat$fIntegralWord4$fIntegralWord3$fIntegralWord2$fIntegralWord1$fIntegralInt4$fIntegralInt3$fIntegralInt2$fIntegralInt1 $fRealNat7 $fRealNat6 $fRealNat5 $fRealNat4 $fRealNat3 $fRealNat2 $fRealNat1 $fRealNat $fRealWord4 $fRealWord3 $fRealWord2 $fRealWord1 $fRealInt4 $fRealInt3 $fRealInt2 $fRealInt1 $fNumNat7 $fNumNat6 $fNumNat5 $fNumNat4 $fNumNat3 $fNumNat2 $fNumNat1$fNumNat $fNumWord4 $fNumWord3 $fNumWord2 $fNumWord1 $fNumInt4 $fNumInt3 $fNumInt2 $fNumInt1 $fReadNat7 $fReadNat6 $fReadNat5 $fReadNat4 $fReadNat3 $fReadNat2 $fReadNat1 $fReadNat $fReadWord4 $fReadWord3 $fReadWord2 $fReadWord1 $fReadInt4 $fReadInt3 $fReadInt2 $fReadInt1 $fShowNat7 $fShowNat6 $fShowNat5 $fShowNat4 $fShowNat3 $fShowNat2 $fShowNat1 $fShowNat $fShowWord4 $fShowWord3 $fShowWord2 $fShowWord1 $fShowInt4 $fShowInt3 $fShowInt2 $fShowInt1$fEqInt1 $fOrdInt1$fEqInt2 $fOrdInt2$fEqInt3 $fOrdInt3$fEqInt4 $fOrdInt4 $fEqWord1 $fOrdWord1 $fEqWord2 $fOrdWord2 $fEqWord3 $fOrdWord3 $fEqWord4 $fOrdWord4$fEqNat$fOrdNat$fEqNat1 $fOrdNat1$fEqNat2 $fOrdNat2$fEqNat3 $fOrdNat3$fEqNat4 $fOrdNat4$fEqNat5 $fOrdNat5$fEqNat6 $fOrdNat6$fEqNat7 $fOrdNat7-:-:>->:->:>->>:->>:>->>>:>-undintintegerfloatdoubleboolcharstringmaybeithnatint1int2int3int4uint1uint2uint3uint4 ShowFunction tBindingsBindingbindings tBindingsShow showFunctionshowFunctionLine$fShowFunctionWord4$fShowFunctionWord3$fShowFunctionWord2$fShowFunctionWord1$fShowFunctionInt4$fShowFunctionInt3$fShowFunctionInt2$fShowFunctionInt1$fShowFunctionNat7$fShowFunctionNat6$fShowFunctionNat5$fShowFunctionNat4$fShowFunctionNat3$fShowFunctionNat2$fShowFunctionNat1$fShowFunctionNat$fShowFunction(,,,,,,,)$fShowFunction(,,,,,,)$fShowFunction(,,,,,)$fShowFunction(,,,,)$fShowFunction(,,,)$fShowFunction(,,)$fShowFunction(->)$fShowFunction(,)$fShowFunctionEither$fShowFunctionMaybe$fShowFunction[]$fShowFunctionOrdering$fShowFunctionDouble$fShowFunctionFloat$fShowFunctionChar$fShowFunctionInteger$fShowFunctionInt$fShowFunctionBool$fShowFunction() $fShow(->)=======&&&&&&&||||||| commutative associative distributive symmetric2 transitive reflexive irreflexive symmetric antisymmetric asymmetric equivalence partialOrderstrictPartialOrder totalOrderstrictTotalOrder comparison idempotentidentity neverIdentityokEqokOrdokEqOrd=$$==||= associations functionPairspairsToFunctiondefaultFunPairsToFunction$fListable(->) CoListablecotiers\+:/alts0alts1alts2alts3ftiers$fCoListableInt$fCoListable[]$fCoListableEither$fCoListableMaybe$fCoListableBool$fCoListable() functions functionsz lsPeriodsOflsPeriodsOfLimitisPeriod isPeriodOf tiersOfLimitbase Data.FoldableconcatGHC.RealIntegral FractionalGHC.BasemapGHC.Listfilter concatMapJustNothinguncurry3uncurry4uncurry5ghc-prim GHC.TypesTrueResultOK Falsified Exception resultsIOresultIO showResultuncurry6uncurry7uncurry8uncurry9 uncurry10 uncurry11 uncurry12template-haskellLanguage.Haskell.TH.SyntaxName typeArityderiveListableXreallyDeriveListablereallyDeriveListableCascading typeConArgstypeConArgsThattypeConCascadingArgsThat normalizeTypenormalizeTypeUnits isInstanceOfisntInstanceOftypeConstructors isTypeSynonymtypeSynonymType|=>|nubMerge nubMergesMaybe GHC.ClassesOrd choicesWithbagChoicesWithsetChoicesWithbindArgumentTypeIntGHC.EnummaxBoundnarrowUnarrowSmapTuplemapFstoNewtypefNewtype otNewtypereadsPrecNewtypeboundedEnumFromboundedEnumFromThenword1word2word3word4nat1nat2nat3nat4nat5nat6nat7oInt1oInt2oInt3oInt4oWord1oWord2oWord3oWord4oNatoNat1oNat2oNat3oNat4oNat5oNat6oNat7fInt1fInt2fInt3fInt4fWord1fWord2fWord3fWord4fNatfNat1fNat2fNat3fNat4fNat5fNat6fNat7asTypeOf undefinedOfGHC.ShowShow isUndefinedparen varnamesFor showTupleshowNBindingsOfisValue showValueOf showFunctionL==combine&&&&&pairsToMaybeFunctiondefaultPairsToFunctionordered orderedBystrictlyOrderedBy tOrderedBystrictlyOrdered orderedOnstrictlyOrderedOnifNotEqthntStrictlyOrderedBy tNatPairOrd tNatTripleOrdtNatQuadrupleOrdtNatQuintupleOrdtNatSixtupleOrd tNatListOrdtListsOfStrictlyOrderedBytListsOfNatOrd tPairEqParamstTripleEqParamstProductsIsFilterByLength