qcheck-core 0.24 · OCaml Package

The Shrink module contains combinators to build up composite shrinkers for user-defined types

Warning: A hand-written shrinker returning its own argument, will cause QCheck's shrinking phase to loop infinitely.

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

package qcheck-core