Copyright	(c) 2015-2017 Rudy Matela
License	3-Clause BSD (see the file LICENSE)
Maintainer	Rudy Matela <rudy@matela.com.br>
Safe Haskell	Safe
Language	Haskell2010

Test.LeanCheck.Basic

Contents

Orphan instances

Description

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.

Synopsis

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