The shrinker type. A shrinker is a function that takes a value and returns a list of values that are in some sense "smaller" than the given value. If there are no such values conceptually, then the shrinker should just return the empty list.

Perform shrinking. Takes a predicate that returns True if you want shrinking to continue (e.g. the test failed). Also takes a shrinker and a value to shrink. It returns the shrunken value, or the input value if no shrunken values that satisfy the predicate are found.

Perform no shrinking. Equivalent to the empty lazy list.

Shrink the empty tuple. Equivalent to noShrink.

Shrinker of bools.

Shrinker of Order values.

Shrinker of integers.

Construct a shrinker of ints which considers the given int to be most minimal.

Shrinker of floats.

Construct a shrinker of floats which considers the given float to be most minimal.

Shrinker of chars.

Construct a shrinker of chars which considers the given char to be most minimal.

Shrinker of chars which considers the empty space as the most minimal char and omits the control key codes.

Equivalent to:

atLeastChar (Char.fromCode 32)

Shrinker of strings. Considers the empty string to be the most minimal string and the space to be the most minimal char.

Equivalent to:

convert String.fromList String.toList (list character)

Maybe shrinker constructor. Takes a shrinker of values and returns a shrinker of Maybes.

Result shrinker constructor. Takes a shrinker of errors and a shrinker of values and returns a shrinker of Results.

Lazy List shrinker constructor. Takes a shrinker of values and returns a shrinker of Lazy Lists. The lazy list being shrunk must be finite. (I mean really, how do you shrink infinity?)

List shrinker constructor. Takes a shrinker of values and returns a shrinker of Lists.

Array shrinker constructor. Takes a shrinker of values and returns a shrinker of Arrays.

2-Tuple shrinker constructor. Takes a tuple of shrinkers and returns a shrinker of tuples.

3-Tuple shrinker constructor. Takes a tuple of shrinkers and returns a shrinker of tuples.

Convert a Shrinker of a's into a Shrinker of b's using two inverse functions. ) If you use this function as follows:

shrinkerB =
    f g shrinkerA

Make sure that

`f(g(x)) == x` for all x

Or else this process will generate garbage.

Filter out the results of a shrinker. The resulting shrinker will only produce shrinks which satisfy the given predicate.

Filter out the results of a shrinker. The resulting shrinker will only throw away shrinks which satisfy the given predicate.

Merge two shrinkers. Generates all the values in the first shrinker, and then all the non-duplicated values in the second shrinker.

Re-export of Lazy.List.map This is useful in order to compose shrinkers, especially when used in conjunction with andMap. For example:

type alias Vector =
    { x : Float
    , y : Float
    , z : Float
    }


vector : Shrinker Vector
vector { x, y, z } =
    Vector
        `map` float x
        `andMap` float y
        `andMap` float z

Apply a lazy list of functions on a lazy list of values.

The argument order is so that it is easy to use in |> chains.