@      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _ ` 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 { | } ~  Safe values are functions of / arguments that return boolean values, e.g.:  Bool  Int -> Bool  Listable a => a -> a -> Bool A type is R when there exists a function that is able to list (ideally all of) its values.*Ideally, this type should be defined by a  function that returns a (possibly 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: \tiers = consN ConstructorA \/ consN ConstructorB \/ consN ConstructorC \/ ...When defined by , each sub-list in ' is a singleton list (each element of  has +1 size). The function  from Test.Check.Derive7 can automatically derive instances of this typeclass.A S instance for functions is also available but is not exported by default. Import Test.Check.Function for that. (Test.Check.Function.Show# for a Show instance for functions)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 6 values. This can be used as the implementation of  for  types. over tiers tiers  tiers of tiers  over tiers {Takes a constructor with no arguments and return tiers (with a single value). This value, by default, has size/weight 0. sTakes a constructor with one argument and return tiers of that value. This value, by default, has size/weight 1. tTakes a constructor with two arguments and return tiers of that value. This value, by default, has size/weight 1.wResets the weight of a constructor (or tiers) Typically used as an infix constructor when defining Listable instances: cons<N> `ofWeight` WBe 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. =[xs,ys,zs,...] \/ [as,bs,cs,...] = [xs++as,ys++bs,zs++cs,...]&Interleave tiers. 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 the product of two lists of tiers. 4productWith f xss yss = map (uncurry f) $ xss >< yssList all results of a  property. Each results is composed by a list of strings and a boolean. The list of strings represents the arguments applied to the function. The boolean tells whether the property holds for that selection of argument. This list is usually infinite.?Lists all counter-examples for a number of tests to a property,ZFor a number of tests to a property, returns Just the first counter-example or Nothing.8Lists all witnesses for a number of tests to a property,RFor a number of tests to a property, returns Just the first witness or Nothing.Does a property hold for a number of test values? 1holds 1000 $ \xs -> length (sort xs) == length xsDoes a property fail for a number of test values? (fails 1000 $ \xs -> xs ++ ys == ys ++ xs There exists2 and assignment of values that satisfy a property?!CBoolean implication. Use this for defining conditional properties: 4prop_something x y = condition x y ==> something x y6  !"  !"   !3  !!Safe"#$%&'()  !"#$%&'("#$%&'("#$%&'(Safe)PGiven a constructor for a type that takes a list, return tiers for that type.+Given a constructor for a type that takes a list with strictly ascending elements, return tiers of that type (e.g.: a Set type).,xGiven a constructor for a type that takes a set of elements (as a list) return tiers of that type (e.g.: a Set type).-jGiven a constructor for a type that takes a list with no duplicate elements, return tiers of that type..Like , but over 3 lists of tiers./ITake the product of lists of tiers by a function returning a maybe value.0=Given tiers of values, returns tiers of lists of those values listsOf [[]] == [[[]]] listsOf [[x]] == [ [[]] , [[x]] , [[x,x]] , [[x,x,x]] , ... ] listsOf [[x],[y]] == [ [[]] , [[x]] , [[x,x],[y]] , [[x,x,x],[x,y],[y,x]] , ... ]1)Generates several lists of the same size. products [ xss, yss, zss ] ==@Tiers of all lists combining elements of tiers: xss, yss and zss2UDelete the first occurence of an element in a tier, for tiers without repetitions: .deleteT x === normalizeT . (`suchThat` (/= x))4HGiven tiers of 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]] , ... ]5mLists tiers of all choices of values from tiers. 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 5, but allows a custom function.6Given tiers of values, returns tiers of lists of elements in ascending order (from tiered enumeration).8Given tiers of values, returns tiers of lists of elements in strictly ascending order (from tiered enumeration). If you only care about whether elements are in returned lists, this returns the tiers of all sets of values. strictlyAscendingListsOf [[0],[1],[2],...] == [ [[]] , [[0]] , [[1]] , [[0,1],[2]] , [[0,2],[3]] , [[0,3],[1,2],[4]] , [[0,1,2],[0,4],[1,3],[5]] , ... ]9ZReturns tiers of sets represented as lists of values (no repeated sets). Shorthand for 8.:Like 5N, but paired tiers are always strictly ascending (in terms of enumeration). strictlyAscendingChoices [[False,True]] == [[(False,[[True]]),(True,[[]])]] strictlyAscendingChoices [[1],[2],[3]] == [ [(1,[[],[2],[3]])] , [(2,[[],[],[3]])] , [(3,[[],[],[]])] ]Like : but customized by a function.;6Given tiers, returns tiers of lists of a given length.)*+,-./0123456789:;)*+,-./0123456789:;)*+,-./068941;2357:)*+,-./0123456789:;Safe<Given 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.Returns 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.MReturns a function given by a list of input-output pairs and a default value.<=>?<=>?=<>?<=>?SafeSafe@ABCDEFGHIJKLM@ABCDEFGB@AMLKJIHCDEFG @ABCDEFGHIJKLMB NoneN.Derives a Listable instance for a given type ().<Checks whether it is possible to derive a Listable instance.lFor example, it is not possible if there are is no Listable instance for a type in one of the constructors.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. NNN NSafe OPQRSTUVWOPQRSTUV WOPQRSTUV OPQRSTUVWSafeX(Check a property printing results on stdoutYCheck a property for N tests printing results on stdoutZ(Check a property printing results on stdout and returning  on success.KThere is no option to silence this function: in that case, you should use .[Check a property for N tests printing results on stdout and returning  on success.KThere is no option to silence this function: in that case, you should use . XYZ[XYZ[XYZ[XYZ[None>  !"#$%&'()*+,-./01234689;NXYZ[: ! "#$%&'( 23N)*+,-./096841; NonerTakes a value and a function. Ignores the value. Binds the argument of the function to the type of the value.\Transforms a value into  that value or  on some errors:ArithExceptionArrayException ErrorCallPatternMatchFail]Transforms a value into  that value or  on error. \]^_`abcdefgB !"#$%&'()*+,-./01234689;NXYZ[\]^_`abcdefg `abcedfg\^_] \]^_`abcdefg NonehhK values are those for which we can return a list of functional bindings.As a user, you probably want m and n..Non functional instances should be defined by: 8instance ShowFunction Ty where tBindings = tBindingsShowj*A functional binding in a showable format.kGiven a h= 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") ]l2A default implementation of tBindings for already  -able types.m,Given a number of patterns to show, shows a h 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 8n-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 falsehijklmnhijklmnmnjkhilhijklmnNone  Nones-Natural numbers modulo 7: 0, 1, 2, 3, 4, 5, 6t*Natural numbers modulo 6: 0, 1, 2, 3, 4, 5u'Natural numbers modulo 5: 0, 1, 2, 3, 4v$Natural numbers modulo 4: 0, 1, 2, 3w!Natural numbers modulo 3: 0, 1, 2xNatural numbers modulo 2: 0, 1yNatural numbers modulo 1: 0z: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, 15|3Three-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, 0opqrs  tuvwxyz{|} !~"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~opqrstuvwxyz{|}~~}|{zyxwvutsrqpoopqrs  tuvwxyz{|} !~"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ None vType 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 -> CharvType 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 -> InttType 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 -> Ty}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 -> bType 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 -> Ty|Type restricted version of const that forces the third argument of its first argument to have the same type as the second.Type 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.Returns 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 -> IntShorthand for undefinedIt might be better to just use   None!Equal under. A ternary operator. 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' -- > False!Check if two lists are equal for n values. (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] -- > False None~  !"#$%&'()*+,-./01234689;NXYZ[opqrstuvwxyz{|}~Nonecheck if a list is ordered7check if a list is ordered by a given ordering function@check if a list is strictly ordered by a given ordering functionchecks if the first n" elements on tiers are ordered by cmp. ,(n `seriesOrderedBy`) comparing (id :: Type)     !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghRijklm n o p q  3 4 0 2 / 1 . r s t u v w x y z { | } ~               bi                        }  ~   !  "  #  $  %  &  '  (  )  *  +  ,  -  . / 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 { | } ~                                                                                                      leanc_887MWNdOvh18j6FfKWupSqTest.Check.CoreTest.Check.BasicTest.Check.Utils Test.Check.Function.ListsOfPairsTest.Check.Function.CoListableTest.Check.DeriveTest.Check.Function.Periodic Test.Check.IOTest.Check.ErrorTest.Check.ShowFunction Test.TypesTest.TypeBindingTest.OperatorsderiveListableTest.Check.Function Test.CheckholdsTest.Check.Function.Show Test.MostTest.Check.InvariantsTestableListabletierslisttoTiers listIntegraltiersFractionalmapTfilterTconcatT concatMapTcons0cons1cons2cons3cons4cons5ofWeight addWeightsuchThat+|\/\\//>< productWithresultscounterExamplescounterExample witnesseswitnessfailsexists==>cons6cons7cons8cons9cons10cons11cons12 consFromListconsFromAscendingListconsFromStrictlyAscendingList consFromSetconsFromNoDupList product3WithproductMaybeWithlistsOfproductsdeleteT normalizeT noDupListsOfchoicesascendingListsOfascendingChoicesstrictlyAscendingListsOfsetsOfstrictlyAscendingChoices listsOfLength associations functionPairspairsToFunctiondefaultFunPairsToFunction CoListable coListing\+:/alts0alts1alts2alts3fListing$fCoListableInt$fCoListable[]$fCoListableEither$fCoListableMaybe$fCoListableBool$fCoListable() functions functionsz lsPeriodsOflsPeriodsOfLimitisPeriod isPeriodOf tiersOfLimit$fListable(->)checkcheckFor checkResultcheckResultForerrorToNothinganyErrorToNothing errorToFalse errorToTrue ShowFunction tBindingsBindingbindings tBindingsShow showFunctionshowFunctionLineUInt4UInt3UInt2UInt1Nat7Nat6Nat5Nat4Nat3Nat2Nat1NatWord4Word3Word2Word1Int4Int3Int2Int1-:-:>->:->:>->>:->>:>->>>:>-undintintegerfloatdoubleboolcharstringmaybeithnatint1int2int3int4uint1uint2uint3uint4=======&&&&&&&||||||| commutative associative distributive transitive idempotentidentity notIdentity=$$==||=base Data.FoldableconcatGHC.Real FractionalGHC.BasemapGHC.Listfilter concatMap resultiersuncurry3uncurry4uncurry5$fTestable(->)$fTestableBool$fListableDouble$fListableFloat $fListable[]$fListable(,,,,)$fListable(,,,)$fListable(,,) $fListable(,)$fListableEither$fListableMaybe$fListableBool$fListableChar$fListableInteger $fListableInt $fListable()uncurry6uncurry7uncurry8uncurry9 uncurry10 uncurry11 uncurry12$fListable(,,,,,,,,,,,)$fListable(,,,,,,,,,,)$fListable(,,,,,,,,,)$fListable(,,,,,,,,)$fListable(,,,,,,,)$fListable(,,,,,,)$fListable(,,,,,)product choicesWithstrictlyAscendingChoicesWithascendingChoicesWithpairsToMaybeFunctionJustNothingdefaultPairsToFunctiontemplate-haskellLanguage.Haskell.TH.SyntaxNamecanDeriveListable typeArityreallyDeriveListable normalizeTypenormalizeTypeUnits isInstanceOftypeCons|=>|ghc-prim GHC.TypesTrueResultOK Falsified Exception resultsIOresultIO showResultbindArgumentTypeGHC.ShowShow isUndefinedparen varnamesFor showTupleshowNBindingsOfisValue showValueOf showFunctionL$fShowFunction(,,,,,,,)$fShowFunction(,,,,,,)$fShowFunction(,,,,,)$fShowFunction(,,,,)$fShowFunction(,,,)$fShowFunction(,,)$fShowFunction(->)$fShowFunction(,)$fShowFunctionMaybe$fShowFunction[]$fShowFunctionChar$fShowFunctionInt$fShowFunctionBool$fShowFunction() $fShow(->)IntGHC.EnummaxBoundunNat7unNat6unNat5unNat4unNat3unNat2unNat1unNatunWord4unWord3unWord2unWord1unInt4unInt3unInt2unInt1narrowUnarrowSmapTuplemapFstoNewtypefNewtype otNewtypereadsPrecNewtypeboundedEnumFromboundedEnumFromThenword1word2word3word4nat1nat2nat3nat4nat5nat6nat7oInt1oInt2oInt3oInt4oWord1oWord2oWord3oWord4oNatoNat1oNat2oNat3oNat4oNat5oNat6oNat7fInt1fInt2fInt3fInt4fWord1fWord2fWord3fWord4fNatfNat1fNat2fNat3fNat4fNat5fNat6fNat7$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 $fShowInt1asTypeOf undefinedOfcombineordered orderedBystrictlyOrderedBy tOrderedBystrictlyOrderedifNotEqthntStrictlyOrderedBy tNatPairOrd tNatTripleOrdtNatQuadrupleOrdtNatQuintupleOrdtNatSixtupleOrd tNatListOrdtListsOfStrictlyOrderedBytListsOfNatOrd tPairEqParamstTripleEqParamstProductsIsFilterByLength