`type 'a t = 'a -> 'a Iter.t`

Given a counter-example, return an iterator on smaller versions of the counter-example.

`val nil : 'a t`

No shrink

`val unit : unit t`

unit shrinker. Does not produce any shrinking candidates.

- since 0.6

`val bool : bool t`

bool shrinker. Shrinks towards `false`.

- since 0.23

`val char : char t`

char shrinker. Shrinks towards `'a'`.

- since 0.6

`val char_numeral : char t`

char digit shrinker. Shrinks towards `'0'`.

- since 0.19

`val char_printable : char t`

Printable char shrinker. Shrinks towards `'a'` like `!char`. The output is also a printable character.

- since 0.19

`val int : int t`

int shrinker. Shrinks towards `0`.

`val int32 : int32 t`

int32 shrinker. Shrinks towards `0l`.

- since 0.14

`val int64 : int64 t`

int64 shrinker. Shrinks towards `0L`.

- since 0.14

`val float : float t`

float shrinker. Shrinks floating point numbers towards `1.0` or `-1.0` and prefers a shorter printed rendering.

- since 0.27

`val float_bound : float -> float t`

float shrinker for bounded floating point numbers. `float_bound b` shrinks floating point numbers towards `0.` for both positive and negative bounds `b`, preferring a shorter printed rendering.

- since 0.27

`val float_range : float -> float -> float t`

`float_range low high` shrinks floating point numbers in the range `low; high` (inclusive). Shrinks towards `low` if `low >= 0.`, towards `high` if `high <= 0.`, and towards `0.` if `low < 0.` and `0. <. high`. It prefers a shorter printed rendering.

- raises `Invalid_argument`

  if `low > high`.

- since 0.27

`val option : 'a t -> 'a option t`

option shrinker. Shrinks towards `None`. `option shk` reduces `Some v` values using `shk` to reduce `v`.

`val result : 'a t -> 'e t -> ('a, 'e) Stdlib.result t`

result shrinker. `result ashk eshk` reduces `Ok a` values using `ashk` and `Error e` values using `eshk`.

- since 0.24

`val bytes : ?shrink:char t -> bytes t`

bytes shrinker. Shrinks towards shorter byte strings.

- parameter shrink

  an optional `char` shrinker.

- since 0.20

`val string : ?shrink:char t -> string t`

string shrinker. Shrinks towards `""`.

- parameter shrink

  an optional `char` shrinker.

`val filter : ('a -> bool) -> 'a t -> 'a t`

`filter f shrink` shrinks values the same as `shrink`, but only keep smaller values that satisfy `f`. This way it's easy to preserve invariants that are enforced by generators, when shrinking values

- since 0.8

`val int_aggressive : int t`

Shrink integers by trying all smaller integers (can take a lot of time!)

- since 0.7

`val list : ?shrink:'a t -> 'a list t`

Try to shrink lists by removing one or more elements.

- parameter shrink

  if provided, will be used to also try to reduce the elements of the list themselves (e.g. in an `int list` one can try to decrease the integers).

`val list_spine : 'a list t`

Try to shrink lists by removing one or more elements.

- since 0.10

`val list_elems : 'a t -> 'a list t`

Shrinks the elements of a list, without changing the list size.

- since 0.10

`val array : ?shrink:'a t -> 'a array t`

Shrink an array.

- parameter shrink

  see `list`

`val pair : 'a t -> 'b t -> ('a * 'b) t`

`pair a b` uses `a` to shrink the first element of tuples, then tries to shrink the second element using `b`. It is often better, when generating tuples, to put the "simplest" element first (atomic type rather than list, etc.) because it will be shrunk earlier. In particular, putting functions last might help.

`val triple : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t`

Similar to `pair`

`val quad : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t`

Similar to `pair`

`val tup2 : 'a t -> 'b t -> ('a * 'b) t`

`tup2 a b` uses `a` to shrink the first element of tuples, then tries to shrink the second element using `b`. It is often better, when generating tuples, to put the "simplest" element first (atomic type rather than list, etc.) because it will be shrunk earlier. In particular, putting functions last might help.

`val tup3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t`

Similar to `tup2`

`val tup4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t`

Similar to `tup2`

`val tup5 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t`

Similar to `tup2`

`val tup6 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> ('a * 'b * 'c * 'd * 'e * 'f) t`

Similar to `tup2`

`val tup7 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g) t`

Similar to `tup2`

`val tup8 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> 'h t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h) t`

Similar to `tup2`

`val tup9 : 'a t -> 'b t -> 'c t -> 'd t -> 'e t -> 'f t -> 'g t -> 'h t -> 'i t -> ('a * 'b * 'c * 'd * 'e * 'f * 'g * 'h * 'i) t`

Similar to `tup2`