`sig
module Generator :
sig
type 'a t = 'a Raw_quickcheck_generator.t
type 'a obs = 'a Raw_quickcheck_observer.t
module Choice :
sig
type 'a t = 'a Quickcheck_generator.Choice.t
val original_gen : 'a t -> 'a Quickcheck_generator.t
val updated_gen :
'a t ->
keep:[ `All_choices
| `All_choices_except_this_choice
| `Choices_to_the_left_of_this_choice_only
| `Choices_to_the_right_of_this_choice_only
| `This_choice_and_all_choices_to_the_left
| `This_choice_and_all_choices_to_the_right ] ->
'a Quickcheck_generator.t
val value : 'a t -> 'a
val attempts_used : 'a t -> int
end
val bind_choice : 'a t -> ('a Choice.t -> 'b t) -> 'b t
val failure : 'a t
val weighted_union : (float * 'a t) list -> 'a t
val of_fun : (unit -> 'a t) -> 'a t
val choose :
'a t ->
random_float_between_zero_and_one:(unit -> float) ->
max_attempts:int ->
[ `Choice of 'a Choice.t | `No_choices_remain | `Ran_out_of_attempts ]
val inspect :
'a t ->
[ `Failure
| `Singleton of 'a
| `Weighted_union of (float * 'a t) list ]
val ( >>= ) : 'a t -> ('a -> 'b t) -> 'b t
val ( >>| ) : 'a t -> ('a -> 'b) -> 'b t
module Monad_infix :
sig
val ( >>= ) :
'a Quickcheck_generator.t ->
('a -> 'b Quickcheck_generator.t) -> 'b Quickcheck_generator.t
val ( >>| ) :
'a Quickcheck_generator.t ->
('a -> 'b) -> 'b Quickcheck_generator.t
end
val bind : 'a t -> ('a -> 'b t) -> 'b t
val return : 'a -> 'a t
val map : 'a t -> f:('a -> 'b) -> 'b t
val join : 'a t t -> 'a t
val ignore_m : 'a t -> unit t
val all : 'a t list -> 'a list t
val all_ignore : unit t list -> unit t
val unit : unit t
val bool : bool t
val int : int t
val float : float t
val string : string t
val char : char t
val sexp : Std_internal.Sexp.t t
val char_digit : char t
val char_lowercase : char t
val char_uppercase : char t
val char_alpha : char t
val char_alphanum : char t
val char_print : char t
val char_whitespace : char t
val string_of : char t -> string t
val singleton : 'a -> 'a t
val doubleton : 'a -> 'a -> 'a t
val of_list : 'a list -> 'a t
val union : 'a t list -> 'a t
val of_sequence : ?p:Percent.t -> 'a Sequence.t -> 'a t
val tuple2 : 'a t -> 'b t -> ('a * 'b) t
val tuple3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val tuple4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val tuple5 :
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t
val tuple6 :
'a t ->
'b t ->
'c t -> 'd t -> 'e t -> 'f t -> ('a * 'b * 'c * 'd * 'e * 'f) t
val either : 'a t -> 'b t -> ('a, 'b) Either.t t
val variant2 : 'a t -> 'b t -> [ `A of 'a | `B of 'b ] t
val variant3 :
'a t -> 'b t -> 'c t -> [ `A of 'a | `B of 'b | `C of 'c ] t
val variant4 :
'a t ->
'b t ->
'c t -> 'd t -> [ `A of 'a | `B of 'b | `C of 'c | `D of 'd ] t
val variant5 :
'a t ->
'b t ->
'c t ->
'd t ->
'e t -> [ `A of 'a | `B of 'b | `C of 'c | `D of 'd | `E of 'e ] t
val variant6 :
'a t ->
'b t ->
'c t ->
'd t ->
'e t ->
'f t ->
[ `A of 'a | `B of 'b | `C of 'c | `D of 'd | `E of 'e | `F of 'f ] t
val option : 'a t -> 'a option t
val size : int t
val fn : ?branching_factor:int t -> 'a obs -> 'b t -> ('a -> 'b) t
val fn2 :
?branching_factor:int t ->
'a obs -> 'b obs -> 'c t -> ('a -> 'b -> 'c) t
val fn3 :
?branching_factor:int t ->
'a obs -> 'b obs -> 'c obs -> 'd t -> ('a -> 'b -> 'c -> 'd) t
val fn4 :
?branching_factor:int t ->
'a obs ->
'b obs -> 'c obs -> 'd obs -> 'e t -> ('a -> 'b -> 'c -> 'd -> 'e) t
val fn5 :
?branching_factor:int t ->
'a obs ->
'b obs ->
'c obs ->
'd obs -> 'e obs -> 'f t -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f) t
val fn6 :
?branching_factor:int t ->
'a obs ->
'b obs ->
'c obs ->
'd obs ->
'e obs ->
'f obs -> 'g t -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f -> 'g) t
val compare_fn :
?branching_factor:int t -> 'a obs -> ('a -> 'a -> int) t
val equal_fn :
?branching_factor:int t -> 'a obs -> ('a -> 'a -> bool) t
type ('a, 'b) fn_with_sexp = ('a -> 'b) * (unit -> Std_internal.Sexp.t)
val fn_sexp : ('a, 'b) fn_with_sexp -> Std_internal.Sexp.t
val compare_fn_with_sexp :
?branching_factor:int t -> 'a obs -> ('a, 'a -> int) fn_with_sexp t
val equal_fn_with_sexp :
?branching_factor:int t -> 'a obs -> ('a, 'a -> bool) fn_with_sexp t
val fn_with_sexp :
?branching_factor:int t ->
'a obs ->
'b t ->
sexp_of_rng:('b -> Std_internal.Sexp.t) -> ('a, 'b) fn_with_sexp t
val fn2_with_sexp :
?branching_factor:int t ->
'a obs ->
'b obs ->
'c t ->
sexp_of_rng:('c -> Std_internal.Sexp.t) ->
('a, 'b -> 'c) fn_with_sexp t
val fn3_with_sexp :
?branching_factor:int t ->
'a obs ->
'b obs ->
'c obs ->
'd t ->
sexp_of_rng:('d -> Std_internal.Sexp.t) ->
('a, 'b -> 'c -> 'd) fn_with_sexp t
val fn4_with_sexp :
?branching_factor:int t ->
'a obs ->
'b obs ->
'c obs ->
'd obs ->
'e t ->
sexp_of_rng:('e -> Std_internal.Sexp.t) ->
('a, 'b -> 'c -> 'd -> 'e) fn_with_sexp t
val fn5_with_sexp :
?branching_factor:int t ->
'a obs ->
'b obs ->
'c obs ->
'd obs ->
'e obs ->
'f t ->
sexp_of_rng:('f -> Std_internal.Sexp.t) ->
('a, 'b -> 'c -> 'd -> 'e -> 'f) fn_with_sexp t
val fn6_with_sexp :
?branching_factor:int t ->
'a obs ->
'b obs ->
'c obs ->
'd obs ->
'e obs ->
'f obs ->
'g t ->
sexp_of_rng:('g -> Std_internal.Sexp.t) ->
('a, 'b -> 'c -> 'd -> 'e -> 'f -> 'g) fn_with_sexp t
val filter_map : 'a t -> f:('a -> 'b option) -> 'b t
val filter : 'a t -> f:('a -> bool) -> 'a t
val recursive : ('a t -> 'a t) -> 'a t
val list :
?length:[ `At_least of int
| `At_most of int
| `Between_inclusive of int * int
| `Exactly of int ] ->
?unique:bool ->
?sorted:[ `Arbitrarily | `By of 'a -> 'a -> int ] ->
'a t -> 'a list t
val permute : 'a list -> 'a list t
val int_between :
lower_bound:int Comparable.bound ->
upper_bound:int Comparable.bound -> int t
type nan_dist =
Quickcheck_generator.nan_dist =
Without
| With_single
| With_all
val float_between :
nan:nan_dist ->
lower_bound:float Comparable.bound ->
upper_bound:float Comparable.bound -> float t
val float_without_nan : float t
val float_finite : float t
val sexp_of_fn_with_sexp :
('a -> Sexplib.Sexp.t) ->
('b -> Sexplib.Sexp.t) -> ('a, 'b) fn_with_sexp -> Sexplib.Sexp.t
end
module Observer :
sig
type 'a t = 'a Raw_quickcheck_observer.t
type 'a gen = 'a Raw_quickcheck_generator.t
val branching_factor : 'a t -> int
val observe :
'a t ->
'b Raw_quickcheck_generator.t ->
sexp_of_rng:('b -> Sexplib.Sexp.t) ->
branching_factor:int ->
(('a -> 'b) * (unit -> Sexplib.Sexp.t)) Raw_quickcheck_generator.t
val singleton : unit -> 'a t
val unmap :
'a t -> f:('b -> 'a) -> f_sexp:(unit -> Sexplib.Sexp.t) -> 'b t
val weighted_union : (float * 'a t) list -> 'a t
val variant2 : 'a t -> 'b t -> [ `A of 'a | `B of 'b ] t
val tuple2 : 'a t -> 'b t -> ('a * 'b) t
val tuple3 : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val tuple4 : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val tuple5 :
'a t -> 'b t -> 'c t -> 'd t -> 'e t -> ('a * 'b * 'c * 'd * 'e) t
val tuple6 :
'a t ->
'b t ->
'c t -> 'd t -> 'e t -> 'f t -> ('a * 'b * 'c * 'd * 'e * 'f) t
val fn :
?p:float ->
'a Raw_quickcheck_generator.t ->
'b t -> sexp_of_dom:('a -> Sexplib.Sexp.t) -> ('a -> 'b) t
val of_fun : (unit -> 'a t) -> 'a t
val unit : unit t
val bool : bool t
val int : int t
val float : float t
val string : string t
val char : char t
val sexp : Std_internal.Sexp.t t
val doubleton :
('a -> bool) -> f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
val enum :
int -> f:('a -> int) -> f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
val of_list :
'a list ->
equal:('a -> 'a -> bool) ->
sexp_of_elt:('a -> Std_internal.Sexp.t) -> 'a t
val option : 'a t -> 'a option t
val list : 'a t -> 'a list t
val recursive : ('a t -> 'a t) -> 'a t
val either : 'a t -> 'b t -> ('a, 'b) Either.t t
val variant3 :
'a t -> 'b t -> 'c t -> [ `A of 'a | `B of 'b | `C of 'c ] t
val variant4 :
'a t ->
'b t ->
'c t -> 'd t -> [ `A of 'a | `B of 'b | `C of 'c | `D of 'd ] t
val variant5 :
'a t ->
'b t ->
'c t ->
'd t ->
'e t -> [ `A of 'a | `B of 'b | `C of 'c | `D of 'd | `E of 'e ] t
val variant6 :
'a t ->
'b t ->
'c t ->
'd t ->
'e t ->
'f t ->
[ `A of 'a | `B of 'b | `C of 'c | `D of 'd | `E of 'e | `F of 'f ] t
val of_predicate :
'a t ->
'a t ->
f:('a -> bool) -> f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
val comparison :
compare:('a -> 'a -> int) ->
eq:'a ->
lt:'a t ->
gt:'a t ->
compare_sexp:(unit -> Std_internal.Sexp.t) ->
sexp_of_eq:('a -> Std_internal.Sexp.t) -> 'a t
val int_between :
lower_bound:int Comparable.bound ->
upper_bound:int Comparable.bound -> int t
end
val default_seed : Quickcheck_intf.seed
val default_trial_count : int
val default_trial_count_for_test_no_duplicates :
[ `Constant of int | `Scale_of_default_trial_count of float ]
val default_attempts_per_trial : float
val random_value : ?seed:Quickcheck_intf.seed -> 'a Generator.t -> 'a
val iter :
?seed:Quickcheck_intf.seed ->
?trials:int -> ?attempts:int -> 'a Generator.t -> f:('a -> unit) -> unit
val test :
?seed:Quickcheck_intf.seed ->
?trials:int ->
?attempts:int ->
?sexp_of:('a -> Sexplib.Sexp.t) ->
?examples:'a list -> 'a Generator.t -> f:('a -> unit) -> unit
val test_can_generate :
?seed:Quickcheck_intf.seed ->
?trials:int ->
?attempts:int ->
?sexp_of:('a -> Sexplib.Sexp.t) ->
'a Generator.t -> f:('a -> bool) -> unit
val test_no_duplicates :
?seed:Quickcheck_intf.seed ->
?trials:int ->
?attempts:int ->
?sexp_of:('a -> Sexplib.Sexp.t) ->
'a Generator.t ->
by:[ `Compare of 'a -> 'a -> int | `Equal of 'a -> 'a -> bool ] -> unit
val random_sequence :
?seed:Quickcheck_intf.seed -> 'a Generator.t -> 'a Sequence.t
val random_state_of_seed : Quickcheck_intf.seed -> Core_random.State.t
module Configure :
functor (Config : Quickcheck_intf.Quickcheck_config) ->
Quickcheck_intf.Quickcheck
end`