type state = Random.State.ttype 'a t = state -> 'aRandom generator for values of type 'a
type 'a random_gen = 'a tval return : 'a -> 'a treturn x is the generator that always returns x. Example: let random_int = return 4 (* fair dice roll *)
Delay evaluation. Useful for side-effectful generators that need some code to run for every call. Example:
let gensym = let r = ref 0 in fun () -> incr r; !r ;;
delay (fun () ->
let name = gensym() in
small_int >>= fun i -> return (name,i)
)Same as choose but without option.
Invalid_argument if the list is empty
val choose_return : 'a list -> 'a tChoose among the list
Invalid_argument if the list is empty
replicate n g makes a list of n elements which are all generated randomly using g
sample_without_replacement n g makes a list of n elements which are all generated randomly using g with the added constraint that none of the generated random values are equal
val pick_list : 'a list -> 'a tval pick_array : 'a array -> 'a tval small_int : int tval int : int -> int tval int_range : int -> int -> int tInclusive range
val small_float : float tA reasonably small float.
val float : float -> float tRandom float within the given range
val float_range : float -> float -> float tInclusive range. float_range a b assumes a < b.
val split : int -> (int * int) option tSplit a positive value n into n1,n2 where n = n1 + n2.
None if the value is too small
val split_list : int -> len:int -> int list option tSplit a value n into a list of values whose sum is n and whose length is length.
None if the value is too small
retry g calls g until it returns some value, or until the maximum number of retries was reached. If g fails, then it counts for one iteration, and the generator retries.
maximum number of retries. Default 10
try_successively l tries each generator of l, one after the other. If some generator succeeds its result is returned, else the next generator is tried
a <?> b is a choice operator. It first tries a, and returns its result if successful. If a fails, then b is returned.
val fix :
?sub1:('a t -> 'a t) list ->
?sub2:('a t -> 'a t -> 'a t) list ->
?subn:(int t * ('a list t -> 'a t)) list ->
base:'a t ->
int t ->
'a tRecursion combinators, for building recursive values. The integer generator is used to provide fuel. The sub_ generators should use their arguments only once!
cases that recurse on one value
cases that use the recursive gen twice
cases that use a list of recursive cases
val pure : 'a -> 'a t