env ty creates default environment with ty inside.

from_core_type loc env ct transforms ct into a QCheck.arbitrary

We distinguish two cases:

• A specific arbitrary is passed throught attribute:

  type t =
  | Day of int [@arb QCheck.(map (fun x -> Day x) (0--31))] 
  | Month of int
  | Year of int
  [@@deriving arb]

• The arbitrary is derived from the core_type

from_arrow loc env (left, right) transform a function type to a QCheck.arbitrary.

TODO: this should be more documented

from_ptyp_variant loc env variant create a QCheck.arbitrary from the body of a Ptyp_variant inside variant

TODO: comment that function, it's really similar to a constructor declaration list.

from_type_kind loc env type_kind creates a QCheck.arbitrary from the type description inside type_kind

• type kind is a record, we use from_record
• type kind is a variant, we use from_variant
• Otherwise we return None because the arbitrary could not be derived.

from_record loc env label_decls create a QCheck.arbitrary using the record's description inside label_decls

For each label_declaration, we create an arbitrary as an expression. These arbitraries are passed to Types_helper.record.

from_tuple loc env cts translate every core_type inside cts and build a tuple QCheck.arbitrary using Types_helper.tuple

from_variant loc env constrs create a QCheck.arbitrary for the constructors in constrs.

We distinguish two cases:

• The type is self recursive

  type tree = Leaf | Node of int * tree * tree

The distinction betweens recursive nodes and leaves must be considered in order to avoid a infinite loop on a recursive type

• The type is a list of constructor

  type color = Green | Blue | Red | Any of int

We just have to chose one of the constructors built using from_constructor_decl.

from_constructor_decl loc env cd returns the pair (weight option * arbitrary) for cd.

Weight is the optional frequency of the arbitrary in a QCheck.frequency as constructor declaration might often be inside a list of declaration

from_type_declaration loc env td translate a type_declaration td into the according QCheck.arbitrary

type t = (* type_declaration *)
[@@deriving arb]

(* ==> *)

let arb : t QCheck.arbitrary = (* t arbitrary *)

env can either be passed from from_type_declarations with additionals information. Otherwise, from_type_declaration will build it's own environment.

from_type_declarations loc tds translate every type_declaration in tds using from_type_declaration.

List of type_declaration comes from a mutual recursive type:

type expr =
| If of expr * expr * expr
| Assign of char * expr
| Value of value

and value =
| Int of int
| Bool of bool [@@deriving arb]

(* ==> *)

let arb_expr () = (* expr arbitrary *)
and arb_expr = arb_expr ()
and arb_value () = (* value arbitrary *)
and arb_value = arb_value ()