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.