Test.LeanCheck.Basic

This module is part of LeanCheck, a simple enumerative property-based testing library.

This module exports Test.LeanCheck.Core along with:

• support for Listable 6-tuples up to 12-tuples;
• tiers constructors (consN) with arities from 6 up to 12;
• a Listable Ratio instance (consequently Listable Rational);
• a Listable Word instance;
• the operators addWeight and ofWeight.

Test.LeanCheck already exports everything from this module. You are probably better off importing it.

You should only import Test.LeanCheck.Basic if you only want the above basic functionality.

Documentation

module Test.LeanCheck.Core

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

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

cons8 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h) => (a -> b -> c -> d -> e -> f -> g -> h -> i) -> [[i]]

cons9 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j) -> [[j]]

cons10 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k) -> [[k]]

cons11 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l) -> [[l]]

cons12 :: (Listable a, Listable b, Listable c, Listable d, Listable e, Listable f, Listable g, Listable h, Listable i, Listable j, Listable k, Listable l) => (a -> b -> c -> d -> e -> f -> g -> h -> i -> j -> k -> l -> m) -> [[m]]

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

Resets 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 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 is closely related to reset.

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

Adds to the weight of tiers of a constructor

addWeight is closely related to delay.

Orphan instances

Listable Word

Methods

tiers :: [[Word]]

list :: [Word]

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

Methods

tiers :: [[Ratio a]]

list :: [Ratio a]

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

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)

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)

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)

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)

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)

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)

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