package base_quickcheck

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Basic Shrinkers
Modifying Shrinkers
Shrinkers for Recursive Types
Low-level functions

Base_quickcheck
- Library base_quickcheck
  - Base_quickcheck
    
    Generator
    
    Applicative_infix
    
    Monad_infix
    
    Let_syntax
    
    Let_syntax
    
    Open_on_rhs
    
    Debug
    
    Observer
    
    Shrinker
    
    Test
    
    S
    
    Config
    
    Seed
    
    Fields
    
    Direct
    
    Export
- Library ppx_quickcheck
  - Ppx_quickcheck
- Library ppx_quickcheck_expander
  - Ppx_quickcheck_expander
- Library ppx_quickcheck_runtime
  - Ppx_quickcheck_runtime
    
    Base
    
    Base_quickcheck
    
    Quickcheckable
    
    S
    
    S1
    
    S2
    
    S3
- Sources
  - base_quickcheck
    
    base_quickcheck.ml
    
    base_quickcheck__.ml
    
    bigarray_helpers.ml
    
    export.ml
    
    generator.ml
    
    observer.ml
    
    observer0.ml
    
    shrinker.ml
    
    test.ml
    
    test_intf.ml
    
    with_basic_types.ml
  - ppx_quickcheck
    
    ppx_quickcheck.ml
  - ppx_quickcheck_expander
    
    clause_syntax.ml
    
    clause_syntax_intf.ml
    
    environment.ml
    
    field_syntax.ml
    
    field_syntax_intf.ml
    
    import.ml
    
    ppx_generator_expander.ml
    
    ppx_observer_expander.ml
    
    ppx_quickcheck_expander.ml
    
    ppx_quickcheck_expander__.ml
    
    ppx_shrinker_expander.ml
  - ppx_quickcheck_runtime
    
    ppx_quickcheck_runtime.ml
    
    ppx_quickcheck_runtime__.ml
    
    quickcheckable.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Base_quickcheck.Shrinker`Source

Shrinkers produce small values from large values. When a random test case fails, a shrinker finds the simplest version of the problem.

Sourcetype 'a t

Basic Shrinkers

Sourceval atomic : _ t

This shrinker treats a type as atomic, never attempting to produce smaller values.

Sourceval unit : Base.unit t

Sourceval bool : Base.bool t

Sourceval char : Base.char t

Sourceval string : Base.string t

Sourceval bytes : Base.bytes t

Sourceval int : Base.int t

Sourceval int32 : Base.int32 t

Sourceval int63 : Base.Int63.t t

Sourceval int64 : Base.int64 t

Sourceval nativeint : Base.nativeint t

Sourceval float : Base.float t

Sourceval sexp : Base.Sexp.t t

Sourceval option : 'a t -> 'a Base.option t

Sourceval list : 'a t -> 'a Base.list t

Sourceval array : 'a t -> 'a Base.array t

Sourceval ref : 'a t -> 'a Base.ref t

Sourceval lazy_t : 'a t -> 'a Base.Lazy.t t

Sourceval both : 'a t -> 'b t -> ('a * 'b) t

Sourceval either : 'a t -> 'b t -> ('a, 'b) Base.Either.t t

Sourceval result : 'a t -> 'b t -> ('a, 'b) Base.Result.t t

This helper module type exists separately just to open Bigarray in its scope.

Source

val bigstring : 
  (Base.char, Bigarray.int8_unsigned_elt, Bigarray.c_layout) Bigarray.Array1.t
    t

Source

val float32_vec : 
  (Base.float, Bigarray.float32_elt, Bigarray.fortran_layout) Bigarray.Array1.t
    t

Source

val float64_vec : 
  (Base.float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array1.t
    t

Source

val float32_mat : 
  (Base.float, Bigarray.float32_elt, Bigarray.fortran_layout) Bigarray.Array2.t
    t

Source

val float64_mat : 
  (Base.float, Bigarray.float64_elt, Bigarray.fortran_layout) Bigarray.Array2.t
    t

Sourceval map_t : 'key t -> 'data t -> ('key, 'data, 'cmp) Base.Map.t t

Sourceval set_t : 'elt t -> ('elt, 'cmp) Base.Set.t t

Source

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

Source

val set_tree_using_comparator : 
  comparator:('elt, 'cmp) Base.Comparator.t ->
  'elt t ->
  ('elt, 'cmp) Base.Set.Using_comparator.Tree.t t

Modifying Shrinkers

Sourceval map : 'a t -> f:('a -> 'b) -> f_inverse:('b -> 'a) -> 'b t

Sourceval filter : 'a t -> f:('a -> Base.bool) -> 'a t

Source

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.

Shrinkers for Recursive Types

Sourceval fixed_point : ('a t -> 'a t) -> 'a t

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

Sourceval 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.

Low-level functions

Most users will not need to call these.

Sourceval create : ('a -> 'a Base.Sequence.t) -> 'a t

Sourceval shrink : 'a t -> 'a -> 'a Base.Sequence.t

package base_quickcheck

Module Base_quickcheck.ShrinkerSource

Basic Shrinkers

Modifying Shrinkers

Shrinkers for Recursive Types

Low-level functions

Module `Base_quickcheck.Shrinker`Source