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.

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

Orphan instances

Listable Word

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

Methods

tiers :: [[Word]]

list :: [Word]

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

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