A generator takes random state and produces a shrink tree.

pure x always generates x with no shrinks.

map f gen applies f to generated values.

bind gen f generates with gen, then uses result to select next generator.

ap fgen xgen applies generated function to generated value. Shrinks are interleaved from both generators.

make_primitive ~gen ~shrink builds a generator from a raw generation function and a shrink function. This is the escape hatch for building custom generators when the standard combinators are not sufficient.

Always generates ().

Generates true or false. Shrinks toward false.

Generates integers in full range. Shrinks toward 0.

int_range low high generates integers in [low, high]. Shrinks toward origin (default: closest to 0 within range).

• raises Invalid_argument

  if high < low, origin < low, or origin > high.

Generates non-negative integers in [0, 10_000], biased toward small values. Shrinks toward 0.

Generates integers in [-10_000, 10_000], biased toward small absolute values. Shrinks toward 0.

Generates 32-bit integers using full range. Shrinks toward 0l.

int32_range low high generates 32-bit integers in [low, high]. Shrinks toward origin (default: closest to 0l within range).

• raises Invalid_argument

  if high < low.

Generates 64-bit integers using full range. Shrinks toward 0L.

int64_range low high generates 64-bit integers in [low, high]. Shrinks toward origin (default: closest to 0L within range).

• raises Invalid_argument

  if high < low.

Generates native integers using full platform range. Shrinks toward 0n.

Generates floats using bit manipulation over the full IEEE 754 range, including NaN, infinity, and subnormal values. Shrinks toward 0.0.

float_range low high generates floats between low (inclusive) and high (exclusive). Shrinks toward origin (default: closest to 0.0 within range).

• raises Invalid_argument

  if high < low, high -. low > max_float, origin < low, or origin > high.

Generates characters in the 0..255 byte range. Shrinks toward 'a'.

char_range low high generates characters in [low, high]. Shrinks toward origin (default: low).

• raises Invalid_argument

  if high < low.

Generates strings of bytes. Length biased toward small values (see nat).

string_of char_gen generates strings using char_gen for characters. Length biased toward small values (see nat).

string_size size_gen char_gen generates strings with length from size_gen and characters from char_gen.

Generates bytes. Length biased toward small values.

option gen generates None or Some x.

• parameter ratio

  Probability of Some (default: 0.85). Shrinks toward None.

result ok_gen err_gen generates Ok or Error.

• parameter ratio

  Probability of Ok (default: 0.75).

either left_gen right_gen generates Left or Right.

• parameter ratio

  Probability of Left (default: 0.5).

list gen generates lists. Length biased toward small. Uses efficient bisection shrinking for large lists.

list_size size_gen gen generates lists with size from size_gen.

array gen generates arrays. Like list but returns array.

pair a b generates pairs.

triple a b c generates triples.

quad a b c d generates 4-tuples.

oneof gens picks one generator uniformly at random.

• raises Invalid_argument

  if gens is empty.

oneofl xs picks one element uniformly at random. Shrinks toward earlier elements in the list.

• raises Invalid_argument

  if xs is empty.

frequency weighted_gens picks a generator with probability proportional to its weight.

• raises Invalid_argument

  if weighted_gens is empty or total weight is less than 1.

sized f generates a size in [0, 1000] biased toward small values, then calls f with that size.

no_shrink gen removes all shrinks from generated trees.

add_shrink_invariant p gen filters shrinks to only those satisfying p.

delay f delays generator construction. Useful for recursive generators.

fix f creates a recursive generator. f receives the generator being defined as its argument.

  type tree = Leaf | Node of tree * tree

  let tree_gen =
    Gen.fix (fun self ->
        Gen.frequency
          [
            (3, Gen.pure Leaf);
            ( 1,
              let+ l, r = Gen.pair self self in
              Node (l, r) );
          ])

find ~f gen state attempts to find a generated value satisfying f. Tries up to count generations (default: 100). Returns None if no match is found. Does not shrink; returns the first match.

let+ x = gen in e is map (fun x -> e) gen.

gen1 and+ gen2 is pair gen1 gen2.

let* x = gen in e is bind gen (fun x -> e).

gen >|= f is map f gen.

gen >>= f is bind gen f.