sig
  module Generator :
    sig
      type 'a t = 'Raw_quickcheck_generator.t
      type 'a obs = 'Raw_quickcheck_observer.t
      module Choice :
        sig
          type 'a t = 'Quickcheck_generator.Choice.t
          val original_gen : 'a t -> '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 ] ->
            'Quickcheck_generator.t
          val value : 'a t -> 'a
          val attempts_used : 'a t -> int
        end
      val bind_choice : 'a t -> ('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 '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 -> ('-> 'b t) -> 'b t
      val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
      module Monad_infix :
        sig
          val ( >>= ) :
            'Quickcheck_generator.t ->
            ('-> 'Quickcheck_generator.t) -> 'Quickcheck_generator.t
          val ( >>| ) :
            'Quickcheck_generator.t ->
            ('-> 'b) -> 'Quickcheck_generator.t
        end
      val bind : 'a t -> ('-> 'b t) -> 'b t
      val return : '-> 'a t
      val map : 'a t -> f:('-> '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 t
      val doubleton : '-> '-> 'a t
      val of_list : 'a list -> 'a t
      val union : 'a t list -> 'a t
      val of_sequence : ?p:Percent.t -> '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 '| `B of 'b ] t
      val variant3 :
        'a t -> 'b t -> 'c t -> [ `A of '| `B of '| `C of 'c ] t
      val variant4 :
        'a t ->
        'b t ->
        'c t -> 'd t -> [ `A of '| `B of '| `C of '| `D of 'd ] t
      val variant5 :
        'a t ->
        'b t ->
        'c t ->
        'd t ->
        'e t -> [ `A of '| `B of '| `C of '| `D of '| `E of 'e ] t
      val variant6 :
        'a t ->
        'b t ->
        'c t ->
        'd t ->
        'e t ->
        'f t ->
        [ `A of '| `B of '| `C of '| `D of '| `E of '| `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 -> ('-> 'b) t
      val fn2 :
        ?branching_factor:int t ->
        'a obs -> 'b obs -> 'c t -> ('-> '-> 'c) t
      val fn3 :
        ?branching_factor:int t ->
        'a obs -> 'b obs -> 'c obs -> 'd t -> ('-> '-> '-> 'd) t
      val fn4 :
        ?branching_factor:int t ->
        'a obs ->
        'b obs -> 'c obs -> 'd obs -> 'e t -> ('-> '-> '-> '-> 'e) t
      val fn5 :
        ?branching_factor:int t ->
        'a obs ->
        'b obs ->
        'c obs ->
        'd obs -> 'e obs -> 'f t -> ('-> '-> '-> '-> '-> 'f) t
      val fn6 :
        ?branching_factor:int t ->
        'a obs ->
        'b obs ->
        'c obs ->
        'd obs ->
        'e obs ->
        'f obs -> 'g t -> ('-> '-> '-> '-> '-> '-> 'g) t
      val compare_fn :
        ?branching_factor:int t -> 'a obs -> ('-> '-> int) t
      val equal_fn :
        ?branching_factor:int t -> 'a obs -> ('-> '-> bool) t
      type ('a, 'b) fn_with_sexp = ('-> '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, '-> int) fn_with_sexp t
      val equal_fn_with_sexp :
        ?branching_factor:int t -> 'a obs -> ('a, '-> bool) fn_with_sexp t
      val fn_with_sexp :
        ?branching_factor:int t ->
        'a obs ->
        'b t ->
        sexp_of_rng:('-> 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:('-> Std_internal.Sexp.t) ->
        ('a, '-> 'c) fn_with_sexp t
      val fn3_with_sexp :
        ?branching_factor:int t ->
        'a obs ->
        'b obs ->
        'c obs ->
        'd t ->
        sexp_of_rng:('-> Std_internal.Sexp.t) ->
        ('a, '-> '-> '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:('-> Std_internal.Sexp.t) ->
        ('a, '-> '-> '-> '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:('-> Std_internal.Sexp.t) ->
        ('a, '-> '-> '-> '-> '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:('-> Std_internal.Sexp.t) ->
        ('a, '-> '-> '-> '-> '-> 'g) fn_with_sexp t
      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
      val filter : 'a t -> f:('-> 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 '-> '-> 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 :
        ('-> Sexplib.Sexp.t) ->
        ('-> Sexplib.Sexp.t) -> ('a, 'b) fn_with_sexp -> Sexplib.Sexp.t
    end
  module Observer :
    sig
      type 'a t = 'Raw_quickcheck_observer.t
      type 'a gen = 'Raw_quickcheck_generator.t
      val branching_factor : 'a t -> int
      val observe :
        'a t ->
        'Raw_quickcheck_generator.t ->
        sexp_of_rng:('-> Sexplib.Sexp.t) ->
        branching_factor:int ->
        (('-> 'b) * (unit -> Sexplib.Sexp.t)) Raw_quickcheck_generator.t
      val singleton : unit -> 'a t
      val unmap :
        'a t -> f:('-> '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 '| `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 ->
        'Raw_quickcheck_generator.t ->
        'b t -> sexp_of_dom:('-> Sexplib.Sexp.t) -> ('-> '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 :
        ('-> bool) -> f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
      val enum :
        int -> f:('-> int) -> f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
      val of_list :
        'a list ->
        equal:('-> '-> bool) ->
        sexp_of_elt:('-> 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 '| `B of '| `C of 'c ] t
      val variant4 :
        'a t ->
        'b t ->
        'c t -> 'd t -> [ `A of '| `B of '| `C of '| `D of 'd ] t
      val variant5 :
        'a t ->
        'b t ->
        'c t ->
        'd t ->
        'e t -> [ `A of '| `B of '| `C of '| `D of '| `E of 'e ] t
      val variant6 :
        'a t ->
        'b t ->
        'c t ->
        'd t ->
        'e t ->
        'f t ->
        [ `A of '| `B of '| `C of '| `D of '| `E of '| `F of 'f ] t
      val of_predicate :
        'a t ->
        'a t ->
        f:('-> bool) -> f_sexp:(unit -> Std_internal.Sexp.t) -> 'a t
      val comparison :
        compare:('-> '-> int) ->
        eq:'->
        lt:'a t ->
        gt:'a t ->
        compare_sexp:(unit -> Std_internal.Sexp.t) ->
        sexp_of_eq:('-> 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 -> 'Generator.t -> 'a
  val iter :
    ?seed:Quickcheck_intf.seed ->
    ?trials:int -> ?attempts:int -> 'Generator.t -> f:('-> unit) -> unit
  val test :
    ?seed:Quickcheck_intf.seed ->
    ?trials:int ->
    ?attempts:int ->
    ?sexp_of:('-> Sexplib.Sexp.t) ->
    ?examples:'a list -> 'Generator.t -> f:('-> unit) -> unit
  val test_can_generate :
    ?seed:Quickcheck_intf.seed ->
    ?trials:int ->
    ?attempts:int ->
    ?sexp_of:('-> Sexplib.Sexp.t) ->
    'Generator.t -> f:('-> bool) -> unit
  val test_no_duplicates :
    ?seed:Quickcheck_intf.seed ->
    ?trials:int ->
    ?attempts:int ->
    ?sexp_of:('-> Sexplib.Sexp.t) ->
    'Generator.t ->
    by:[ `Compare of '-> '-> int | `Equal of '-> '-> bool ] -> unit
  val random_sequence :
    ?seed:Quickcheck_intf.seed -> 'Generator.t -> '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