Module Raw_quickcheck_generator

module Raw_quickcheck_generator: sig .. end
See Quickcheck_generator for an overview.

type 'a t 
val bind : 'a t ->
('a -> 'b t) -> 'b t
bind t f is a monadic bind that replaces each value x that has probability p in t with the probability distribution f x weighted proportionally by p. singleton, below, corresponds to monadic return.
module Choice: sig .. end  with type 'a gen := 'a t
'a Choice.t represents the choice of a value from a generator.
val bind_choice : 'a t ->
('a Choice.t -> 'b t) ->
'b t
bind_choice t f is like bind t f, except f is passed an 'a Choice.t and can thus use subsets of t by using Choice.gen with the ~keep option.

bind t f is equal to bind_choice t (fun c -> f (Choice.value c)), although bind is cheaper than bind_choice.

val failure : 'a t
Empty generator that is guaranteed to fail to produce a value.
val singleton : 'a -> 'a t
Constant generator. singleton t is equal to return t.
val weighted_union : (float * 'a t) list -> 'a t
weighted_union alist produces a generator that combines the distributions of each t in alist with the associated weights, which must be finite positive floating point values.
val of_fun : (unit -> 'a t) -> 'a t
of_fun f produces a generator that lazily applies f.

f *MUST* be deterministic or else random value generation will fail. However, it is recommended that f not be memoized. Instead, spread out the work of generating a whole distribution over many of_fun calls combined with weighted_union. This allows lazily generated generators to be garbage collected after each test and the relevant portions cheaply recomputed in subsequent tests, rather than accumulating without bound over time.

val choose : 'a t ->
random_float_between_zero_and_one:(unit -> float) ->
max_attempts:int ->
[ `Choice of 'a Choice.t
| `No_choices_remain
| `Ran_out_of_attempts ]
choose t ~random_float_between_zero_and_one makes a choice in t at random, using random_float_between_zero_and_one to produce random floats between 0. (inclusive) and 1. (exclusive) for each weighted choice. If t has been fully explored, it produces `No_choices_remain. Otherwise it produces `Choice c for some choice c in t.
val inspect : 'a t ->
[ `Failure
| `Singleton of 'a
| `Weighted_union of (float * 'a t) list ]
inspect t produces a concrete representation of the outermost constructor of t. It is possible to explore t further with recursive calls to inspect; however, be aware that t may be infinite.