Previous  Up  Next

Module Quickcheck_observer

module Quickcheck_observer: sig .. end
An 'a Quickcheck.Observer.t represents observations that can be made to distinguish values of type 'a. An observer maps values of type 'a to disjoint subsets ("buckets") using a finite number of observations.

Observers are used to construct distributions of random functions; see Quickcheck.Generator.fn.

One constructs an observer by breaking down an input into basic type constituents that can be individually observed. Use built-in observers for basic types when possible. Use either or the variant* observers to distinguish clauses of variants. Use the tuple* observers to get at individual fields of tuples or records. When you have a custom type with no built-in observer, construct an observer for an equivalent type, then use unmap. Use recursive to build observers for recursive types. See the below example for a binary search tree: 

      type 'a bst = Leaf | Node of 'a bst * 'a * 'a bst

      let bst_obs key_obs =
        recursive (fun bst_of_key_obs ->
          unmap (either unit (tuple3 bst_of_key_obs key_obs bst_of_key_obs))
            ~f:(function
              | Leaf           -> First ()
              | Node (l, k, r) -> Second (l, k, r))
            ~f_sexp:(fun () -> Sexp.Atom "either_of_bst"))
    

type 'a t = 'a Raw_quickcheck_observer.t 
type 'a gen = 'a Raw_quickcheck_generator.t 
include Raw_quickcheck_observer
val unit : unit t
Observers for basic types.
val bool : bool t
val int : int t
val float : float t
val string : string t
val char : char t
val sexp : Std_internal.Sexp.t t
val doubleton : ('a -> bool) ->
       f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
doubleton f ~f_sexp maps values to two "buckets" (as described in t above), depending on whether they satisfy f. f_sexp should describe f.
val enum : int ->
       f:('a -> int) ->
       f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
enum n ~f maps values to n buckets, where f produces the index for a bucket from 0 to n-1 for each value.
val of_list : 'a list ->
       equal:('a -> 'a -> bool) ->
       sexp_of_elt:('a -> Std_internal.Sexp.t) -> 'a t
of_list list ~equal maps values in list to separate buckets, and compares observed values to the elements of list using equal.
val option : 'a t -> 'a option t
val list : 'a t -> 'a list t
val recursive : ('a t -> 'a t) ->
       'a t
Fixed point observer; use recursive to create observers for recursive types. For example: 

      let sexp_obs =
        recursive (fun sexp_t ->
          unmap (variant2 string (list sexp_t))
            ~f:(function
              | Sexp.Atom atom -> `A atom
              | Sexp.List list -> `B list)
            ~f_sexp:(fun () -> Sexp.Atom "variant_of_sexp"))
    

val either : 'a t ->
       'b t -> ('a, 'b) Either.t t
val variant3 : 'a t ->
       'b t ->
       'c t ->
       [ `A of 'a | `B of 'b | `C of 'c ] t
val variant4 : 'a t ->
       'b t ->
       'c t ->
       'd t ->
       [ `A of 'a | `B of 'b | `C of 'c | `D of 'd ] t
val variant5 : 'a t ->
       'b t ->
       'c t ->
       'd t ->
       'e t ->
       [ `A of 'a | `B of 'b | `C of 'c | `D of 'd | `E of 'e ]
       t
val variant6 : 'a t ->
       'b t ->
       'c t ->
       'd t ->
       'e t ->
       'f t ->
       [ `A of 'a | `B of 'b | `C of 'c | `D of 'd | `E of 'e | `F of 'f ]
       t
val of_predicate : 'a t ->
       'a t ->
       f:('a -> bool) ->
       f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
of_predicate t1 t2 ~f combines t1 and t2, where t1 observes values that satisfy f and t2 observes values that do not satisfy f.
val comparison : compare:('a -> 'a -> int) ->
       eq:'a ->
       lt:'a t ->
       gt:'a t ->
       compare_sexp:(unit -> Std_internal.Sexp.t) ->
       sexp_of_eq:('a -> Std_internal.Sexp.t) -> 'a t
comparison ~compare ~eq ~lt ~gt combines observers lt and gt, where lt observes values less than eq according to compare, and gt observes values greater than eq according to compare.
val int_between : lower_bound:int Comparable.bound ->
       upper_bound:int Comparable.bound -> int t
int_between ~lower_bound ~upper_bound observes integers within the given bounds.