Test.LeanCheck

LeanCheck is a simple enumerative property-based testing library.

A property is a function returning a Bool that should be True for all possible choices of arguments. Properties can be viewed as a parameterized unit tests.

To check if a property holds by testing up to a thousand values, we evaluate:

holds 1000 property

True indicates success. False indicates a bug.

For example:

holds 1000 $ \xs -> length (sort xs) == length (xs::[Int])

To get the smallest counterExample by testing up to a thousand values, we evaluate:

counterExample 1000 property

Arguments of properties should be instances of the Listable typeclass. Listable instances are provided for the most common Haskell types. New instances are easily defined (see Listable for more info).

Checking and testing

holds :: Testable a => Int -> a -> Bool

Does a property hold up to a number of test values?

holds 1000 $ \xs -> length (sort xs) == length xs

fails :: Testable a => Int -> a -> Bool

Does a property fail for a number of test values?

fails 1000 $ \xs -> xs ++ ys == ys ++ xs

exists :: Testable a => Int -> a -> Bool

There exists an assignment of values that satisfies a property up to a number of test values?

exists 1000 $ \x -> x > 10

Boolean (property) operators

(==>) :: Bool -> Bool -> Bool infixr 0

Boolean implication operator. Useful for defining conditional properties:

prop_something x y = condition x y ==> something x y

Examples:

> prop_addMonotonic x y  =  y > 0 ==> x + y > x
> check prop_addMonotonic
+++ OK, passed 200 tests.

Counterexamples and witnesses

counterExample :: Testable a => Int -> a -> Maybe [String]

Up to a number of tests to a property, returns Just the first counter-example or Nothing if there is none.

> counterExample 100 $ \xs -> [] `union` xs == (xs::[Int])
Just ["[0,0]"]

counterExamples :: Testable a => Int -> a -> [[String]]

Lists all counter-examples for a number of tests to a property,

> counterExamples 12 $ \xs -> xs == nub (xs :: [Int])
[["[0,0]"],["[0,0,0]"],["[0,0,0,0]"],["[0,0,1]"],["[0,1,0]"]]

witness :: Testable a => Int -> a -> Maybe [String]

Up to a number of tests to a property, returns Just the first witness or Nothing if there is none.

> witness 1000 (\x -> x > 1 && x < 77 && 77 `rem` x == 0)
Just ["7"]

witnesses :: Testable a => Int -> a -> [[String]]

Lists all witnesses up to a number of tests to a property.

> witnesses 1000 (\x -> x > 1 && x < 77 && 77 `rem` x == 0)
[["7"],["11"]]

Reporting

check :: Testable a => a -> IO ()

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]

checkFor :: Testable a => Int -> a -> IO ()

Check a property for a given number of tests printing results on stdout

> checkFor 1000 $ \xs -> sort (sort xs) == sort (xs::[Int])
+++ OK, passed 1000 tests.

checkResult :: Testable a => a -> IO Bool

Check a property printing results on stdout and returning True on success.

> p <- checkResult $ \xs -> sort (sort xs) == sort (xs::[Int])
+++ OK, passed 200 tests.
> q <- checkResult $ \xs ys -> xs `union` ys == ys `union` (xs::[Int])
*** Failed! Falsifiable (after 4 tests):
[] [0,0]
> p && q
False

There is no option to silence this function: for silence, you should use holds.

checkResultFor :: Testable a => Int -> a -> IO Bool

Check a property for a given number of tests printing results on stdout and returning True on success.

> checkResultFor 1000 $ \xs -> sort (sort xs) == sort (xs::[Int])
+++ OK, passed 1000 tests.
True

There is no option to silence this function: for silence, you should use holds.

Listing test values

class Listable a where

A type is Listable when there exists a function that is able to list (ideally all of) its values.

Ideally, instances should be defined by a tiers 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 tiers is

tiers = cons<N> ConstructorA
     \/ cons<N> ConstructorB
     \/ ...
     \/ cons<N> ConstructorZ

where N is the number of arguments of each constructor A...Z.

Here is a datatype with 4 constructors and its listable instance:

data MyType  =  MyConsA
             |  MyConsB Int
             |  MyConsC Int Char
             |  MyConsD String

instance Listable MyType where
  tiers =  cons0 MyConsA
        \/ cons1 MyConsB
        \/ cons2 MyConsC
        \/ cons1 MyConsD

The instance for Hutton's Razor is given by:

data Expr  =  Val Int
           |  Add Expr Expr

instance Listable Expr where
  tiers  =  cons1 Val
         \/ cons2 Add

Instances can be alternatively defined by list. In this case, each sub-list in tiers is a singleton list (each succeeding element of list has +1 size).

The function deriveListable from Test.LeanCheck.Derive can automatically derive instances of this typeclass.

A Listable instance for functions is also available but is not exported by default. Import Test.LeanCheck.Function if you need to test higher-order properties.

Minimal complete definition

list | tiers

Methods

tiers :: [[a]]

list :: [a]

Instances

Listable Bool

tiers :: [[Bool]] = [[False,True]]
list :: [[Bool]] = [False,True]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Bool]]

list :: [Bool]

Listable Char

list :: [Char] = ['a', ' ', 'b', 'A', 'c', '\', 'n', 'd', ...]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Char]]

list :: [Char]

Listable Double

NaN and -0 are not included in the list of Doubles.

list :: [Double]  =  [0.0, 1.0, -1.0, Infinity, 0.5, 2.0, ...]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Double]]

list :: [Double]

Listable Float

NaN and -0 are not included in the list of Floats.

list :: [Float] =
  [ 0.0
  , 1.0, -1.0, Infinity
  , 0.5, 2.0, -Infinity, -0.5, -2.0
  , 0.33333334, 3.0, -0.33333334, -3.0
  , 0.25, 0.6666667, 1.5, 4.0, -0.25, -0.6666667, -1.5, -4.0
  , ...
  ]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Float]]

list :: [Float]

Listable Int

tiers :: [[Int]] = [[0], [1], [-1], [2], [-2], [3], [-3], ...]
list :: [Int] = [0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, ...]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Int]]

list :: [Int]

Listable Int8

list :: [Int8] = [0, 1, -1, 2, -2, 3, -3, ..., 127, -127, -128]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Int8]]

list :: [Int8]

Listable Int16

list :: [Int16] = [0, 1, -1, 2, -2, ..., 32767, -32767, -32768]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Int16]]

list :: [Int16]

Listable Int32

list :: [Int32] = [0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, ...]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Int32]]

list :: [Int32]

Listable Int64

list :: [Int64] = [0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, ...]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Int64]]

list :: [Int64]

Listable Integer

list :: [Int] = [0, 1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, ...]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Integer]]

list :: [Integer]

Listable Ordering

list :: [Ordering]  = [LT, EQ, GT]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Ordering]]

list :: [Ordering]

Listable Word

list :: [Word] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Word]]

list :: [Word]

Listable Word8

list :: [Word8] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ..., 255]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Word8]]

list :: [Word8]

Listable Word16

list :: [Word16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ..., 65535]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Word16]]

list :: [Word16]

Listable Word32

list :: [Word32] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Word32]]

list :: [Word32]

Listable Word64

list :: [Word64] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Word64]]

list :: [Word64]

Listable ()

list :: [()]  =  [()]
tiers :: [[()]]  =  [[()]]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[()]]

list :: [()]

Listable ExitCode

Only includes valid POSIX exit codes

> list :: [ExitCode]
[ExitSuccess, ExitFailure 1, ExitFailure 2, ..., ExitFailure 255]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[ExitCode]]

list :: [ExitCode]

Listable BufferMode

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[BufferMode]]

list :: [BufferMode]

Listable SeekMode

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[SeekMode]]

list :: [SeekMode]

Listable CChar

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CChar]]

list :: [CChar]

Listable CSChar

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CSChar]]

list :: [CSChar]

Listable CUChar

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CUChar]]

list :: [CUChar]

Listable CShort

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CShort]]

list :: [CShort]

Listable CUShort

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CUShort]]

list :: [CUShort]

Listable CInt

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CInt]]

list :: [CInt]

Listable CUInt

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CUInt]]

list :: [CUInt]

Listable CLong

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CLong]]

list :: [CLong]

Listable CULong

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CULong]]

list :: [CULong]

Listable CLLong

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CLLong]]

list :: [CLLong]

Listable CULLong

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CULLong]]

list :: [CULLong]

Listable CBool

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CBool]]

list :: [CBool]

Listable CFloat

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CFloat]]

list :: [CFloat]

Listable CDouble

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CDouble]]

list :: [CDouble]

Listable CPtrdiff

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CPtrdiff]]

list :: [CPtrdiff]

Listable CSize

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CSize]]

list :: [CSize]

Listable CWchar

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CWchar]]

list :: [CWchar]

Listable CSigAtomic

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CSigAtomic]]

list :: [CSigAtomic]

Listable CClock

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CClock]]

list :: [CClock]

Listable CTime

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CTime]]

list :: [CTime]

Listable CUSeconds

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CUSeconds]]

list :: [CUSeconds]

Listable CSUSeconds

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CSUSeconds]]

list :: [CSUSeconds]

Listable CIntPtr

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CIntPtr]]

list :: [CIntPtr]

Listable CUIntPtr

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CUIntPtr]]

list :: [CUIntPtr]

Listable CIntMax

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CIntMax]]

list :: [CIntMax]

Listable CUIntMax

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[CUIntMax]]

list :: [CUIntMax]

Listable IOMode

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[IOMode]]

list :: [IOMode]

Listable GeneralCategory

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[GeneralCategory]]

list :: [GeneralCategory]

Listable Letters

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Letters]]

list :: [Letters]

Listable AlphaNums

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[AlphaNums]]

list :: [AlphaNums]

Listable Digits

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Digits]]

list :: [Digits]

Listable Alphas

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Alphas]]

list :: [Alphas]

Listable Uppers

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Uppers]]

list :: [Uppers]

Listable Lowers

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Lowers]]

list :: [Lowers]

Listable Spaces

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Spaces]]

list :: [Spaces]

Listable Letter

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Letter]]

list :: [Letter]

Listable AlphaNum

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[AlphaNum]]

list :: [AlphaNum]

Listable Digit

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Digit]]

list :: [Digit]

Listable Alpha

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Alpha]]

list :: [Alpha]

Listable Upper

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Upper]]

list :: [Upper]

Listable Lower

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Lower]]

list :: [Lower]

Listable Space

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Space]]

list :: [Space]

Listable Nat7

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat7]]

list :: [Nat7]

Listable Nat6

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat6]]

list :: [Nat6]

Listable Nat5

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat5]]

list :: [Nat5]

Listable Nat4

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat4]]

list :: [Nat4]

Listable Nat3

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat3]]

list :: [Nat3]

Listable Nat2

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat2]]

list :: [Nat2]

Listable Nat1

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat1]]

list :: [Nat1]

Listable Nat

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Nat]]

list :: [Nat]

Listable Natural

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Natural]]

list :: [Natural]

Listable Word4

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Word4]]

list :: [Word4]

Listable Word3

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Word3]]

list :: [Word3]

Listable Word2

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Word2]]

list :: [Word2]

Listable Word1

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Word1]]

list :: [Word1]

Listable Int4

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Int4]]

list :: [Int4]

Listable Int3

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Int3]]

list :: [Int3]

Listable Int2

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Int2]]

list :: [Int2]

Listable Int1

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Int1]]

list :: [Int1]

Listable a => Listable [a]

tiers :: [[ [Int] ]] = [ [ [] ]
                       , [ [0] ]
                       , [ [0,0], [1] ]
                       , [ [0,0,0], [0,1], [1,0], [-1] ]
                       , ... ]
list :: [ [Int] ] = [ [], [0], [0,0], [1], [0,0,0], ... ]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[[a]]]

list :: [[a]]

Listable a => Listable (Maybe a)

tiers :: [[Maybe Int]] = [[Nothing], [Just 0], [Just 1], ...]
tiers :: [[Maybe Bool]] = [[Nothing], [Just False, Just True]]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Maybe a]]

list :: [Maybe a]

(Integral a, Listable a) => Listable (Ratio a)

list :: [Rational] =
  [   0  % 1
  ,   1  % 1
  , (-1) % 1
  ,   1  % 2,   2  % 1
  , (-1) % 2, (-2) % 1
  ,   1  % 3,   3  % 1
  , (-1) % 3, (-3) % 1
  ,   1  % 4,   2  % 3,   3  % 2,   4  % 1
  , (-1) % 4, (-2) % 3, (-3) % 2, (-4) % 1
  ,   1  % 5,   5  % 1
  , (-1) % 5, (-5) % 1
  , ...
  ]

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Ratio a]]

list :: [Ratio a]

(RealFloat a, Listable a) => Listable (Complex a)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[Complex a]]

list :: [Complex a]

(Integral a, Bounded a) => Listable (Xs a)

Lists with elements of the X type.

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Xs a]]

list :: [Xs a]

(Integral a, Bounded a) => Listable (X a)

Extremily large integers are intercalated with small integers.

list :: [X Int] = map X
  [ 0, 1, -1, maxBound,   minBound
     , 2, -2, maxBound-1, minBound+1
     , 3, -3, maxBound-2, minBound+2
     , ... ]

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[X a]]

list :: [X a]

Listable a => Listable (Set a)

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Set a]]

list :: [Set a]

Listable a => Listable (Bag a)

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Bag a]]

list :: [Bag a]

Listable a => Listable (NoDup a)

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[NoDup a]]

list :: [NoDup a]

(Eq a, Listable a, Listable b) => Listable (a -> b)

Defined in Test.LeanCheck.Function.Listable.ListsOfPairs

Methods

tiers :: [[a -> b]]

list :: [a -> b]

(Listable a, Listable b) => Listable (Either a b)

tiers :: [[Either Bool Bool]] =
  [[Left False, Right False, Left True, Right True]]
tiers :: [[Either Int Int]] = [ [Left 0, Right 0]
                              , [Left 1, Right 1]
                              , [Left (-1), Right (-1)]
                              , [Left 2, Right 2]
                              , ... ]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[Either a b]]

list :: [Either a b]

(Listable a, Listable b) => Listable (a, b)

tiers :: [[(Int,Int)]] =
[ [(0,0)]
, [(0,1),(1,0)]
, [(0,-1),(1,1),(-1,0)]
, ...]
list :: [(Int,Int)] = [ (0,0), (0,1), (1,0), (0,-1), (1,1), ...]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[(a, b)]]

list :: [(a, b)]

(Listable a, Listable b) => Listable (Map a b)

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[Map a b]]

list :: [Map a b]

(Listable a, Listable b, Listable c) => Listable (a, b, c)

list :: [(Int,Int,Int)] = [ (0,0,0), (0,0,1), (0,1,0), ...]

Defined in Test.LeanCheck.Core

Methods

tiers :: [[(a, b, c)]]

list :: [(a, b, c)]

(Listable a, Listable b, Listable c, Listable d) => Listable (a, b, c, d)

Defined in Test.LeanCheck.Core

Methods

tiers :: [[(a, b, c, d)]]

list :: [(a, b, c, d)]

(Listable a, Listable b, Listable c, Listable d, Listable e) => Listable (a, b, c, d, e)

Defined in Test.LeanCheck.Core

Methods

tiers :: [[(a, b, c, d, e)]]

list :: [(a, b, c, d, e)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f) => Listable (a, b, c, d, e, f)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[(a, b, c, d, e, f)]]

list :: [(a, b, c, d, e, f)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g) => Listable (a, b, c, d, e, f, g)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[(a, b, c, d, e, f, g)]]

list :: [(a, b, c, d, e, f, g)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h) => Listable (a, b, c, d, e, f, g, h)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[(a, b, c, d, e, f, g, h)]]

list :: [(a, b, c, d, e, f, g, h)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i) => Listable (a, b, c, d, e, f, g, h, i)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i)]]

list :: [(a, b, c, d, e, f, g, h, i)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j) => Listable (a, b, c, d, e, f, g, h, i, j)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i, j)]]

list :: [(a, b, c, d, e, f, g, h, i, j)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k) => Listable (a, b, c, d, e, f, g, h, i, j, k)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i, j, k)]]

list :: [(a, b, c, d, e, f, g, h, i, j, k)]

(Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k, Listable l) => Listable (a, b, c, d, e, f, g, h, i, j, k, l)

Defined in Test.LeanCheck.Basic

Methods

tiers :: [[(a, b, c, d, e, f, g, h, i, j, k, l)]]

list :: [(a, b, c, d, e, f, g, h, i, j, k, l)]

Listing constructors

cons0 :: a -> [[a]]

Given a constructor with no arguments, returns tiers 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.

cons1 :: Listable a => (a -> b) -> [[b]]

Given a constructor with one Listable argument, return tiers of applications of this constructor. By default, returned values will have size/weight of 1.

cons2 :: (Listable a, Listable b) => (a -> b -> c) -> [[c]]

Given a constructor with two Listable arguments, return tiers of applications of this constructor. By default, returned values will have size/weight of 1.

cons3 :: (Listable a, Listable b, Listable c) => (a -> b -> c -> d) -> [[d]]

Returns tiers of applications of a 3-argument constructor.

cons4 :: (Listable a, Listable b, Listable c, Listable d) => (a -> b -> c -> d -> e) -> [[e]]

Returns tiers of applications of a 4-argument constructor.

cons5 :: (Listable a, Listable b, Listable c, Listable d, Listable e) => (a -> b -> c -> d -> e -> f) -> [[f]]

Returns tiers of applications of a 5-argument constructor.

Test.LeanCheck.Basic defines cons6 up to cons12. Those are exported by default from Test.LeanCheck, but are hidden from the Haddock documentation.

delay :: [[a]] -> [[a]]

Delays the enumeration of tiers. Conceptually this function adds to the weight of a constructor.

delay [xs, ys, zs, ... ]  =  [[], xs, ys, zs, ...]

delay [[x,...], [y,...], ...]  =  [[], [x,...], [y,...], ...]

Typically used when defining Listable instances:

instance Listable <Type> where
  tiers  =  ...
         \/ delay (cons<N> <Constructor>)
         \/ ...

reset :: [[a]] -> [[a]]

Resets any delays in a list-of tiers. Conceptually this function makes a constructor "weightless", assuring the first tier is non-empty.

reset [[], [], ..., xs, ys, zs, ...]  =  [xs, ys, zs, ...]

reset [[], xs, ys, zs, ...]  =  [xs, ys, zs, ...]

reset [[], [], ..., [x], [y], [z], ...]  =  [[x], [y], [z], ...]

Typically used when defining Listable instances:

instance Listable <Type> where
  tiers  =  ...
         \/ reset (cons<N> <Constructor>)
         \/ ...

Be careful: do not apply reset to recursive data structure constructors. In general this will make the list of size 0 infinite, breaking the tiers invariant (each tier must be finite).

ofWeight :: [[a]] -> Int -> [[a]]

Resets the weight of a constructor or tiers.

> [ [], [], ..., xs, ys, zs, ... ] `ofWeight` 1
[ [], xs, ys, zs, ... ]

> [ xs, ys, zs, ... ] `ofWeight` 2
[ [], [], xs, ys, zs, ... ]

> [ [], xs, ys, zs, ... ] `ofWeight` 3
[ [], [], [], xs, ys, zs, ... ]

Typically used as an infix operator when defining Listable instances:

instance Listable <Type> where
  tiers  =  ...
         \/ cons<N> <Cons>  `ofWeight`  <W>
         \/ ...

Warning: do not apply `ofWeight` 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).

`ofWeight` n is equivalent to reset followed by n applications of delay.

addWeight :: [[a]] -> Int -> [[a]]

Adds to the weight of a constructor or tiers.

instance Listable <Type> where
  tiers  =  ...
         \/ cons<N> <Cons>  `addWeight`  <W>
         \/ ...

Typically used as an infix operator when defining Listable instances:

> [ xs, ys, zs, ... ] `addWeight` 1
[ [], xs, ys, zs, ... ]

> [ xs, ys, zs, ... ] `addWeight` 2
[ [], [], xs, ys, zs, ... ]

> [ [], xs, ys, zs, ... ] `addWeight` 3
[ [], [], [], [], xs, ys, zs, ... ]

`addWeight` n is equivalent to n applications of delay.

suchThat :: [[a]] -> (a -> Bool) -> [[a]]

Tiers of values that follow a property.

Typically used in the definition of Listable tiers:

instance Listable <Type> where
  tiers  =  ...
         \/ cons<N> `suchThat` <condition>
         \/ ...

Examples:

> tiers `suchThat` odd
[[], [1], [-1], [], [], [3], [-3], [], [], [5], ...]

> tiers `suchThat` even
[[0], [], [], [2], [-2], [], [], [4], [-4], [], ...]

This function is just a flipped version of filterT.

Combining tiers

(\/) :: [[a]] -> [[a]] -> [[a]] infixr 7

Append tiers --- sum of two tiers enumerations.

[xs,ys,zs,...] \/ [as,bs,cs,...]  =  [xs++as, ys++bs, zs++cs, ...]

(\\//) :: [[a]] -> [[a]] -> [[a]] infixr 7

Interleave tiers --- sum of two tiers enumerations. When in doubt, use \/ instead.

[xs,ys,zs,...] \/ [as,bs,cs,...]  =  [xs+|as, ys+|bs, zs+|cs, ...]

(><) :: [[a]] -> [[b]] -> [[(a, b)]] infixr 8

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)]
  , ...
  ]

productWith :: (a -> b -> c) -> [[a]] -> [[b]] -> [[c]]

Take a tiered product of lists of tiers. productWith can be defined by ><, as:

productWith f xss yss  =  map (uncurry f) $ xss >< yss

Manipulating tiers

mapT :: (a -> b) -> [[a]] -> [[b]]

map over tiers

mapT f [[x], [y,z], [w,...], ...]  =  [[f x], [f y, f z], [f w, ...], ...]

mapT f [xs, ys, zs, ...]  =  [map f xs, map f ys, map f zs]

filterT :: (a -> Bool) -> [[a]] -> [[a]]

filter tiers

filterT p [xs, yz, zs, ...]  =  [filter p xs, filter p ys, filter p zs]

filterT odd tiers  =  [[], [1], [-1], [], [], [3], [-3], [], [], [5], ...]

concatT :: [[[[a]]]] -> [[a]]

concat tiers of tiers

concatMapT :: (a -> [[b]]) -> [[a]] -> [[b]]

concatMap over tiers

deleteT :: Eq a => a -> [[a]] -> [[a]]

Delete the first occurence of an element in a tier.

For normalized lists-of-tiers without repetitions, the following holds:

deleteT x = normalizeT . (`suchThat` (/= x))

normalizeT :: [[a]] -> [[a]]

Normalizes tiers by removing up to 12 empty tiers from the end of a list of tiers.

normalizeT [xs0,xs1,...,xsN,[]]     =  [xs0,xs1,...,xsN]
normalizeT [xs0,xs1,...,xsN,[],[]]  =  [xs0,xs1,...,xsN]

The arbitrary limit of 12 tiers is necessary as this function would loop if there is an infinite trail of empty tiers.

toTiers :: [a] -> [[a]]

Takes a list of values xs and transform it into tiers on which each tier is occupied by a single element from xs.

> toTiers [x, y, z, ...]
[ [x], [y], [z], ...]

To convert back to a list, just concat.

Automatically deriving Listable instances

deriveListable :: Name -> DecsQ

Derives a Listable instance for a given type Name.

Consider the following Stack datatype:

data Stack a = Stack a (Stack a) | Empty

Writing

deriveListable ''Stack

will automatically derive the following Listable instance:

instance Listable a => Listable (Stack a) where
  tiers = cons2 Stack \/ cons0 Empty

Warning: if the values in your type need to follow a data invariant, the derived instance won't respect it. Use this only on "free" datatypes.

Needs the TemplateHaskell extension.

deriveListableCascading :: Name -> DecsQ

Derives a Listable instance for a given type Name cascading derivation of type arguments as well.

Consider the following series of datatypes:

data Position = CEO | Manager | Programmer

data Person = Person
            { name :: String
            , age :: Int
            , position :: Position
            }

data Company = Company
             { name :: String
             , employees :: [Person]
             }

Writing

deriveListableCascading ''Company

will automatically derive the following three Listable instances:

instance Listable Position where
  tiers = cons0 CEO \/ cons0 Manager \/ cons0 Programmer

instance Listable Person where
  tiers = cons3 Person

instance Listable Company where
  tiers = cons2 Company

Specialized constructors of tiers

setCons :: Listable a => ([a] -> b) -> [[b]]

Given a constructor that takes a set of elements (as a list), lists tiers of applications of this constructor.

A naive Listable instance for the Set (of Data.Set) would read:

instance Listable a => Listable (Set a) where
  tiers = cons0 empty \/ cons2 insert

The above instance has a problem: it generates repeated sets. A more efficient implementation that does not repeat sets is given by:

  tiers = setCons fromList

Alternatively, you can use setsOf direclty.

bagCons :: Listable a => ([a] -> b) -> [[b]]

Given 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 Bag

noDupListCons :: Listable a => ([a] -> b) -> [[b]]

Given a constructor that takes a list with no duplicate elements, return tiers of applications of this constructor.

mapCons :: (Listable a, Listable b) => ([(a, b)] -> c) -> [[c]]

Given a constructor that takes a map of elements (encoded as a list), lists tiers of applications of this constructor

So long as the underlying Listable enumerations have no repetitions, this will generate no repetitions.

This allows defining an efficient implementation of tiers that does not repeat maps given by:

  tiers = mapCons fromList

Products of tiers

product3With :: (a -> b -> c -> d) -> [[a]] -> [[b]] -> [[c]] -> [[d]]

Like productWith, but over 3 lists of tiers.

productMaybeWith :: (a -> b -> Maybe c) -> [[a]] -> [[b]] -> [[c]]

Take the product of lists of tiers by a function returning a Maybe value discarding Nothing values.

Listing lists

listsOf :: [[a]] -> [[[a]]]

Takes 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]]
                      , ...
                      ]

setsOf :: [[a]] -> [[[a]]]

Takes 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 Listable instances. For Set (from Data.Set), we would have:

instance Listable a => Listable (Set a) where
  tiers = mapT fromList $ setsOf tiers

bagsOf :: [[a]] -> [[[a]]]

Takes 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]]
  , ...
  ]

noDupListsOf :: [[a]] -> [[[a]]]

Takes as argument tiers of element values; returns tiers of lists with no repeated elements.

noDupListsOf [[0],[1],[2],...] ==
  [ [[]]
  , [[0]]
  , [[1]]
  , [[0,1],[1,0],[2]]
  , [[0,2],[2,0],[3]]
  , ...
  ]

products :: [[[a]]] -> [[[a]]]

Takes 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

listsOfLength :: Int -> [[a]] -> [[[a]]]

Takes 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]]
  , ...
  ]

Listing values

tiersFloating :: Fractional a => [[a]]

Tiers of Floating values. This can be used as the implementation of tiers for Floating types.

This function is equivalent to tiersFractional with positive and negative infinities included: 10 and -10.

tiersFloating :: [[Float]] =
  [ [0.0]
  , [1.0]
  , [-1.0, Infinity]
  , [ 0.5,  2.0, -Infinity]
  , [-0.5, -2.0]
  , [ 0.33333334,  3.0]
  , [-0.33333334, -3.0]
  , [ 0.25,  0.6666667,  1.5,  4.0]
  , [-0.25, -0.6666667, -1.5, -4.0]
  , [ 0.2,  5.0]
  , [-0.2, -5.0]
  , [ 0.16666667,  0.4,  0.75,  1.3333334,  2.5,  6.0]
  , [-0.16666667, -0.4, -0.75, -1.3333334, -2.5, -6.0]
  , ...
  ]

NaN and -0 are excluded from this enumeration.

tiersFractional :: Fractional a => [[a]]

Tiers of Fractional values. This can be used as the implementation of tiers for Fractional types.

tiersFractional :: [[Rational]]  =
  [ [  0  % 1]
  , [  1  % 1]
  , [(-1) % 1]
  , [  1  % 2,   2  % 1]
  , [(-1) % 2, (-2) % 1]
  , [  1  % 3,   3  % 1]
  , [(-1) % 3, (-3) % 1]
  , [  1  % 4,   2  % 3,   3  % 2,   4  % 1]
  , [(-1) % 4, (-2) % 3, (-3) % 2, (-4) % 1]
  , [  1  % 5,   5  % 1]
  , [(-1) % 5, (-5) % 1]
  , [  1  % 6,   2 % 5,    3  % 4,   4  % 3,   5  % 2,   6  % 1]
  , [(-1) % 6, (-2) % 5, (-3) % 4, (-4) % 3, (-5) % 2, (-6) % 1]
  , ...
  ]

listIntegral :: (Ord a, Num a) => [a]

Tiers of Integral values. Can be used as a default implementation of list for Integral types.

For types with negative values, like Int, the list starts with 0 then intercalates between positives and negatives.

listIntegral  =  [0, 1, -1, 2, -2, 3, -3, 4, -4, ...]

For types without negative values, like Word, the list starts with 0 followed by positives of increasing magnitude.

listIntegral  =  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...]

This function will not work for types that throw errors when the result of an arithmetic operation is negative such as Natural. For these, use [0..] as the list implementation.

(+|) :: [a] -> [a] -> [a] infixr 5

Lazily 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,...]

Test results

class Testable a

Testable values are functions of Listable arguments that return boolean values.

•  Bool

•  Listable a => a -> Bool

•  (Listable a, Listable b) => a -> b -> Bool

•  (Listable a, Listable b, Listable c) => a -> b -> c -> Bool

•  (Listable a, Listable b, Listable c, ...) => a -> b -> c -> ... -> Bool

For example:

•  Int -> Bool

•  String -> [Int] -> Bool

Minimal complete definition

resultiers

Instances

Testable Bool

Defined in Test.LeanCheck.Core

Methods

resultiers :: Bool -> [[([String], Bool)]]

(Testable b, Show a, Listable a) => Testable (a -> b)

Defined in Test.LeanCheck.Core

Methods

resultiers :: (a -> b) -> [[([String], Bool)]]

results :: Testable a => a -> [([String], Bool)]

List all results of a Testable 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.

> results (<)
[ (["0","0"],    False)
, (["0","1"],    True)
, (["1","0"],    False)
, (["0","(-1)"], False)
, (["1","1"],    False)
, (["(-1)","0"], True)
, (["0","2"],    True)
, (["1","(-1)"], False)
, ...
]

> take 10 $ results (\xs -> xs == nub (xs :: [Int]))
[ (["[]"],      True)
, (["[0]"],     True)
, (["[0,0]"],   False)
, (["[1]"],     True)
, (["[0,0,0]"], False)
, ...
]