Module QCheck.Arbitrary

module Arbitrary: sig .. end

type 'a t = Random.State.t -> 'a 
A generator of arbitrary values of type 'a
val return : 'a -> 'a t
Return always the same value (e.g. 4)
val int : int -> int t
Any integer between 0 (inclusive) and the given higher bound (exclusive)
val int_range : start:int -> stop:int -> int t
val (--) : int -> int -> int t
Infix synonym for QCheck.Arbitrary.int_range
val small_int : int t
Ints lower than 100
val split_int : int t -> (int * int) t
split_int gen generates a number n from gen, and returns i, j where i + j = n
val bool : bool t
Arbitrary boolean
val char : char t
A (printable) char
val alpha : char t
Alphabetic char
val float : float -> float t
Random float
val string : string t
Random strings of small length
val string_len : int t -> string t
String of random length
val map : 'a t -> ('a -> 'b) -> 'b t
Transform an arbitrary into another
val map' : ('a -> 'b) -> 'a t -> 'b t
Since 0.3
val list : ?len:int t ->
'a t -> 'a list t
List of arbitrary length. Default len is between 0 and 10.
val opt : 'a t -> 'a option t
May return a value, or None
val pair : 'a t ->
'b t -> ('a * 'b) t
val triple : 'a t ->
'b t ->
'c t -> ('a * 'b * 'c) t
val quad : 'a t ->
'b t ->
'c t ->
'd t -> ('a * 'b * 'c * 'd) t
val list_repeat : int -> 'a t -> 'a list t
Lists of given length exactly
val array : ?len:int t ->
'a t -> 'a array t
Random array of random length
val array_repeat : int -> 'a t -> 'a array t
Random array of given length
val among : 'a list -> 'a t
Choose an element among those of the list
val among_array : 'a array -> 'a t
Choose in the array
val shuffle : 'a array -> unit t
Shuffle the array in place
Since 0.3
val choose : 'a t list -> 'a t
Choice among a list generators
val (|||) : 'a t -> 'a t -> 'a t
Choice among two generators. a ||| b is the same as choose [a;b].
val fix : ?max:int ->
base:'a t ->
('a t -> 'a t) -> 'a t
Recursive arbitrary values. The optional value max defines the maximal depth, if needed (default 15). base is the base case.
val fix_depth : depth:int t ->
base:'a t ->
('a t -> 'a t) -> 'a t
Recursive values of at most given random depth
val fail_fix : unit -> 'a
Function used to indicate that, in QCheck.Arbitrary.fix_fuel, a sub-case is impossible to fulfill.
Since 0.4
type 'a recursive_case = [ `Base of 'a t
| `Base_fuel of int -> 'a t
| `Rec of (int -> 'a list t) -> 'a t
| `Rec1 of 'a t -> 'a t
| `Rec2 of
'a t -> 'a t -> 'a t
| `Rec_fuel of
(int -> 'a list t) -> int -> 'a t ]
What is a recursive case for a fueled fixpoint?
val fix_fuel : 'a recursive_case list ->
int -> 'a option t
fix_fuel l fuel consumes fuel in recursive subcases. The idea is that l contains one or more recursive builders, such that every f in l is given a function f' : int -> 'a list t, to call with an integer n so as to obtain n recursive subcases. The function f' MUST be called exactly once per case f in l..
Since 0.3

Example:
type tree = Node of tree * tree | Leaf of int;;

let leaf_ x = Leaf x;;
let node_ x y = Node (x,y);;

let rand_tree =
   fix_fuel [
     `Base (small_int >|= leaf_);
     `Rec (fun self ->
        self 2 >>= function [x;y] ->
        return (node_ x y))
    ];;

generate (rand_tree 20);;  (* generate trees with 20 nodes *)

type tree' = Node2 of tree' * tree' | Node1 of tree' | Leaf' of int;;

let leaf' x = Leaf' x ;;
let node2 x y = Node2(x,y) ;;
let node1 x = Node1 x;;

(* alternative with [`Rec2] *)
let rand_tree' =
  fix_fuel [
     `Base (small_int >|= leaf');
     `Rec1 (fun self -> self >|= node1);
     `Rec2 (fun self1 self2 -> pure node2 <*> self1 <*> self2)
    ];;

generate ~n:1 (rand_tree' 20);;

type ('a, 'state) general_recursive_case = [ `Base of 'state -> 'a t
| `Base_fuel of int -> 'state -> 'a t
| `Rec of
(int -> ('state -> 'a) list t) ->
'state -> 'a t
| `Rec1 of
('state -> 'a t) -> 'state -> 'a t
| `Rec2 of
('state -> 'a t) ->
('state -> 'a t) -> 'state -> 'a t
| `Rec_fuel of
(int -> ('state -> 'a) list t) ->
int -> 'state -> 'a t ]
What is a recursive case for a general fueled fixpoint?
val fix_fuel_gen : ('a, 'state) general_recursive_case list ->
int -> 'state -> 'a option t
fix_fuel_gen l state fuel consumes fuel in recursive subcases, similar to what fix_fuel l fuel would do, but more general because a "state" is passed bottom-up. In recursive subcases, is that l contains one or more recursive builders, such that every f in l is given a function f' : int -> ('state -> 'a) list t, to call with an integer n so as to obtain n recursive subcases. The function f' MUST be called exactly once per case f in l..
Since 0.4
val lift : ('a -> 'b) -> 'a t -> 'b t
val lift2 : ('a -> 'b -> 'c) ->
'a t -> 'b t -> 'c t
val lift3 : ('a -> 'b -> 'c -> 'd) ->
'a t ->
'b t -> 'c t -> 'd t
val lift4 : ('a -> 'b -> 'c -> 'd -> 'e) ->
'a t ->
'b t ->
'c t -> 'd t -> 'e t
val (>>=) : 'a t ->
('a -> 'b t) -> 'b t
Monadic bind
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
Since 0.3
val (<*>) : ('a -> 'b) t ->
'a t -> 'b t
Since 0.3
val pure : 'a -> 'a t
Since 0.3
val retry : 'a option t -> 'a t
Generate until a Some value is returned
val generate : ?n:int -> ?rand:Random.State.t -> 'a t -> 'a list
Generate n random values of the given type