Base_quickcheck.Shrinker
Shrinkers produce small values from large values. When a random test case fails, a shrinker finds the simplest version of the problem.
val atomic : _ t
This shrinker treats a type as atomic, never attempting to produce smaller values.
val string : Base.string t
val bytes : Base.bytes t
val int32 : Base.int32 t
val int63 : Base.Int63.t t
val int64 : Base.int64 t
val nativeint : Base.nativeint t
val float : Base.float t
val sexp : Base.Sexp.t t
val option : 'a t -> 'a Base.option t
val array : 'a t -> 'a Base.array t
val lazy_t : 'a t -> 'a Base.Lazy.t t
val either : 'a t -> 'b t -> ('a, 'b) Base.Either.t t
val result : 'a t -> 'b t -> ('a, 'b) Base.Result.t t
This helper module type exists separately just to open Bigarray
in its scope.
val bigstring :
(Base.char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
t
val float32_vec :
(Base.float, Bigarray.float32_elt, Bigarray.fortran_layout) Bigarray.Array1.t
t
val float64_vec :
(Base.float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array1.t
t
val float32_mat :
(Base.float, Bigarray.float32_elt, Bigarray.fortran_layout) Bigarray.Array2.t
t
val float64_mat :
(Base.float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array2.t
t
val map_t : 'key t -> 'data t -> ('key, 'data, 'cmp) Base.Map.t t
val set_t : 'elt t -> ('elt, 'cmp) Base.Set.t t
val map_tree_using_comparator :
comparator:('key, 'cmp) Base.Comparator.t ->
'key t ->
'data t ->
('key, 'data, 'cmp) Base.Map.Using_comparator.Tree.t t
val set_tree_using_comparator :
comparator:('elt, 'cmp) Base.Comparator.t ->
'elt t ->
('elt, 'cmp) Base.Set.Using_comparator.Tree.t t
val filter_map :
'a t ->
f:('a -> 'b Base.option) ->
f_inverse:('b -> 'a) ->
'b t
Filters and maps according to f
, and provides input to t
via f_inverse
. Only the f
direction produces options, intentionally.
Ties the recursive knot to shrink recursive types.
For example, here is an shrinker for binary trees:
let tree_shrinker leaf_shrinker =
fixed_point (fun self ->
either leaf_shrinker (both self self)
|> map
~f:(function
| First leaf -> `Leaf leaf
| Second (l, r) -> `Node (l, r))
~f_inverse:(function
| `Leaf leaf -> First leaf
| `Node (l, r) -> Second (l, r)))
val of_lazy : 'a t Base.Lazy.t -> 'a t
Creates a t
that forces the lazy argument as necessary. Can be used to tie (mutually) recursive knots.
Most users will not need to call these.
val create : ('a -> 'a Base.Sequence.t) -> 'a t
val shrink : 'a t -> 'a -> 'a Base.Sequence.t