jon.recoil.org

Module Quickcheck.GeneratorSource

An 'a t a generates values of type 'a with a specific probability distribution.

Generators are constructed as functions that produce a value from a splittable pseudorandom number generator (see Splittable_random), with a ~size argument threaded through to bound the size of the result value and the depth of recursion.

There is no prescribed semantics for size other than that it must be non-negative. Non-recursive generators are free to ignore it, and recursive generators need only make sure it decreases in recursive calls and that recursion bottoms out at 0.

Sourceval create : (size:Base.Int.t -> random:Splittable_random.t -> 'a) -> 'a Core.Quickcheck.Generator.t
Sourceval generate : 'a Core.Quickcheck.Generator.t -> size:Base.Int.t -> random:Splittable_random.t -> 'a

Generators form a monad. t1 >>= fun x -> t2 replaces each value x in t1 with the values in t2; each value's probability is the product of its probability in t1 and t2.

This can be used to form distributions of related values. For instance, the following expression creates a distribution of pairs x,y where x <= y:

  Int.gen
  >>= fun x ->
  Int.gen_incl x Int.max_value
  >>| fun y ->
  x, y
include Base.Monad.S with type 'a t := 'a Core.Quickcheck.Generator.t

t >>= f returns a computation that sequences the computations represented by two monad elements. The resulting computation first does t to yield a value v, and then runs the computation returned by f v.

Sourcemodule Monad_infix : sig ... end

bind t ~f = t >>= f

join t is t >>= (fun t' -> t').

ignore_m t is map t ~f:(fun _ -> ()). ignore_m used to be called ignore, but we decided that was a bad name, because it shadowed the widely used Stdlib.ignore. Some monads still do let ignore = ignore_m for historical reasons.

Sourcemodule Let_syntax : sig ... end

These are convenient to have in scope when programming with a monad:

include Base.Applicative.S with type 'a t := 'a Core.Quickcheck.Generator.t
Sourceval return : 'a -> 'a Core.Quickcheck.Generator.t

same as apply

Sourcemodule Applicative_infix : sig ... end

size = create (fun ~size _ -> size)

with_size t ~size = create (fun ~size:_ random -> generate t ~size random)

Sourceval singleton : 'a -> 'a Core.Quickcheck.Generator.t
Sourceval doubleton : 'a -> 'a -> 'a Core.Quickcheck.Generator.t

Produce any of the given values, weighted equally.

of_list [ v1 ; ... ; vN ] = union [ singleton v1 ; ... ; singleton vN ]

Combine arbitrary generators, weighted equally.

union [ g1 ; ... ; gN ] = weighted_union [ (1.0, g1) ; ... ; (1.0, gN) ]

Generator for the values from a potentially infinite sequence. Chooses each value with probability p, or continues with probability 1-p. Must satisfy 0. < p && p <= 1..

geometric init ~p produces a geometric distribution (think "radioactive decay") that produces init with probability p, and otherwise effectively recursively chooses from geometric (init+1) ~p. The implementation can be more efficient than actual recursion. Must satisfy 0. <= p && p <= 1..

Sourceval small_non_negative_int : Base.Int.t Core.Quickcheck.Generator.t

small_non_negative_int produces a non-negative int of a tractable size, e.g. allocating a value of this size should not run out of memory.

small_positive_int produces a positive int of a tractable size, e.g. allocating a value of this size should not run out of memory.

Generators for functions; take observers for inputs and a generator for outputs.

Generator for comparison functions; result is guaranteed to be a partial order.

Generator for equality functions; result is guaranteed to be an equivalence relation.

filter_map t ~f produces y for every x in t such that f x = Some y.

filter t ~f produces every x in t such that f x = true.

Generator for recursive data type with multiple clauses. At size 0, chooses only among the non-recursive cases; at sizes greater than 0, chooses among non-recursive and recursive cases, calling the recursive cases with decremented size.

  type tree = Leaf | Node of tree * int * tree;;
  recursive_union [return Leaf] ~f:(fun self ->
    [let%map left = self
     and int = Int.gen
     and right = self
     in Node (left, int, right)])

Like recursive_union, with the addition of non-uniform weights for each clause.

Fixed-point generator. Use size to bound the size of the value and the depth of the recursion. There is no prescribed semantics for size except that it must be non-negative. For example, the following produces a naive generator for natural numbers:

  fixed_point (fun self ->
    match%bind size with
    | 0 -> singleton 0
    | n -> with_size self ~size:(n-1) >>| Int.succ)

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.

of_fun f produces a generator that lazily applies f.

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.

Generators for lists, choosing each element independently from the given element generator. list and list_non_empty distribute size among the list length and the sizes of each element. list_non_empty never generates the empty list. list_with_length generates lists of the given length, and distributes size among the sizes of the elements.