bam 0.3 · OCaml Package

Main module defining basic generators.

module Shrinker : sig ... end

This module contains the various strinking strategies which can be used with the generators below.

type 'a t = 'a Gen.t

The type of random generators.

val return : 'a -> 'a t

return v is a generator for a constant value v.

val bind : 'a t -> ('a -> 'b t) -> 'b t

bind gen f returns a new generator depending on another generator. This should be the main building block to construct new generator. To understand how shrinking works with this operator please read shrinking.

val root : 'a t -> ('a -> 'b t) -> 'b t

root gen f applies f on the original value generated by gen and forgets about the shrinking. Hence, f is always applied to a single value. More details in shrinking.

val crunch : int -> 'a t -> 'a t

crunch i gen returns a new generator with a more aggressive shrinking. It increases the number of values that will be used during the shrinking. More details in shrinking.

val of_seq : 'a Seq.t -> 'a option t

of_seq seq returns a generator that will produce successively the values of the sequence until the sequence is empty. Those values are intended to be used as the root argument of other generators.

val int : 
  ?root:int ->
  ?shrinker:int Shrinker.t ->
  ?min:int ->
  ?max:int ->
  unit ->
  int t

int ?root ?shrinker ?(min=0) ?(max=Int.max_int) () is a generator for integers. Bounds are inclusive.

Default strategy is Shrinker.t.Int0.

val int32 : 
  ?root:int32 ->
  ?shrinker:int32 Shrinker.t ->
  ?min:int32 ->
  ?max:int32 ->
  unit ->
  int32 t

int ?root ?shrinker ?(min=0) ?(max=Int.max_int) () is a generator for integers. Bounds are inclusive.

Default strategy is Shrinker.t.Int0.

val int64 : 
  ?root:int64 ->
  ?shrinker:int64 Shrinker.t ->
  ?min:int64 ->
  ?max:int64 ->
  unit ->
  int64 t

int ?root ?shrinker ?(min=0) ?(max=Int.max_int) () is a generator for integers. Bounds are inclusive.

Default strategy is Shrinker.t.Int0.

val float : 
  ?root:float ->
  ?shrinker:float Shrinker.t ->
  ?min:float ->
  ?max:float ->
  unit ->
  float t

float ?root ?shrinker ?(min=0.) ?(max=Float.max_float) () generates integers. Bounds are inclusive.

Default strategy is Shrinker.t.Float0..

val pair : ?shrinker:('a * 'b) Shrinker.t -> 'a t -> 'b t -> ('a * 'b) t

pair ?shrinker left right () generates a pair using the left and right generators.

Default strategy is Shrinker.t.Pair_left.

val bool : ?shrinker:bool Shrinker.t -> unit -> bool t

bool ?shrinker () generates a boolean.x

Default strategy is Shrinker.t.Boolfalse.

val char : 
  ?root:char ->
  ?shrinker:Char.t Shrinker.t ->
  ?printable:bool ->
  unit ->
  char t

char ?root ?shrinker ?(printable=true) () generates a char.

Default strategy is Shrinker.t.Char'a.

val list : ?shrinker:'a list Shrinker.t -> size:int t -> 'a t -> 'a list t

list ?shrinker ~size gen () generates a list of values using gen.

Default strategy is Shrinker.t.Prefix.

val string : 
  ?shrinker:Char.t list Shrinker.t ->
  ?char:Char.t t ->
  size:int t ->
  unit ->
  string t

string ?shrinker ?char ~size () is mostly an alias for list ?shrinker ~char:(char ()).

val bytes : 
  ?shrinker:Char.t list Shrinker.t ->
  ?char:Char.t t ->
  size:int t ->
  unit ->
  bytes t

bytes ?shrinker ?char ~size () is mostly an alias for list ?shrinker ~char:(char ~printable:false ()) ().

val oneof : ?shrinker:int Shrinker.t -> (int * 'a t) list -> 'a t

oneof ?shrinker list pick one generator of the list according to the distribution defined by the first elements of the list.

Default strategy is the same as for int. This generator can be thought as a repeated list of generators. The shrinker will choose particular index from the list.

val oneofg : ?shrinker:int Shrinker.t -> 'a t list -> 'a t

oneofg ?shrinker list is an alias for oneof ?shrinker (List.map (fun gen -> (1, gen)) list)

val oneofl : ?shrinker:int Shrinker.t -> 'a list -> 'a t

oneofl ?shrinker list is an alias for oneofg ?shrinker (List.map Gen.return list

module Syntax : sig ... end

package bam