Test.LeanCheck.Function.ShowFunction

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

This module exports the ShowFunction typeclass, its instances and related functions.

Using this module, it is possible to implement a Show instance for functions:

import Test.LeanCheck.ShowFunction
instance (Show a, Listable a, ShowFunction b) => Show (a->b) where
  show  =  showFunction 8

This shows functions as a case pattern with up to 8 cases.

It will only work for functions whose ultimate return value is an instance of ShowFunction. This module provides instances for most standard data types (Int, Bool, Maybe, ...). Please see the ShowFunction typeclass documentation for how to declare istances for user-defined data types.

The modules Test.LeanCheck.Function and Test.LeanCheck.Function.Show exports an instance like the one above.

Showing functions

showFunction :: ShowFunction a => Int -> a -> String

Given the number of patterns to show, shows a ShowFunction value.

> putStrLn $ showFunction undefined True
True

> putStrLn $ showFunction 3 (id::Int->Int)
\x -> case x of
      0 -> 0
      1 -> 1
      -1 -> -1
      ...

> putStrLn $ showFunction 4 (&&)
\x y -> case (x,y) of
        (True,True) -> True
        _ -> False

In the examples above, "..." should be interpreted literally.

This can be used as an implementation of show for functions:

instance (Show a, Listable a, ShowFunction b) => Show (a->b) where
  show  =  showFunction 8

See showFunctionLine for an alternative without line breaks.

showFunctionLine :: ShowFunction a => Int -> a -> String

Same as showFunction, but has no line breaks.

> putStrLn $ showFunctionLine 3 (id::Int->Int)
\x -> case x of 0 -> 0; 1 -> 1; -1 -> -1; ...
> putStrLn $ showFunctionLine 3 (&&)
\x y -> case (x,y) of (True,True) -> True; _ -> False

This can be used as an implementation of show for functions:

instance (Show a, Listable a, ShowFunction b) => Show (a->b) where
  show  =  showFunction 8

Support for user-defined algebraic datatypes on return values

class ShowFunction a where

ShowFunction values are those for which we can return a list of functional bindings.

Instances for showable algebraic datatypes are defined using bindtiersShow:

instance ShowFunction Ty where bindtiers  =  bindtiersShow

Methods

bindtiers :: a -> [[Binding]]

Instances

ShowFunction Bool

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Bool -> [[Binding]]

ShowFunction Char

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Char -> [[Binding]]

ShowFunction Double

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Double -> [[Binding]]

ShowFunction Float

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Float -> [[Binding]]

ShowFunction Int

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int -> [[Binding]]

ShowFunction Int8

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int8 -> [[Binding]]

ShowFunction Int16

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int16 -> [[Binding]]

ShowFunction Int32

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int32 -> [[Binding]]

ShowFunction Int64

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int64 -> [[Binding]]

ShowFunction Integer

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Integer -> [[Binding]]

ShowFunction Ordering

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Ordering -> [[Binding]]

ShowFunction Word

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word -> [[Binding]]

ShowFunction Word8

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word8 -> [[Binding]]

ShowFunction Word16

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word16 -> [[Binding]]

ShowFunction Word32

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word32 -> [[Binding]]

ShowFunction Word64

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word64 -> [[Binding]]

ShowFunction ()

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: () -> [[Binding]]

ShowFunction ExitCode

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: ExitCode -> [[Binding]]

ShowFunction BufferMode

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: BufferMode -> [[Binding]]

ShowFunction SeekMode

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: SeekMode -> [[Binding]]

ShowFunction CChar

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CChar -> [[Binding]]

ShowFunction CSChar

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CSChar -> [[Binding]]

ShowFunction CUChar

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CUChar -> [[Binding]]

ShowFunction CShort

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CShort -> [[Binding]]

ShowFunction CUShort

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CUShort -> [[Binding]]

ShowFunction CInt

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CInt -> [[Binding]]

ShowFunction CUInt

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CUInt -> [[Binding]]

ShowFunction CLong

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CLong -> [[Binding]]

ShowFunction CULong

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CULong -> [[Binding]]

ShowFunction CLLong

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CLLong -> [[Binding]]

ShowFunction CULLong

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CULLong -> [[Binding]]

ShowFunction CBool

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CBool -> [[Binding]]

ShowFunction CFloat

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CFloat -> [[Binding]]

ShowFunction CDouble

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CDouble -> [[Binding]]

ShowFunction CPtrdiff

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CPtrdiff -> [[Binding]]

ShowFunction CSize

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CSize -> [[Binding]]

ShowFunction CWchar

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CWchar -> [[Binding]]

ShowFunction CSigAtomic

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CSigAtomic -> [[Binding]]

ShowFunction CClock

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CClock -> [[Binding]]

ShowFunction CTime

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CTime -> [[Binding]]

ShowFunction CUSeconds

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CUSeconds -> [[Binding]]

ShowFunction CSUSeconds

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CSUSeconds -> [[Binding]]

ShowFunction CIntPtr

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CIntPtr -> [[Binding]]

ShowFunction CUIntPtr

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CUIntPtr -> [[Binding]]

ShowFunction CIntMax

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CIntMax -> [[Binding]]

ShowFunction CUIntMax

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: CUIntMax -> [[Binding]]

ShowFunction IOMode

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: IOMode -> [[Binding]]

ShowFunction GeneralCategory

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: GeneralCategory -> [[Binding]]

ShowFunction Letters

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Letters -> [[Binding]]

ShowFunction AlphaNums

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: AlphaNums -> [[Binding]]

ShowFunction Digits

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Digits -> [[Binding]]

ShowFunction Alphas

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Alphas -> [[Binding]]

ShowFunction Uppers

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Uppers -> [[Binding]]

ShowFunction Lowers

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Lowers -> [[Binding]]

ShowFunction Spaces

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Spaces -> [[Binding]]

ShowFunction Letter

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Letter -> [[Binding]]

ShowFunction AlphaNum

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: AlphaNum -> [[Binding]]

ShowFunction Digit

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Digit -> [[Binding]]

ShowFunction Alpha

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Alpha -> [[Binding]]

ShowFunction Upper

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Upper -> [[Binding]]

ShowFunction Lower

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Lower -> [[Binding]]

ShowFunction Space

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Space -> [[Binding]]

ShowFunction Nat7

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat7 -> [[Binding]]

ShowFunction Nat6

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat6 -> [[Binding]]

ShowFunction Nat5

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat5 -> [[Binding]]

ShowFunction Nat4

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat4 -> [[Binding]]

ShowFunction Nat3

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat3 -> [[Binding]]

ShowFunction Nat2

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat2 -> [[Binding]]

ShowFunction Nat1

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat1 -> [[Binding]]

ShowFunction Nat

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Nat -> [[Binding]]

ShowFunction Natural

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Natural -> [[Binding]]

ShowFunction Word4

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word4 -> [[Binding]]

ShowFunction Word3

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word3 -> [[Binding]]

ShowFunction Word2

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word2 -> [[Binding]]

ShowFunction Word1

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Word1 -> [[Binding]]

ShowFunction Int4

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int4 -> [[Binding]]

ShowFunction Int3

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int3 -> [[Binding]]

ShowFunction Int2

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int2 -> [[Binding]]

ShowFunction Int1

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Int1 -> [[Binding]]

Show a => ShowFunction [a]

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: [a] -> [[Binding]]

Show a => ShowFunction (Maybe a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Maybe a -> [[Binding]]

(Integral a, Show a) => ShowFunction (Ratio a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Ratio a -> [[Binding]]

(RealFloat a, Show a) => ShowFunction (Complex a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Complex a -> [[Binding]]

Show a => ShowFunction (Xs a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Xs a -> [[Binding]]

Show a => ShowFunction (X a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: X a -> [[Binding]]

Show a => ShowFunction (Set a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Set a -> [[Binding]]

Show a => ShowFunction (Bag a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Bag a -> [[Binding]]

Show a => ShowFunction (NoDup a)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: NoDup a -> [[Binding]]

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

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a -> b) -> [[Binding]]

(Show a, Show b) => ShowFunction (Either a b)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Either a b -> [[Binding]]

(Show a, Show b) => ShowFunction (a, b)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b) -> [[Binding]]

(Show a, Show b) => ShowFunction (Map a b)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: Map a b -> [[Binding]]

(Show a, Show b, Show c) => ShowFunction (a, b, c)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c) -> [[Binding]]

(Show a, Show b, Show c, Show d) => ShowFunction (a, b, c, d)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d) -> [[Binding]]

(Show a, Show b, Show c, Show d, Show e) => ShowFunction (a, b, c, d, e)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d, e) -> [[Binding]]

(Show a, Show b, Show c, Show d, Show e, Show f) => ShowFunction (a, b, c, d, e, f)

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d, e, f) -> [[Binding]]

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

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d, e, f, g) -> [[Binding]]

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

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d, e, f, g, h) -> [[Binding]]

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

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d, e, f, g, h, i) -> [[Binding]]

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

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d, e, f, g, h, i, j) -> [[Binding]]

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

Defined in Test.LeanCheck.Function.ShowFunction

Methods

bindtiers :: (a, b, c, d, e, f, g, h, i, j, k) -> [[Binding]]

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

Defined in Test.LeanCheck.Function.ShowFunction

Methods

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

bindtiersShow :: Show a => a -> [[Binding]]

A drop-in implementation of bindtiers for showable types.

Define instances for showable algebraic datatypes as:

instance ShowFunction Ty where bindtiers  =  bindtiersShow

Listing functional bindings

type Binding = ([String], Maybe String)

A functional binding in a showable format. Argument values are represented as a list of strings. The result value is represented by Just a String when defined or by Nothing when undefined.

bindings :: ShowFunction a => a -> [Binding]

Given a ShowFunction value, return a list of Bindings. If the domain of the given argument function is infinite, the resulting list is infinite.

Some examples follow. These are used as running examples in the definition of explainedBindings, describedBindings and clarifiedBindings.

• Defined return values are represented as Just Strings:

  > bindings True
  [([],Just "True")]

• Undefined return values are represented as Nothing:

  > bindings undefined
  [([],Nothing)]

• Infinite domains result in an infinite bindings list:

  > bindings (id::Int->Int)
  [ (["0"], Just "0")
  , (["1"], Just "1")
  , (["-1"], Just "-1")
  , ...
  ]

• Finite domains result in a finite bindings list:

  > bindings (&&)
  [ (["False","False"], Just "False")
  , (["False","True"], Just "False")
  , (["True","False"], Just "False")
  , (["True","True"], Just "True")
  ]

  > bindings (||)
  [ (["False","False"], Just "False")
  , (["False","True"], Just "True")
  , (["True","False"], Just "True")
  , (["True","True"], Just "True")
  ]

• Even very simple functions are represented by an infinite list of bindings:

  > bindings (== 0)
  [ (["0"], Just "True")
  , (["1"], Just "False")
  , (["-1"], Just "False")
  , ...
  ]

  > bindings (== 1)
  [ (["0"], Just "False")
  , (["1"], Just "True")
  , (["-1"], Just "False")
  , ...
  ]

• Ignored arguments are still listed:

  > bindings ((\_ y -> y == 1) :: Int -> Int -> Bool)
  [ (["0","0"], Just "False")
  , (["0","1"], Just "True")
  , (["1","0"], Just "False")
  , ...
  ]

• Again, undefined values are represented as Nothing. Here, the head of an empty list is undefined:

  > bindings (head :: [Int] -> Int)
  [ (["[]"], Nothing)
  , (["[0]"], Just "0")
  , (["[0,0]"], Just "0")
  , (["[1]"], Just "1")
  , ...
  ]

Pipeline for explaining, describing and clarifying bindings

explainedBindings :: ShowFunction a => Int -> a -> [Binding]

Returns a set of bindings explaining how a function works. Some argument values are generalized to "_" when possible. It takes as argument the maximum number of cases considered for computing the explanation.

A measure of success in this generalization process is if this function returns less values than the asked maximum number of cases.

This is the first function in the clarification pipeline.

• In some cases, bindings cannot be "explained" an almost unchanged result of bindings is returned with the last binding having variables replaced by "_":

  > explainedBindings 4 (id::Int->Int)
  [ (["0"],Just "0")
  , (["1"],Just "1")
  , (["-1"],Just "-1")
  , (["_"],Just "2") ]

• When possible, some cases are generalized using _:

  > explainedBindings 10 (||)
  [ (["False","False"],Just "False")
  , (["_","_"],Just "True") ]

  but the resulting "explanation" might not be the shortest possible (cf. describedBindings):

  > explainedBindings 10 (&&)
  [ ( ["False","_"],Just "False")
  , (["_","False"],Just "False")
  , (["_","_"],Just "True") ]

• Generalization works for infinite domains (heuristically):

  > explainedBindings 10 (==0)
  [ (["0"],Just "True")
  , (["_"],Just "False") ]

• Generalization for each item is processed in the order they are generated by bindings hence explanations are not always the shortest possible (cf. describedBindings). In the following examples, the first case is redundant.

  > explainedBindings 10 (==1)
  [ (["0"],Just "False")
  , (["1"],Just "True"),
  , (["_"],Just "False") ]

  > explainedBindings 10 (\_ y -> y == 1)
  [ (["_","0"],Just "False")
  , (["_","1"],Just "True")
  , (["_","_"],Just "False") ]

describedBindings :: ShowFunction a => Int -> Int -> a -> [Binding]

Returns a set of bindings describing how a function works. Some argument values are generalized to "_" when possible. It takes two integer arguments:

1. m: the maximum number of cases considered for computing description;
2. n: the maximum number of cases in the actual description.

As a general rule of thumb, set m=n*n+1.

This is the second function in the clarification pipeline.

This function processes the result of explainedBindings to sometimes return shorter descriptions. It chooses the shortest of the following (in order):

• regular unexplained-undescribed bindings;
• regular explainedBindings;
• explainedBindings with least occurring cases generalized first;

Here are some examples:

• Sometimes the result is the same as explainedBindings:

  > describedBindings 100 10 (||)
  [ (["False","False"],Just "False")
  , (["_","_"],Just "True") ]

  > describedBindings 100 10 (==0)
  [ (["0"],Just "True")
  , (["_"],Just "False") ]

• but sometimes it is shorter because we consider generalizing least occurring cases first:

  > describedBindings 100 10 (&&)
  [ ( ["True","True"],Just "True")
  , ( ["_","_"],Just "False") ]

  > describedBindings 100 10 (==1)
  [ (["1"],Just "True"),
  , (["_"],Just "False") ]

  > describedBindings 100 10 (\_ y -> y == 1)
  [ (["_","1"],Just "True")
  , (["_","_"],Just "False") ]

clarifiedBindings :: ShowFunction a => Int -> Int -> a -> ([String], [Binding])

Returns a set of variables and a set of bindings describing how a function works.

Some argument values are generalized to "_" when possible. If one of the function arguments is not used altogether, it is ommited in the set of bindings and appears as "_" in the variables list.

This is the last function in the clarification pipeline.

It takes two integer arguments:

1. m: the maximum number of cases considered for computing the description;
2. n: the maximum number of cases in the actual description.

As a general rule of thumb, set m=n*n+1.

Some examples follow:

• When all arguments are used, the result is the same as describedBindings:

  > clarifiedBindings 100 10 (==1)
  ( ["x"], [ (["1"],Just "True"),
           , (["_"],Just "False") ] )

• When some arguments are unused, they are omitted in the list of bindings and appear as "_" in the list of variables.

  > clarifiedBindings 100 10 (\_ y -> y == 1)
  ( ["_", "y"], [ (["1"],Just "True")
                , (["_"],Just "False") ] )

Re-exports

class Listable a

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

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 F

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[F]]

list :: [F]

Listable E

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[E]]

list :: [E]

Listable D

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[D]]

list :: [D]

Listable C

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[C]]

list :: [C]

Listable B

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[B]]

list :: [B]

Listable A

Defined in Test.LeanCheck.Utils.Types

Methods

tiers :: [[A]]

list :: [A]

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