Safe Haskell | None |
---|---|

Language | Haskell2010 |

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.

The module
`Test.LeanCheck.Function.Show`

(`Show`

)
exports an instance like the one above.

- showFunction :: ShowFunction a => Int -> a -> String
- showFunctionLine :: ShowFunction a => Int -> a -> String
- type Binding = ([String], Maybe String)
- bindings :: ShowFunction a => a -> [Binding]
- class ShowFunction a where
- tBindingsShow :: Show a => a -> [[Binding]]
- class Listable a

# Documentation

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

Given a number of patterns to show, shows a `ShowFunction`

value.

showFunction undefined True == "True" showFunction 3 (id::Int) == "\\x -> case x of\n\ \ 0 -> 0\n\ \ 1 -> 1\n\ \ -1 -> -1\n\ \ ...\n" showFunction 4 (&&) == "\\x y -> case (x,y) of\n\ \ (False,False) -> False\n\ \ (False,True) -> False\n\ \ (True,False) -> False\n\ \ (True,True) -> True\n"

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

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

Same as showFunction, but has no line breaks.

showFunction 2 (id::Int) == "\\x -> case x of 0 -> 0; 1 -> 1; ..."

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

Given a `ShowFunction`

value, return a list of bindings
for printing. Examples:

bindings True == [([],True)] bindings (id::Int) == [(["0"],"0"), (["1"],"1"), (["-1"],"-1"), ... bindings (&&) == [ (["False","False"], "False") , (["False","True"], "False") , (["True","False"], "False") , (["True","True"], "True") ]

class ShowFunction a where Source #

`ShowFunction`

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

As a user, you probably want `showFunction`

and `showFunctionLine`

.

Non functional instances should be defined by:

instance ShowFunction Ty where tBindings = tBindingsShow

tBindingsShow :: Show a => a -> [[Binding]] Source #

A default implementation of tBindings for already `Show`

-able types.

# Re-exports

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`

.

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.