sig
module Types :
sig
module Poly :
sig
module type Equatable =
sig
type 'a t
val equal :
'a Reins.Types.Poly.Equatable.t ->
'a Reins.Types.Poly.Equatable.t -> bool
end
module type Comparable =
sig
type 'a t
val compare :
('a -> 'a -> int) ->
'a Reins.Types.Poly.Comparable.t ->
'a Reins.Types.Poly.Comparable.t -> int
val to_string :
('a -> string) -> 'a Reins.Types.Poly.Comparable.t -> string
end
module type Hashable =
sig
type 'a t
val equal : 'a t -> 'a t -> bool
val hash : 'a t -> int
end
module type Arbitrary =
sig
type 'a t
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int ->
Random.State.t -> 'a Reins.Types.Poly.Arbitrary.t
val to_string :
('a -> string) -> 'a Reins.Types.Poly.Arbitrary.t -> string
end
module type ArbitraryComparable =
sig
type 'a t
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
val to_string : ('a -> string) -> 'a t -> string
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
end
module ComposeComparable :
functor (A : Comparable) ->
functor (B : Comparable) ->
sig
type 'a t = 'a B.t A.t
val compare :
('a -> 'a -> int) ->
'a Reins.Types.Poly.ComposeComparable.t ->
'a Reins.Types.Poly.ComposeComparable.t -> int
val to_string :
('a -> string) ->
'a Reins.Types.Poly.ComposeComparable.t -> string
end
module ComposeGen :
functor (A : Arbitrary) ->
functor (B : Arbitrary) ->
sig
type 'a t = 'a B.t A.t
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int ->
Random.State.t -> 'a Reins.Types.Poly.ComposeGen.t
val to_string :
('a -> string) ->
'a Reins.Types.Poly.ComposeGen.t -> string
end
module ComposeGenComparable :
functor (A : ArbitraryComparable) ->
functor (B : ArbitraryComparable) ->
sig
type 'a t = 'a B.t A.t
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int ->
Random.State.t ->
'a Reins.Types.Poly.ComposeGenComparable.t
val to_string :
('a -> string) ->
'a Reins.Types.Poly.ComposeGenComparable.t -> string
val compare :
('a -> 'a -> int) ->
'a Reins.Types.Poly.ComposeGenComparable.t ->
'a Reins.Types.Poly.ComposeGenComparable.t -> int
end
module Close :
sig
type 'a t = 'a
val to_string : ('a -> 'b) -> 'a -> 'b
val compare : ('a -> 'b -> 'c) -> 'a -> 'b -> 'c
end
end
module Mono :
sig
module type Equatable =
sig
type t
val equal :
Reins.Types.Mono.Equatable.t ->
Reins.Types.Mono.Equatable.t -> bool
end
module type Comparable =
sig
type t
val compare :
Reins.Types.Mono.Comparable.t ->
Reins.Types.Mono.Comparable.t -> int
val to_string : Reins.Types.Mono.Comparable.t -> string
end
module type Hashable =
sig type t val equal : t -> t -> bool val hash : t -> int end
module type Arbitrary =
sig
type t
val gen :
?size:int -> Random.State.t -> Reins.Types.Mono.Arbitrary.t
val to_string : Reins.Types.Mono.Arbitrary.t -> string
end
module type ArbitraryComparable =
sig
type t
val gen : ?size:int -> Random.State.t -> t
val to_string : t -> string
val compare : t -> t -> int
end
module ComposeComparable :
functor (P : Poly.Comparable) ->
functor (M : Comparable) ->
sig
type t = M.t P.t
val compare :
Reins.Types.Mono.ComposeComparable.t ->
Reins.Types.Mono.ComposeComparable.t -> int
val to_string :
Reins.Types.Mono.ComposeComparable.t -> string
end
module ComposeGen :
functor (P : Poly.Arbitrary) ->
functor (M : Arbitrary) ->
sig
type t = M.t P.t
val gen :
?size:int ->
Random.State.t -> Reins.Types.Mono.ComposeGen.t
val to_string : Reins.Types.Mono.ComposeGen.t -> string
end
module ComposeGenComparable :
functor (P : Poly.ArbitraryComparable) ->
functor (M : ArbitraryComparable) ->
sig
type t = M.t P.t
val gen :
?size:int ->
Random.State.t -> Reins.Types.Mono.ComposeGenComparable.t
val to_string :
Reins.Types.Mono.ComposeGenComparable.t -> string
val compare :
Reins.Types.Mono.ComposeGenComparable.t ->
Reins.Types.Mono.ComposeGenComparable.t -> int
end
module ComparablePair :
functor (M1 : Comparable) ->
functor (M2 : Comparable) ->
sig
type t = M1.t * M2.t
val compare :
Reins.Types.Mono.ComparablePair.t ->
Reins.Types.Mono.ComparablePair.t -> int
val to_string : Reins.Types.Mono.ComparablePair.t -> string
end
module Comparable3Tuple :
functor (M1 : Comparable) ->
functor (M2 : Comparable) ->
functor (M3 : Comparable) ->
sig
type t = M1.t * M2.t * M3.t
val compare :
Reins.Types.Mono.Comparable3Tuple.t ->
Reins.Types.Mono.Comparable3Tuple.t -> int
val to_string :
Reins.Types.Mono.Comparable3Tuple.t -> string
end
module GenPair :
functor (A : Arbitrary) ->
functor (B : Arbitrary) ->
sig
type t = A.t * B.t
val gen :
?size:int -> Random.State.t -> Reins.Types.Mono.GenPair.t
val to_string : Reins.Types.Mono.GenPair.t -> string
end
module Gen3Tuple :
functor (A : Arbitrary) ->
functor (B : Arbitrary) ->
functor (C : Arbitrary) ->
sig
type t = A.t * B.t * C.t
val gen :
?size:int ->
Random.State.t -> Reins.Types.Mono.Gen3Tuple.t
val to_string : Reins.Types.Mono.Gen3Tuple.t -> string
end
end
module type Integral =
sig
type t
val zero : Reins.Types.Integral.t
val one : Reins.Types.Integral.t
val minus_one : Reins.Types.Integral.t
val abs : Reins.Types.Integral.t -> Reins.Types.Integral.t
val neg : Reins.Types.Integral.t -> Reins.Types.Integral.t
val succ : Reins.Types.Integral.t -> Reins.Types.Integral.t
val pred : Reins.Types.Integral.t -> Reins.Types.Integral.t
val add :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val sub :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val mul :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val div :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val rem :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val logand :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val lognot : Reins.Types.Integral.t -> Reins.Types.Integral.t
val logor :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val logxor :
Reins.Types.Integral.t ->
Reins.Types.Integral.t -> Reins.Types.Integral.t
val shift_left :
Reins.Types.Integral.t -> int -> Reins.Types.Integral.t
val shift_right :
Reins.Types.Integral.t -> int -> Reins.Types.Integral.t
val shift_right_logical :
Reins.Types.Integral.t -> int -> Reins.Types.Integral.t
val compare :
Reins.Types.Integral.t -> Reins.Types.Integral.t -> int
val of_int : int -> Reins.Types.Integral.t
val to_int : Reins.Types.Integral.t -> int
val of_float : float -> Reins.Types.Integral.t
val to_float : Reins.Types.Integral.t -> float
val to_string : Reins.Types.Integral.t -> string
val of_string : string -> Reins.Types.Integral.t
end
module Int :
sig
type t = int
val zero : int
val one : int
val minus_one : int
val abs : int -> int
val neg : int -> int
val succ : int -> int
val pred : int -> int
val add : int -> int -> int
val sub : int -> int -> int
val mul : int -> int -> int
val div : int -> int -> int
val rem : int -> int -> int
val logxor : int -> int -> int
val logand : int -> int -> int
val lognot : int -> int
val logor : int -> int -> int
val shift_left : int -> int -> int
val shift_right : int -> int -> int
val shift_right_logical : int -> int -> int
val of_int : 'a -> 'a
val to_int : 'a -> 'a
val of_float : float -> int
val to_float : int -> float
val of_string : string -> int
val compare : int -> int -> int
val equal : int -> int -> bool
val hash : 'a -> 'a
val to_string : int -> string
val gen : ?size:int -> Random.State.t -> int
end
module Float :
sig
type t = float
val compare : float -> float -> int
val equal : float -> float -> bool
val hash : 'a -> int
val gen : ?size:int -> Random.State.t -> float
val to_string : float -> string
end
module Bool :
sig
type t = bool
val compare : bool -> bool -> int
val equal : bool -> bool -> bool
val hash : 'a -> int
val gen : ?size:'a -> Random.State.t -> bool
val to_string : bool -> string
end
module Char :
sig
type t = char
val compare : char -> char -> int
val equal : char -> char -> bool
val hash : 'a -> int
val gen : ?size:int -> Random.State.t -> char
val to_string : char -> string
end
module Int32 :
sig
val zero : int32
val one : int32
val minus_one : int32
external neg : int32 -> int32 = "%int32_neg"
external add : int32 -> int32 -> int32 = "%int32_add"
external sub : int32 -> int32 -> int32 = "%int32_sub"
external mul : int32 -> int32 -> int32 = "%int32_mul"
external div : int32 -> int32 -> int32 = "%int32_div"
external rem : int32 -> int32 -> int32 = "%int32_mod"
val succ : int32 -> int32
val pred : int32 -> int32
val abs : int32 -> int32
val max_int : int32
val min_int : int32
external logand : int32 -> int32 -> int32 = "%int32_and"
external logor : int32 -> int32 -> int32 = "%int32_or"
external logxor : int32 -> int32 -> int32 = "%int32_xor"
val lognot : int32 -> int32
external shift_left : int32 -> int -> int32 = "%int32_lsl"
external shift_right : int32 -> int -> int32 = "%int32_asr"
external shift_right_logical : int32 -> int -> int32 = "%int32_lsr"
external of_int : int -> int32 = "%int32_of_int"
external to_int : int32 -> int = "%int32_to_int"
external of_float : float -> int32 = "caml_int32_of_float"
external to_float : int32 -> float = "caml_int32_to_float"
external of_string : string -> int32 = "caml_int32_of_string"
val to_string : int32 -> string
external bits_of_float : float -> int32
= "caml_int32_bits_of_float"
external float_of_bits : int32 -> float
= "caml_int32_float_of_bits"
type t = int32
val compare : Reins.Types.Int32.t -> Reins.Types.Int32.t -> int
external format : string -> int32 -> string = "caml_int32_format"
val equal : Reins.Types.Int32.t -> Reins.Types.Int32.t -> bool
val hash : 'a -> int
val gen : ?size:'a -> Random.State.t -> Int32.t
end
module Int64 :
sig
val zero : int64
val one : int64
val minus_one : int64
external neg : int64 -> int64 = "%int64_neg"
external add : int64 -> int64 -> int64 = "%int64_add"
external sub : int64 -> int64 -> int64 = "%int64_sub"
external mul : int64 -> int64 -> int64 = "%int64_mul"
external div : int64 -> int64 -> int64 = "%int64_div"
external rem : int64 -> int64 -> int64 = "%int64_mod"
val succ : int64 -> int64
val pred : int64 -> int64
val abs : int64 -> int64
val max_int : int64
val min_int : int64
external logand : int64 -> int64 -> int64 = "%int64_and"
external logor : int64 -> int64 -> int64 = "%int64_or"
external logxor : int64 -> int64 -> int64 = "%int64_xor"
val lognot : int64 -> int64
external shift_left : int64 -> int -> int64 = "%int64_lsl"
external shift_right : int64 -> int -> int64 = "%int64_asr"
external shift_right_logical : int64 -> int -> int64 = "%int64_lsr"
external of_int : int -> int64 = "%int64_of_int"
external to_int : int64 -> int = "%int64_to_int"
external of_float : float -> int64 = "caml_int64_of_float"
external to_float : int64 -> float = "caml_int64_to_float"
external of_int32 : int32 -> int64 = "%int64_of_int32"
external to_int32 : int64 -> int32 = "%int64_to_int32"
external of_nativeint : nativeint -> int64 = "%int64_of_nativeint"
external to_nativeint : int64 -> nativeint = "%int64_to_nativeint"
external of_string : string -> int64 = "caml_int64_of_string"
val to_string : int64 -> string
external bits_of_float : float -> int64
= "caml_int64_bits_of_float"
external float_of_bits : int64 -> float
= "caml_int64_float_of_bits"
type t = int64
val compare : Reins.Types.Int64.t -> Reins.Types.Int64.t -> int
external format : string -> int64 -> string = "caml_int64_format"
val equal : Reins.Types.Int64.t -> Reins.Types.Int64.t -> bool
val hash : 'a -> int
val gen : ?size:'a -> Random.State.t -> Int64.t
end
module Nativeint :
sig
val zero : nativeint
val one : nativeint
val minus_one : nativeint
external neg : nativeint -> nativeint = "%nativeint_neg"
external add : nativeint -> nativeint -> nativeint
= "%nativeint_add"
external sub : nativeint -> nativeint -> nativeint
= "%nativeint_sub"
external mul : nativeint -> nativeint -> nativeint
= "%nativeint_mul"
external div : nativeint -> nativeint -> nativeint
= "%nativeint_div"
external rem : nativeint -> nativeint -> nativeint
= "%nativeint_mod"
val succ : nativeint -> nativeint
val pred : nativeint -> nativeint
val abs : nativeint -> nativeint
val size : int
val max_int : nativeint
val min_int : nativeint
external logand : nativeint -> nativeint -> nativeint
= "%nativeint_and"
external logor : nativeint -> nativeint -> nativeint
= "%nativeint_or"
external logxor : nativeint -> nativeint -> nativeint
= "%nativeint_xor"
val lognot : nativeint -> nativeint
external shift_left : nativeint -> int -> nativeint
= "%nativeint_lsl"
external shift_right : nativeint -> int -> nativeint
= "%nativeint_asr"
external shift_right_logical : nativeint -> int -> nativeint
= "%nativeint_lsr"
external of_int : int -> nativeint = "%nativeint_of_int"
external to_int : nativeint -> int = "%nativeint_to_int"
external of_float : float -> nativeint = "caml_nativeint_of_float"
external to_float : nativeint -> float = "caml_nativeint_to_float"
external of_int32 : int32 -> nativeint = "%nativeint_of_int32"
external to_int32 : nativeint -> int32 = "%nativeint_to_int32"
external of_string : string -> nativeint
= "caml_nativeint_of_string"
val to_string : nativeint -> string
type t = nativeint
val compare :
Reins.Types.Nativeint.t -> Reins.Types.Nativeint.t -> int
external format : string -> nativeint -> string
= "caml_nativeint_format"
val equal :
Reins.Types.Nativeint.t -> Reins.Types.Nativeint.t -> bool
val hash : 'a -> int
val gen : ?size:'a -> Random.State.t -> Nativeint.t
end
module Big_int :
sig
type big_int = Big_int.big_int
val zero_big_int : Reins.Types.Big_int.big_int
val unit_big_int : Reins.Types.Big_int.big_int
val minus_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val abs_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val add_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val succ_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val add_int_big_int :
int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val sub_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val pred_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val mult_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val mult_int_big_int :
int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val square_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val sqrt_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val quomod_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int * Reins.Types.Big_int.big_int
val div_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val mod_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val gcd_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val power_int_positive_int :
int -> int -> Reins.Types.Big_int.big_int
val power_big_int_positive_int :
Reins.Types.Big_int.big_int -> int -> Reins.Types.Big_int.big_int
val power_int_positive_big_int :
int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val power_big_int_positive_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val sign_big_int : Reins.Types.Big_int.big_int -> int
val compare_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int -> int
val eq_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> bool
val le_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> bool
val ge_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> bool
val lt_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> bool
val gt_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> bool
val max_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val min_big_int :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val num_digits_big_int : Reins.Types.Big_int.big_int -> int
val string_of_big_int : Reins.Types.Big_int.big_int -> string
val big_int_of_string : string -> Reins.Types.Big_int.big_int
val big_int_of_int : int -> Reins.Types.Big_int.big_int
val is_int_big_int : Reins.Types.Big_int.big_int -> bool
val int_of_big_int : Reins.Types.Big_int.big_int -> int
val float_of_big_int : Reins.Types.Big_int.big_int -> float
val nat_of_big_int : Reins.Types.Big_int.big_int -> Nat.nat
val big_int_of_nat : Nat.nat -> Reins.Types.Big_int.big_int
val base_power_big_int :
int ->
int -> Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val sys_big_int_of_string :
string -> int -> int -> Reins.Types.Big_int.big_int
val round_futur_last_digit : string -> int -> int -> bool
val approx_big_int : int -> Reins.Types.Big_int.big_int -> string
type t = Reins.Types.Big_int.big_int
val equal :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> bool
val compare :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> bool
val hash : 'a -> int
val gen : ?size:'a -> Random.State.t -> Big_int.big_int
val zero : Reins.Types.Big_int.big_int
val one : Reins.Types.Big_int.big_int
val minus_one : Reins.Types.Big_int.big_int
val abs :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val neg :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val succ :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val pred :
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val add :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val sub :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val mul :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val div :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val rem :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val of_int : 'a -> int -> Reins.Types.Big_int.big_int
val to_int : 'a -> Reins.Types.Big_int.big_int -> int
val of_float : float -> Reins.Types.Big_int.big_int
val to_float : Reins.Types.Big_int.big_int -> float
val to_string : Reins.Types.Big_int.big_int -> string
val of_string : string -> Reins.Types.Big_int.big_int
end
module Ratio :
sig
type ratio = Ratio.ratio
val null_denominator : Reins.Types.Ratio.ratio -> bool
val numerator_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
val denominator_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
val sign_ratio : Reins.Types.Ratio.ratio -> int
val normalize_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val cautious_normalize_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val cautious_normalize_ratio_when_printing :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val create_ratio :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
val create_normalized_ratio :
Reins.Types.Big_int.big_int ->
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
val is_normalized_ratio : Reins.Types.Ratio.ratio -> bool
val report_sign_ratio :
Reins.Types.Ratio.ratio ->
Reins.Types.Big_int.big_int -> Reins.Types.Big_int.big_int
val abs_ratio : Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val is_integer_ratio : Reins.Types.Ratio.ratio -> bool
val add_ratio :
Reins.Types.Ratio.ratio ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val minus_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val add_int_ratio :
int -> Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val add_big_int_ratio :
Reins.Types.Big_int.big_int ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val sub_ratio :
Reins.Types.Ratio.ratio ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val mult_ratio :
Reins.Types.Ratio.ratio ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val mult_int_ratio :
int -> Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val mult_big_int_ratio :
Reins.Types.Big_int.big_int ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val square_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val inverse_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val div_ratio :
Reins.Types.Ratio.ratio ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val integer_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
val floor_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
val round_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
val ceiling_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
val eq_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
val compare_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> int
val lt_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
val le_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
val gt_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
val ge_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio -> bool
val max_ratio :
Reins.Types.Ratio.ratio ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val min_ratio :
Reins.Types.Ratio.ratio ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val eq_big_int_ratio :
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
val compare_big_int_ratio :
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> int
val lt_big_int_ratio :
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
val le_big_int_ratio :
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
val gt_big_int_ratio :
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
val ge_big_int_ratio :
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio -> bool
val int_of_ratio : Reins.Types.Ratio.ratio -> int
val ratio_of_int : int -> Reins.Types.Ratio.ratio
val ratio_of_nat : Nat.nat -> Reins.Types.Ratio.ratio
val nat_of_ratio : Reins.Types.Ratio.ratio -> Nat.nat
val ratio_of_big_int :
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
val big_int_of_ratio :
Reins.Types.Ratio.ratio -> Reins.Types.Big_int.big_int
val div_int_ratio :
int -> Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val div_ratio_int :
Reins.Types.Ratio.ratio -> int -> Reins.Types.Ratio.ratio
val div_big_int_ratio :
Reins.Types.Big_int.big_int ->
Reins.Types.Ratio.ratio -> Reins.Types.Ratio.ratio
val div_ratio_big_int :
Reins.Types.Ratio.ratio ->
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
val approx_ratio_fix : int -> Reins.Types.Ratio.ratio -> string
val approx_ratio_exp : int -> Reins.Types.Ratio.ratio -> string
val float_of_rational_string : Reins.Types.Ratio.ratio -> string
val string_of_ratio : Reins.Types.Ratio.ratio -> string
val ratio_of_string : string -> Reins.Types.Ratio.ratio
val float_of_ratio : Reins.Types.Ratio.ratio -> float
val power_ratio_positive_int :
Reins.Types.Ratio.ratio -> int -> Reins.Types.Ratio.ratio
val power_ratio_positive_big_int :
Reins.Types.Ratio.ratio ->
Reins.Types.Big_int.big_int -> Reins.Types.Ratio.ratio
val equal : 'a -> 'a -> bool
val hash : 'a -> int
val gen : ?size:'a -> Random.State.t -> Ratio.ratio
end
module Complex :
sig
type t = Complex.t = { re : float; im : float; }
val zero : Reins.Types.Complex.t
val one : Reins.Types.Complex.t
val i : Reins.Types.Complex.t
val neg : Reins.Types.Complex.t -> Reins.Types.Complex.t
val conj : Reins.Types.Complex.t -> Reins.Types.Complex.t
val add :
Reins.Types.Complex.t ->
Reins.Types.Complex.t -> Reins.Types.Complex.t
val sub :
Reins.Types.Complex.t ->
Reins.Types.Complex.t -> Reins.Types.Complex.t
val mul :
Reins.Types.Complex.t ->
Reins.Types.Complex.t -> Reins.Types.Complex.t
val inv : Reins.Types.Complex.t -> Reins.Types.Complex.t
val div :
Reins.Types.Complex.t ->
Reins.Types.Complex.t -> Reins.Types.Complex.t
val sqrt : Reins.Types.Complex.t -> Reins.Types.Complex.t
val norm2 : Reins.Types.Complex.t -> float
val norm : Reins.Types.Complex.t -> float
val arg : Reins.Types.Complex.t -> float
val polar : float -> float -> Reins.Types.Complex.t
val exp : Reins.Types.Complex.t -> Reins.Types.Complex.t
val log : Reins.Types.Complex.t -> Reins.Types.Complex.t
val pow :
Reins.Types.Complex.t ->
Reins.Types.Complex.t -> Reins.Types.Complex.t
val equal : 'a -> 'a -> bool
val hash : 'a -> int
val gen : ?size:'a -> Random.State.t -> Complex.t
end
module String :
sig
external length : string -> int = "%string_length"
external get : string -> int -> char = "%string_safe_get"
external set : string -> int -> char -> unit = "%string_safe_set"
external create : int -> string = "caml_create_string"
val make : int -> char -> string
val copy : string -> string
val sub : string -> int -> int -> string
val fill : string -> int -> int -> char -> unit
val blit : string -> int -> string -> int -> int -> unit
val concat : string -> string list -> string
val iter : (char -> unit) -> string -> unit
val escaped : string -> string
val index : string -> char -> int
val rindex : string -> char -> int
val index_from : string -> int -> char -> int
val rindex_from : string -> int -> char -> int
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
type t = string
val compare : Reins.Types.String.t -> Reins.Types.String.t -> int
external unsafe_get : string -> int -> char = "%string_unsafe_get"
external unsafe_set : string -> int -> char -> unit
= "%string_unsafe_set"
external unsafe_blit :
string -> int -> string -> int -> int -> unit
= "caml_blit_string" "noalloc"
external unsafe_fill : string -> int -> int -> char -> unit
= "caml_fill_string" "noalloc"
val equal : Reins.Types.String.t -> Reins.Types.String.t -> bool
val hash : 'a -> int
val gen : ?size:int -> Random.State.t -> string
val to_string : 'a -> 'a
end
module Option :
sig
type 'a t = 'a option
val compare : ('a -> 'b -> int) -> 'a option -> 'b option -> int
val equal : 'a option -> 'a option -> bool
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a option
val to_string : ('a -> string) -> 'a option -> string
end
end
module Quickcheck :
sig
exception Trivial
module type Law =
sig
module Arg : Types.Mono.Arbitrary
val desc : string
val law : Arg.t -> bool
end
module type Config =
sig
val num_iterations : int
val size_arg : int option
val max_trivial_percentage : float
end
module Check :
functor (Conf : Config) ->
functor (L : Law) ->
sig val desc : string val test : Random.State.t -> unit end
end
module Heaps :
sig
module type Heap_ =
sig
type 'a elt_
type 'a heap
val empty : 'a Reins.Heaps.Heap_.heap
val is_empty : 'a Reins.Heaps.Heap_.heap -> bool
val singleton :
'a Reins.Heaps.Heap_.elt_ -> 'a Reins.Heaps.Heap_.heap
val insert :
'a Reins.Heaps.Heap_.elt_ ->
'a Reins.Heaps.Heap_.heap -> 'a Reins.Heaps.Heap_.heap
val merge :
'a Reins.Heaps.Heap_.heap ->
'a Reins.Heaps.Heap_.heap -> 'a Reins.Heaps.Heap_.heap
val find_min :
'a Reins.Heaps.Heap_.heap -> 'a Reins.Heaps.Heap_.elt_
val delete_min :
'a Reins.Heaps.Heap_.heap -> 'a Reins.Heaps.Heap_.heap
end
module type MonoHeapSig =
sig
type t
type elt
type 'a elt_ = elt
type 'a heap = t
val empty : 'a heap
val is_empty : 'a heap -> bool
val singleton : 'a elt_ -> 'a heap
val insert : 'a elt_ -> 'a heap -> 'a heap
val merge : 'a heap -> 'a heap -> 'a heap
val find_min : 'a heap -> 'a elt_
val delete_min : 'a heap -> 'a heap
val to_string : 'a heap -> string
end
module type MonoHeapSigFn =
functor (C : Types.Mono.Comparable) ->
sig
type t
type elt = C.t
type 'a elt_ = elt
type 'a heap = t
val empty : 'a heap
val is_empty : 'a heap -> bool
val singleton : 'a elt_ -> 'a heap
val insert : 'a elt_ -> 'a heap -> 'a heap
val merge : 'a heap -> 'a heap -> 'a heap
val find_min : 'a heap -> 'a elt_
val delete_min : 'a heap -> 'a heap
val to_string : 'a heap -> string
end
module type GenHeapSig =
sig
type t
type elt
type 'a elt_ = elt
type 'a heap = t
val empty : 'a heap
val is_empty : 'a heap -> bool
val singleton : 'a elt_ -> 'a heap
val insert : 'a elt_ -> 'a heap -> 'a heap
val merge : 'a heap -> 'a heap -> 'a heap
val find_min : 'a heap -> 'a elt_
val delete_min : 'a heap -> 'a heap
val to_string : 'a heap -> string
val gen : ?size:int -> Random.State.t -> t
end
module type GenHeapSigFn =
functor (C : Types.Mono.ArbitraryComparable) ->
sig
type t
type elt = C.t
type 'a elt_ = elt
type 'a heap = t
val empty : 'a heap
val is_empty : 'a heap -> bool
val singleton : 'a elt_ -> 'a heap
val insert : 'a elt_ -> 'a heap -> 'a heap
val merge : 'a heap -> 'a heap -> 'a heap
val find_min : 'a heap -> 'a elt_
val delete_min : 'a heap -> 'a heap
val to_string : 'a heap -> string
val gen : ?size:int -> Random.State.t -> t
end
module type PolyHeapSig =
sig
type 'a t
type 'a elt_ = 'a
type 'a heap = 'a t
val empty : 'a heap
val is_empty : 'a heap -> bool
val singleton : 'a elt_ -> 'a heap
val insert : 'a elt_ -> 'a heap -> 'a heap
val merge : 'a heap -> 'a heap -> 'a heap
val find_min : 'a heap -> 'a elt_
val delete_min : 'a heap -> 'a heap
val to_string : ('a -> string) -> 'a heap -> string
end
end
module BinomialHeap :
sig
module MonoHeap : Heaps.MonoHeapSigFn
module GenHeap : Heaps.GenHeapSigFn
module PolyHeap : Heaps.PolyHeapSig
end
module SkewBinomialHeap :
sig
module MonoHeap : Heaps.MonoHeapSigFn
module GenHeap : Heaps.GenHeapSigFn
module PolyHeap : Heaps.PolyHeapSig
end
module Iterator :
sig
module type S =
sig
type 'a t
type 'a elt
type 'a cursor
type 'a collection
type direction
type 'a traversal =
Traverse_All
| Traverse_If of ('a -> bool)
| Traverse_While of ('a -> bool)
val create :
Reins.Iterator.S.direction ->
'a Reins.Iterator.S.elt Reins.Iterator.S.traversal ->
'a Reins.Iterator.S.collection -> 'a Reins.Iterator.S.t
val from_cursor :
Reins.Iterator.S.direction ->
'a Reins.Iterator.S.elt Reins.Iterator.S.traversal ->
'a Reins.Iterator.S.cursor -> 'a Reins.Iterator.S.t
val value : 'a Reins.Iterator.S.t -> 'a Reins.Iterator.S.elt option
val get_value : 'a Reins.Iterator.S.t -> 'a Reins.Iterator.S.elt
val at_end : 'a Reins.Iterator.S.t -> bool
val at_beg : 'a Reins.Iterator.S.t -> bool
val has_next : 'a Reins.Iterator.S.t -> bool
val next : 'a Reins.Iterator.S.t -> 'a Reins.Iterator.S.t
val has_prev : 'a Reins.Iterator.S.t -> bool
val prev : 'a Reins.Iterator.S.t -> 'a Reins.Iterator.S.t
val goto_beg : 'a Reins.Iterator.S.t -> 'a Reins.Iterator.S.t
val goto_end : 'a Reins.Iterator.S.t -> 'a Reins.Iterator.S.t
val flip : 'a Reins.Iterator.S.t -> 'a Reins.Iterator.S.t
val iter :
('a Reins.Iterator.S.elt -> unit) ->
'a Reins.Iterator.S.t -> unit
val fold :
('a -> 'b Reins.Iterator.S.elt -> 'a) ->
'a -> 'b Reins.Iterator.S.t -> 'a
end
end
module Lists :
sig
module type ListSig =
sig
type 'a t
val empty : 'a Reins.Lists.ListSig.t
val is_empty : 'a Reins.Lists.ListSig.t -> bool
val length : 'a Reins.Lists.ListSig.t -> int
val rev : 'a Reins.Lists.ListSig.t -> 'a Reins.Lists.ListSig.t
val cons :
'a -> 'a Reins.Lists.ListSig.t -> 'a Reins.Lists.ListSig.t
val snoc :
'a -> 'a Reins.Lists.ListSig.t -> 'a Reins.Lists.ListSig.t
val hd : 'a Reins.Lists.ListSig.t -> 'a
val tl : 'a Reins.Lists.ListSig.t -> 'a Reins.Lists.ListSig.t
val pop : 'a Reins.Lists.ListSig.t -> 'a * 'a Reins.Lists.ListSig.t
val last : 'a Reins.Lists.ListSig.t -> 'a
val append :
'a Reins.Lists.ListSig.t ->
'a Reins.Lists.ListSig.t -> 'a Reins.Lists.ListSig.t
val flatten :
'a Reins.Lists.ListSig.t Reins.Lists.ListSig.t ->
'a Reins.Lists.ListSig.t
val from_list : 'a list -> 'a Reins.Lists.ListSig.t
val to_list : 'a Reins.Lists.ListSig.t -> 'a list
val iter : ('a -> unit) -> 'a Reins.Lists.ListSig.t -> unit
val fold : ('a -> 'b -> 'a) -> 'a -> 'b Reins.Lists.ListSig.t -> 'a
val rev_map :
('a -> 'b) ->
'a Reins.Lists.ListSig.t -> 'b Reins.Lists.ListSig.t
val map :
('a -> 'b) ->
'a Reins.Lists.ListSig.t -> 'b Reins.Lists.ListSig.t
val to_string :
('a -> string) -> 'a Reins.Lists.ListSig.t -> string
val compare :
('a -> 'a -> int) ->
'a Reins.Lists.ListSig.t -> 'a Reins.Lists.ListSig.t -> int
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a Reins.Lists.ListSig.t
end
end
module ListCursor :
sig
module type S =
sig
type 'a list_
type 'a cursor
val to_cursor :
'a Reins.ListCursor.S.list_ -> 'a Reins.ListCursor.S.cursor
val from_cursor :
'a Reins.ListCursor.S.cursor -> 'a Reins.ListCursor.S.list_
val at_front : 'a Reins.ListCursor.S.cursor -> bool
val at_back : 'a Reins.ListCursor.S.cursor -> bool
val move_next :
'a Reins.ListCursor.S.cursor -> 'a Reins.ListCursor.S.cursor
val move_prev :
'a Reins.ListCursor.S.cursor -> 'a Reins.ListCursor.S.cursor
val goto_front :
'a Reins.ListCursor.S.cursor -> 'a Reins.ListCursor.S.cursor
val goto_back :
'a Reins.ListCursor.S.cursor -> 'a Reins.ListCursor.S.cursor
val value : 'a Reins.ListCursor.S.cursor -> 'a option
val list :
'a Reins.ListCursor.S.cursor -> 'a Reins.ListCursor.S.list_
val replace_list :
'a Reins.ListCursor.S.list_ ->
'a Reins.ListCursor.S.cursor -> 'a Reins.ListCursor.S.cursor
end
module Make :
functor (L : Lists.ListSig) ->
sig
type 'a list_ = 'a L.t
type 'a cursor
val to_cursor : 'a list_ -> 'a cursor
val from_cursor : 'a cursor -> 'a list_
val at_front : 'a cursor -> bool
val at_back : 'a cursor -> bool
val move_next : 'a cursor -> 'a cursor
val move_prev : 'a cursor -> 'a cursor
val goto_front : 'a cursor -> 'a cursor
val goto_back : 'a cursor -> 'a cursor
val value : 'a cursor -> 'a option
val list : 'a cursor -> 'a list_
val replace_list : 'a list_ -> 'a cursor -> 'a cursor
end
end
module ListIterator :
sig
module type S =
sig
type direction_ = Left_Right | Right_Left
type 'a t
type 'a elt
type 'a cursor
type 'a collection
type direction = direction_
type 'a traversal =
Traverse_All
| Traverse_If of ('a -> bool)
| Traverse_While of ('a -> bool)
val create : direction -> 'a elt traversal -> 'a collection -> 'a t
val from_cursor :
direction -> 'a elt traversal -> 'a cursor -> 'a t
val value : 'a t -> 'a elt option
val get_value : 'a t -> 'a elt
val at_end : 'a t -> bool
val at_beg : 'a t -> bool
val has_next : 'a t -> bool
val next : 'a t -> 'a t
val has_prev : 'a t -> bool
val prev : 'a t -> 'a t
val goto_beg : 'a t -> 'a t
val goto_end : 'a t -> 'a t
val flip : 'a t -> 'a t
val iter : ('a elt -> unit) -> 'a t -> unit
val fold : ('a -> 'b elt -> 'a) -> 'a -> 'b t -> 'a
end
module Make :
functor (I : ListCursor.S) ->
sig
type direction_ = Left_Right | Right_Left
type 'a t
type 'a elt = 'a
type 'a cursor = 'a I.cursor
type 'a collection = 'a I.list_
type direction = direction_
type 'a traversal =
Traverse_All
| Traverse_If of ('a -> bool)
| Traverse_While of ('a -> bool)
val create :
direction -> 'a elt traversal -> 'a collection -> 'a t
val from_cursor :
direction -> 'a elt traversal -> 'a cursor -> 'a t
val value : 'a t -> 'a elt option
val get_value : 'a t -> 'a elt
val at_end : 'a t -> bool
val at_beg : 'a t -> bool
val has_next : 'a t -> bool
val next : 'a t -> 'a t
val has_prev : 'a t -> bool
val prev : 'a t -> 'a t
val goto_beg : 'a t -> 'a t
val goto_end : 'a t -> 'a t
val flip : 'a t -> 'a t
val iter : ('a elt -> unit) -> 'a t -> unit
val fold : ('a -> 'b elt -> 'a) -> 'a -> 'b t -> 'a
end
module From_List :
functor (L : Lists.ListSig) ->
sig
type direction_ = Left_Right | Right_Left
type 'a t
type 'a elt = 'a
type 'a cursor = 'a ListCursor.Make(L).cursor
type 'a collection = 'a L.t
type direction = direction_
type 'a traversal =
Traverse_All
| Traverse_If of ('a -> bool)
| Traverse_While of ('a -> bool)
val create :
direction -> 'a elt traversal -> 'a collection -> 'a t
val from_cursor :
direction -> 'a elt traversal -> 'a cursor -> 'a t
val value : 'a t -> 'a elt option
val get_value : 'a t -> 'a elt
val at_end : 'a t -> bool
val at_beg : 'a t -> bool
val has_next : 'a t -> bool
val next : 'a t -> 'a t
val has_prev : 'a t -> bool
val prev : 'a t -> 'a t
val goto_beg : 'a t -> 'a t
val goto_end : 'a t -> 'a t
val flip : 'a t -> 'a t
val iter : ('a elt -> unit) -> 'a t -> unit
val fold : ('a -> 'b elt -> 'a) -> 'a -> 'b t -> 'a
end
end
module Sets :
sig
module type Set_ =
sig
type 'a elt_
type 'a set
type ('a, 'b) result_
val empty : 'a Reins.Sets.Set_.set
val is_empty : 'a Reins.Sets.Set_.set -> bool
val mem :
'a Reins.Sets.Set_.elt_ ->
'a Reins.Sets.Set_.set -> (bool, 'a) Reins.Sets.Set_.result_
val add :
'a Reins.Sets.Set_.elt_ ->
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.set
val singleton : 'a Reins.Sets.Set_.elt_ -> 'a Reins.Sets.Set_.set
val remove :
'a Reins.Sets.Set_.elt_ ->
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.set
val min_elt :
'a Reins.Sets.Set_.set ->
('a Reins.Sets.Set_.elt_, 'a) Reins.Sets.Set_.result_
val max_elt :
'a Reins.Sets.Set_.set ->
('a Reins.Sets.Set_.elt_, 'a) Reins.Sets.Set_.result_
val choose :
'a Reins.Sets.Set_.set ->
('a Reins.Sets.Set_.elt_, 'a) Reins.Sets.Set_.result_
val cardinal : 'a Reins.Sets.Set_.set -> int
val compare :
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.set -> int
val equal :
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.set -> bool
val iter :
('a Reins.Sets.Set_.elt_ -> unit) ->
'a Reins.Sets.Set_.set -> unit
val fold :
('a -> 'b Reins.Sets.Set_.elt_ -> 'a) ->
'a -> 'b Reins.Sets.Set_.set -> 'a
val union :
'a Reins.Sets.Set_.set ->
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.set
val inter :
'a Reins.Sets.Set_.set ->
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.set
val diff :
'a Reins.Sets.Set_.set ->
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.set
val gen1 :
(?size:int -> Random.State.t -> 'a Reins.Sets.Set_.elt_) ->
?size:int -> Random.State.t -> 'a Reins.Sets.Set_.set
val well_formed : 'a Reins.Sets.Set_.set -> bool
val of_result : ('a, 'b) Reins.Sets.Set_.result_ -> 'a
type 'a cursor_
val to_cursor :
'a Reins.Sets.Set_.set -> 'a Reins.Sets.Set_.cursor_
val from_cursor :
'a Reins.Sets.Set_.cursor_ -> 'a Reins.Sets.Set_.set
val at_top : 'a Reins.Sets.Set_.cursor_ -> bool
val at_left : 'a Reins.Sets.Set_.cursor_ -> bool
val at_right : 'a Reins.Sets.Set_.cursor_ -> bool
val move_up :
'a Reins.Sets.Set_.cursor_ -> 'a Reins.Sets.Set_.cursor_
val move_down_left :
'a Reins.Sets.Set_.cursor_ -> 'a Reins.Sets.Set_.cursor_
val move_down_right :
'a Reins.Sets.Set_.cursor_ -> 'a Reins.Sets.Set_.cursor_
val went_left : 'a Reins.Sets.Set_.cursor_ -> bool
val went_right : 'a Reins.Sets.Set_.cursor_ -> bool
val has_value : 'a Reins.Sets.Set_.cursor_ -> bool
val get_value :
'a Reins.Sets.Set_.cursor_ -> 'a Reins.Sets.Set_.elt_
end
module type MonoSetSig =
sig
type t
type elt
type cursor
type 'a result
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
end
module type MonoSetSigFn =
functor (C : Types.Mono.Comparable) ->
sig
type t
type elt = C.t
type cursor
type 'a result
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
end
module type MonoSetSigFnStd =
functor (C : Types.Mono.Comparable) ->
sig
type t
type elt = C.t
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
end
module type GenSetSig =
sig
type t
type elt
type cursor
type 'a result
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
end
module type GenSetSigFn =
functor (C : Types.Mono.ArbitraryComparable) ->
sig
type t
type elt = C.t
type cursor
type 'a result
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
end
module type GenSetSigFnStd =
functor (C : Types.Mono.ArbitraryComparable) ->
sig
type t
type elt = C.t
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
end
module type PolySetSig =
sig
type 'a t
type 'a cursor
type ('a, 'b) result
type 'a elt_ = 'a
type 'a set = 'a t
type ('a, 'b) result_ = ('a, 'b) result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = 'a cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : ('a -> string) -> 'a set -> string
end
module type PolySetSigStd =
sig
type 'a t
type 'a cursor
type ('a, 'b) result = 'a
type 'a elt_ = 'a
type 'a set = 'a t
type ('a, 'b) result_ = ('a, 'b) result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = 'a cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : ('a -> string) -> 'a set -> string
end
end
module TreeSetIterator :
sig
module type S =
sig
type ordering = PreOrder | InOrder | PostOrder
type direction_ =
Ascending of Reins.TreeSetIterator.S.ordering
| Descending of Reins.TreeSetIterator.S.ordering
type 'a t
type 'a elt
type 'a cursor
type 'a collection
type direction = direction_
type 'a traversal =
Traverse_All
| Traverse_If of ('a -> bool)
| Traverse_While of ('a -> bool)
val create : direction -> 'a elt traversal -> 'a collection -> 'a t
val from_cursor :
direction -> 'a elt traversal -> 'a cursor -> 'a t
val value : 'a t -> 'a elt option
val get_value : 'a t -> 'a elt
val at_end : 'a t -> bool
val at_beg : 'a t -> bool
val has_next : 'a t -> bool
val next : 'a t -> 'a t
val has_prev : 'a t -> bool
val prev : 'a t -> 'a t
val goto_beg : 'a t -> 'a t
val goto_end : 'a t -> 'a t
val flip : 'a t -> 'a t
val iter : ('a elt -> unit) -> 'a t -> unit
val fold : ('a -> 'b elt -> 'a) -> 'a -> 'b t -> 'a
end
module Make :
functor (T : Sets.Set_) ->
sig
type ordering = PreOrder | InOrder | PostOrder
type direction_ = Ascending of ordering | Descending of ordering
type 'a t
type 'a elt = 'a T.elt_
type 'a cursor = 'a T.cursor_
type 'a collection = 'a T.set
type direction = direction_
type 'a traversal =
Traverse_All
| Traverse_If of ('a -> bool)
| Traverse_While of ('a -> bool)
val create :
direction -> 'a elt traversal -> 'a collection -> 'a t
val from_cursor :
direction -> 'a elt traversal -> 'a cursor -> 'a t
val value : 'a t -> 'a elt option
val get_value : 'a t -> 'a elt
val at_end : 'a t -> bool
val at_beg : 'a t -> bool
val has_next : 'a t -> bool
val next : 'a t -> 'a t
val has_prev : 'a t -> bool
val prev : 'a t -> 'a t
val goto_beg : 'a t -> 'a t
val goto_end : 'a t -> 'a t
val flip : 'a t -> 'a t
val iter : ('a elt -> unit) -> 'a t -> unit
val fold : ('a -> 'b elt -> 'a) -> 'a -> 'b t -> 'a
end
end
module CatenableList :
sig
type 'a t
val empty : 'a Reins.CatenableList.t
val is_empty : 'a Reins.CatenableList.t -> bool
val length : 'a Reins.CatenableList.t -> int
val rev : 'a Reins.CatenableList.t -> 'a Reins.CatenableList.t
val hd : 'a Reins.CatenableList.t -> 'a
val tl : 'a Reins.CatenableList.t -> 'a Reins.CatenableList.t
val pop : 'a Reins.CatenableList.t -> 'a * 'a Reins.CatenableList.t
val cons : 'a -> 'a Reins.CatenableList.t -> 'a Reins.CatenableList.t
val snoc : 'a -> 'a Reins.CatenableList.t -> 'a Reins.CatenableList.t
val last : 'a Reins.CatenableList.t -> 'a
val append :
'a Reins.CatenableList.t ->
'a Reins.CatenableList.t -> 'a Reins.CatenableList.t
val flatten :
'a Reins.CatenableList.t Reins.CatenableList.t ->
'a Reins.CatenableList.t
val from_list : 'a list -> 'a Reins.CatenableList.t
val to_list : 'a Reins.CatenableList.t -> 'a list
val iter : ('a -> unit) -> 'a Reins.CatenableList.t -> unit
val fold : ('a -> 'b -> 'a) -> 'a -> 'b Reins.CatenableList.t -> 'a
val rev_map :
('a -> 'b) -> 'a Reins.CatenableList.t -> 'b Reins.CatenableList.t
val map :
('a -> 'b) -> 'a Reins.CatenableList.t -> 'b Reins.CatenableList.t
val to_string : ('a -> string) -> 'a Reins.CatenableList.t -> string
val compare :
('a -> 'a -> int) ->
'a Reins.CatenableList.t -> 'a Reins.CatenableList.t -> int
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a Reins.CatenableList.t
end
module DoubleList :
sig
module Make :
functor (L : Lists.ListSig) ->
sig
type 'a t
val empty : 'a Reins.DoubleList.Make.t
val is_empty : 'a Reins.DoubleList.Make.t -> bool
val at_front : 'a t -> bool
val at_back : 'a t -> bool
val length : 'a Reins.DoubleList.Make.t -> int
val next_length : 'a Reins.DoubleList.Make.t -> int
val prev_length : 'a Reins.DoubleList.Make.t -> int
val rev :
'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val hd : 'a Reins.DoubleList.Make.t -> 'a
val tl : 'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val pop :
'a Reins.DoubleList.Make.t -> 'a * 'a Reins.DoubleList.Make.t
val last : 'a Reins.DoubleList.Make.t -> 'a
val next :
'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val prev_hd : 'a Reins.DoubleList.Make.t -> 'a
val prev_tl :
'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val prev_pop :
'a Reins.DoubleList.Make.t -> 'a * 'a Reins.DoubleList.Make.t
val prev :
'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val cons :
'a -> 'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val prev_cons :
'a -> 'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val snoc :
'a -> 'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val prev_snoc :
'a -> 'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val append :
'a Reins.DoubleList.Make.t ->
'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val splice :
'a Reins.DoubleList.Make.t ->
'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t
val flatten :
'a Reins.DoubleList.Make.t Reins.DoubleList.Make.t ->
'a Reins.DoubleList.Make.t
val from_list : 'a list -> 'a Reins.DoubleList.Make.t
val to_list : 'a Reins.DoubleList.Make.t -> 'a list
val iter : ('a -> unit) -> 'a Reins.DoubleList.Make.t -> unit
val fold :
('a -> 'b -> 'a) -> 'a -> 'b Reins.DoubleList.Make.t -> 'a
val rev_map :
('a -> 'b) ->
'a Reins.DoubleList.Make.t -> 'b Reins.DoubleList.Make.t
val map :
('a -> 'b) ->
'a Reins.DoubleList.Make.t -> 'b Reins.DoubleList.Make.t
val to_string :
('a -> string) -> 'a Reins.DoubleList.Make.t -> string
val compare :
('a -> 'a -> int) ->
'a Reins.DoubleList.Make.t -> 'a Reins.DoubleList.Make.t -> int
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a Reins.DoubleList.Make.t
type 'a list_ = 'a t
type 'a cursor = 'a t
val to_cursor : 'a list_ -> 'a cursor
val from_cursor : 'a cursor -> 'a list_
val at_front : 'a cursor -> bool
val at_back : 'a cursor -> bool
val move_next : 'a cursor -> 'a cursor
val move_prev : 'a cursor -> 'a cursor
val goto_front : 'a cursor -> 'a cursor
val goto_back : 'a cursor -> 'a cursor
val value : 'a cursor -> 'a option
val list : 'a cursor -> 'a list_
val replace_list : 'a list_ -> 'a cursor -> 'a cursor
end
end
module DoubleQueue :
sig
type 'a t
val empty : 'a Reins.DoubleQueue.t
val is_empty : 'a Reins.DoubleQueue.t -> bool
val hd : 'a Reins.DoubleQueue.t -> 'a
val tl : 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val pop : 'a Reins.DoubleQueue.t -> 'a * 'a Reins.DoubleQueue.t
val cons : 'a -> 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val hd_back : 'a Reins.DoubleQueue.t -> 'a
val tl_back : 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val pop_back : 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t * 'a
val cons_back : 'a -> 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val snoc : 'a -> 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val last : 'a Reins.DoubleQueue.t -> 'a
val enqueue : 'a -> 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val dequeue : 'a Reins.DoubleQueue.t -> 'a * 'a Reins.DoubleQueue.t
val length : 'a Reins.DoubleQueue.t -> int
val rev : 'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val append :
'a Reins.DoubleQueue.t ->
'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val iter : ('a -> unit) -> 'a Reins.DoubleQueue.t -> unit
val fold : ('a -> 'b -> 'a) -> 'a -> 'b Reins.DoubleQueue.t -> 'a
val rev_map :
('a -> 'b) -> 'a Reins.DoubleQueue.t -> 'b Reins.DoubleQueue.t
val map :
('a -> 'b) -> 'a Reins.DoubleQueue.t -> 'b Reins.DoubleQueue.t
val to_list : 'a Reins.DoubleQueue.t -> 'a list
val from_list : 'a list -> 'a Reins.DoubleQueue.t
val flatten :
'a Reins.DoubleQueue.t Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t
val to_string : ('a -> string) -> 'a Reins.DoubleQueue.t -> string
val compare :
('a -> 'a -> int) ->
'a Reins.DoubleQueue.t -> 'a Reins.DoubleQueue.t -> int
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a Reins.DoubleQueue.t
end
module SList :
sig
type 'a t = 'a list
val empty : 'a list
val is_empty : 'a list -> bool
val cons : 'a -> 'a list -> 'a list
val pop : 'a list -> 'a * 'a list
val fold : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val snoc : 'a -> 'a list -> 'a list
val last : 'a Reins.SList.t -> 'a
val to_list : 'a -> 'a
val from_list : 'a -> 'a
val to_string : ('a -> string) -> 'a list -> string
val compare : ('a -> 'b -> int) -> 'a list -> 'b list -> int
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a list
val length : 'a list -> int
val hd : 'a list -> 'a
val tl : 'a list -> 'a list
val nth : 'a list -> int -> 'a
val rev : 'a list -> 'a list
val append : 'a list -> 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
val iter : ('a -> unit) -> 'a list -> unit
val map : ('a -> 'b) -> 'a list -> 'b list
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 :
('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
val fold_right2 :
('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val for_all : ('a -> bool) -> 'a list -> bool
val exists : ('a -> bool) -> 'a list -> bool
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val mem : 'a -> 'a list -> bool
val memq : 'a -> 'a list -> bool
val find : ('a -> bool) -> 'a list -> 'a
val filter : ('a -> bool) -> 'a list -> 'a list
val find_all : ('a -> bool) -> 'a list -> 'a list
val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
val assoc : 'a -> ('a * 'b) list -> 'b
val assq : 'a -> ('a * 'b) list -> 'b
val mem_assoc : 'a -> ('a * 'b) list -> bool
val mem_assq : 'a -> ('a * 'b) list -> bool
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val combine : 'a list -> 'b list -> ('a * 'b) list
val sort : ('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
end
module SkewBinaryList :
sig
type 'a t
val empty : 'a Reins.SkewBinaryList.t
val is_empty : 'a Reins.SkewBinaryList.t -> bool
val length : 'a Reins.SkewBinaryList.t -> int
val rev : 'a Reins.SkewBinaryList.t -> 'a Reins.SkewBinaryList.t
val cons : 'a -> 'a Reins.SkewBinaryList.t -> 'a Reins.SkewBinaryList.t
val snoc : 'a -> 'a Reins.SkewBinaryList.t -> 'a Reins.SkewBinaryList.t
val last : 'a Reins.SkewBinaryList.t -> 'a
val hd : 'a Reins.SkewBinaryList.t -> 'a
val tl : 'a Reins.SkewBinaryList.t -> 'a Reins.SkewBinaryList.t
val pop : 'a Reins.SkewBinaryList.t -> 'a * 'a Reins.SkewBinaryList.t
val append :
'a Reins.SkewBinaryList.t ->
'a Reins.SkewBinaryList.t -> 'a Reins.SkewBinaryList.t
val flatten :
'a Reins.SkewBinaryList.t Reins.SkewBinaryList.t ->
'a Reins.SkewBinaryList.t
val from_list : 'a list -> 'a Reins.SkewBinaryList.t
val to_list : 'a Reins.SkewBinaryList.t -> 'a list
val iter : ('a -> unit) -> 'a Reins.SkewBinaryList.t -> unit
val fold : ('a -> 'b -> 'a) -> 'a -> 'b Reins.SkewBinaryList.t -> 'a
val rev_map :
('a -> 'b) -> 'a Reins.SkewBinaryList.t -> 'b Reins.SkewBinaryList.t
val map :
('a -> 'b) -> 'a Reins.SkewBinaryList.t -> 'b Reins.SkewBinaryList.t
val to_string : ('a -> string) -> 'a Reins.SkewBinaryList.t -> string
val compare :
('a -> 'a -> int) ->
'a Reins.SkewBinaryList.t -> 'a Reins.SkewBinaryList.t -> int
val gen :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a Reins.SkewBinaryList.t
val lookup : int -> 'a Reins.SkewBinaryList.t -> 'a
val update :
int -> 'a -> 'a Reins.SkewBinaryList.t -> 'a Reins.SkewBinaryList.t
end
module Maps :
sig
module type Map_ =
sig
type 'a key_
type 'a elt_
type ('a, 'b) map
type ('a, 'b, 'c) result_
val empty : ('a, 'b) Reins.Maps.Map_.map
val is_empty : ('a, 'b) Reins.Maps.Map_.map -> bool
val mem :
'a Reins.Maps.Map_.key_ ->
('a, 'b) Reins.Maps.Map_.map ->
(bool, 'a, 'b) Reins.Maps.Map_.result_
val add :
'a Reins.Maps.Map_.key_ ->
'b Reins.Maps.Map_.elt_ ->
('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
val singleton :
'a Reins.Maps.Map_.key_ ->
'b Reins.Maps.Map_.elt_ -> ('a, 'b) Reins.Maps.Map_.map
val remove :
'a Reins.Maps.Map_.key_ ->
('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
val find :
'a Reins.Maps.Map_.key_ ->
('a, 'b) Reins.Maps.Map_.map ->
('b Reins.Maps.Map_.elt_, 'a, 'b) Reins.Maps.Map_.result_
val min_key :
('a, 'b) Reins.Maps.Map_.map ->
('a Reins.Maps.Map_.key_, 'a, 'b) Reins.Maps.Map_.result_
val max_key :
('a, 'b) Reins.Maps.Map_.map ->
('a Reins.Maps.Map_.key_, 'a, 'b) Reins.Maps.Map_.result_
val min_keyval :
('a, 'b) Reins.Maps.Map_.map ->
('a Reins.Maps.Map_.key_ * 'b Reins.Maps.Map_.elt_, 'a, 'b)
Reins.Maps.Map_.result_
val max_keyval :
('a, 'b) Reins.Maps.Map_.map ->
('a Reins.Maps.Map_.key_ * 'b Reins.Maps.Map_.elt_, 'a, 'b)
Reins.Maps.Map_.result_
val cardinal : ('a, 'b) Reins.Maps.Map_.map -> int
val iter :
('a Reins.Maps.Map_.key_ -> 'b Reins.Maps.Map_.elt_ -> unit) ->
('a, 'b) Reins.Maps.Map_.map -> unit
val fold :
('a -> 'b Reins.Maps.Map_.key_ -> 'c Reins.Maps.Map_.elt_ -> 'a) ->
'a -> ('b, 'c) Reins.Maps.Map_.map -> 'a
val map :
('a Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_) ->
('c, 'a) Reins.Maps.Map_.map -> ('c, 'b) Reins.Maps.Map_.map
val mapi :
('a Reins.Maps.Map_.key_ ->
'b Reins.Maps.Map_.elt_ -> 'c Reins.Maps.Map_.elt_) ->
('a, 'b) Reins.Maps.Map_.map -> ('a, 'c) Reins.Maps.Map_.map
val union :
('a Reins.Maps.Map_.key_ ->
'b Reins.Maps.Map_.elt_ ->
'b Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_) ->
('a, 'b) Reins.Maps.Map_.map ->
('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
val inter :
('a Reins.Maps.Map_.key_ ->
'b Reins.Maps.Map_.elt_ ->
'b Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_) ->
('a, 'b) Reins.Maps.Map_.map ->
('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
val diff :
('a Reins.Maps.Map_.key_ ->
'b Reins.Maps.Map_.elt_ -> 'b Reins.Maps.Map_.elt_ -> bool) ->
('a, 'b) Reins.Maps.Map_.map ->
('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.map
val well_formed : ('a, 'b) Reins.Maps.Map_.map -> bool
val of_result : ('a, 'b, 'c) Reins.Maps.Map_.result_ -> 'a
type ('a, 'b) cursor_
val to_cursor :
('a, 'b) Reins.Maps.Map_.map -> ('a, 'b) Reins.Maps.Map_.cursor_
val from_cursor :
('a, 'b) Reins.Maps.Map_.cursor_ -> ('a, 'b) Reins.Maps.Map_.map
val at_top : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
val at_left : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
val at_right : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
val move_up :
('a, 'b) Reins.Maps.Map_.cursor_ ->
('a, 'b) Reins.Maps.Map_.cursor_
val move_down_left :
('a, 'b) Reins.Maps.Map_.cursor_ ->
('a, 'b) Reins.Maps.Map_.cursor_
val move_down_right :
('a, 'b) Reins.Maps.Map_.cursor_ ->
('a, 'b) Reins.Maps.Map_.cursor_
val went_left : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
val went_right : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
val has_value : ('a, 'b) Reins.Maps.Map_.cursor_ -> bool
val get_value :
('a, 'b) Reins.Maps.Map_.cursor_ ->
'a Reins.Maps.Map_.key_ * 'b Reins.Maps.Map_.elt_
end
module type PolyMapSig =
sig
type ('a, 'b) t
type 'a key = 'a
type 'a elt = 'a
type ('a, 'b) cursor
type ('a, 'b, 'c) result
type 'a key_ = 'a
type 'a elt_ = 'a
type ('a, 'b) map = ('a, 'b) t
type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = ('a, 'b) cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val gen2 :
(?size:int -> Random.State.t -> 'a key_) ->
(?size:int -> Random.State.t -> 'b elt_) ->
?size:int -> Random.State.t -> ('a, 'b) map
val to_string : ('a -> 'b -> string) -> ('a, 'b) map -> string
val compare :
('a -> 'a -> int) ->
('b -> 'b -> int) ->
('a, 'b) Reins.Maps.PolyMapSig.t ->
('a, 'b) Reins.Maps.PolyMapSig.t -> int
val compare_keys :
('a -> 'a -> int) ->
('a, 'b) Reins.Maps.PolyMapSig.t ->
('a, 'b) Reins.Maps.PolyMapSig.t -> int
end
module type PolyMapSigStd =
sig
type ('a, 'b) t
type 'a key = 'a
type 'a elt = 'a
type ('a, 'b) cursor
type ('a, 'b, 'c) result = 'a
type 'a key_ = 'a
type 'a elt_ = 'a
type ('a, 'b) map = ('a, 'b) t
type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = ('a, 'b) cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val gen2 :
(?size:int -> Random.State.t -> 'a key_) ->
(?size:int -> Random.State.t -> 'b elt_) ->
?size:int -> Random.State.t -> ('a, 'b) map
val to_string : ('a -> 'b -> string) -> ('a, 'b) map -> string
val compare :
('a -> 'a -> int) ->
('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
val compare_keys :
('a -> 'a -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
end
module type MonoKeyMapSig =
sig
type 'a t
type key
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys :
'a Reins.Maps.MonoKeyMapSig.t ->
'a Reins.Maps.MonoKeyMapSig.t -> int
val compare :
('a -> 'a -> int) ->
'a Reins.Maps.MonoKeyMapSig.t ->
'a Reins.Maps.MonoKeyMapSig.t -> int
val to_string :
('a -> string) -> 'a Reins.Maps.MonoKeyMapSig.t -> string
val gen2 :
(?size:int -> Random.State.t -> Reins.Maps.MonoKeyMapSig.key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a Reins.Maps.MonoKeyMapSig.t
end
module type MonoKeyMapSigStd =
sig
type 'a t
type key
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result = 'a
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module type MonoKeyMapSigFnStd =
functor (C : Types.Mono.Comparable) ->
sig
type 'a t
type key = C.t
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result = 'a
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module type GenKeyMapSig =
sig
type 'a t
type key
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
val gen1 :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module type GenKeyMapSigStd =
sig
type 'a t
type key
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result = 'a
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
val gen1 :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module type GenKeyMapSigFnStd =
functor (C : Types.Mono.ArbitraryComparable) ->
sig
type 'a t
type key = C.t
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result = 'a
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
val gen1 :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module type MonoMapSig =
sig
type t
type key
type elt
type cursor
type 'a result
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys :
Reins.Maps.MonoMapSig.t -> Reins.Maps.MonoMapSig.t -> int
val compare :
Reins.Maps.MonoMapSig.t -> Reins.Maps.MonoMapSig.t -> int
val to_string : Reins.Maps.MonoMapSig.t -> string
val gen2 :
(?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.key) ->
(?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.elt) ->
?size:int -> Random.State.t -> Reins.Maps.MonoMapSig.t
end
module type MonoMapSigFn =
functor (K : Types.Mono.Comparable) ->
functor (V : Types.Mono.Comparable) ->
sig
type t
type key = K.t
type elt = V.t
type cursor
type 'a result
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) ->
('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
end
module type MonoMapSigFnStd =
functor (K : Types.Mono.Comparable) ->
functor (V : Types.Mono.Comparable) ->
sig
type t
type key = K.t
type elt = V.t
type cursor
type 'a result = 'a
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) ->
('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
end
module type GenMapSig =
sig
type t
type key
type elt
type cursor
type 'a result
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
val gen : ?size:int -> Random.State.t -> t
end
module type GenMapSigFn =
functor (K : Types.Mono.ArbitraryComparable) ->
functor (V : Types.Mono.ArbitraryComparable) ->
sig
type t
type key = K.t
type elt = V.t
type cursor
type 'a result
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) ->
('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
val gen : ?size:int -> Random.State.t -> t
end
module type GenMapSigFnStd =
functor (K : Types.Mono.ArbitraryComparable) ->
functor (V : Types.Mono.ArbitraryComparable) ->
sig
type t
type key = K.t
type elt = V.t
type cursor
type 'a result = 'a
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) ->
('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
val gen : ?size:int -> Random.State.t -> t
end
end
module AVLMap :
sig
module PolyMap : Maps.PolyMapSigStd
module MonoKeyMap : Maps.MonoKeyMapSigFnStd
module GenKeyMap : Maps.GenKeyMapSigFnStd
module MonoMap : Maps.MonoMapSigFnStd
module GenMap : Maps.GenMapSigFnStd
module AVL_PMap :
functor (HeightDiff : sig val v : int end) -> Maps.PolyMapSig
module AVL_KeyMap :
functor (HeightDiff : sig val v : int end) -> Maps.MonoKeyMapSigFnStd
module AVL_GenKeyMap :
functor (HeightDiff : sig val v : int end) -> Maps.GenKeyMapSigFnStd
module AVL_Map :
functor (HeightDiff : sig val v : int end) -> Maps.MonoMapSigFnStd
module AVL_GenMap :
functor (HeightDiff : sig val v : int end) -> Maps.GenMapSigFnStd
module Poly1 : Maps.PolyMapSig
module Poly2 : Maps.PolyMapSig
module Poly3 : Maps.PolyMapSig
module MonoKey1 : Maps.MonoKeyMapSigFnStd
module MonoKey2 : Maps.MonoKeyMapSigFnStd
module MonoKey3 : Maps.MonoKeyMapSigFnStd
module GenKey1 : Maps.GenKeyMapSigFnStd
module GenKey2 : Maps.GenKeyMapSigFnStd
module GenKey3 : Maps.GenKeyMapSigFnStd
module Mono1 : Maps.MonoMapSigFnStd
module Mono2 : Maps.MonoMapSigFnStd
module Mono3 : Maps.MonoMapSigFnStd
module Gen1 : Maps.GenMapSigFnStd
module Gen2 : Maps.GenMapSigFnStd
module Gen3 : Maps.GenMapSigFnStd
end
module PatriciaMap :
sig
module MonoKeyMap :
sig
type 'a t
type key = int
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module GenKeyMap :
sig
type 'a t
type key = int
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
val gen1 :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module MonoMap :
functor (C : Types.Mono.Comparable) ->
sig
type t
type key = int
type elt = C.t
type cursor
type 'a result
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
end
module GenMap :
functor (C : Types.Mono.ArbitraryComparable) ->
sig
type t
type key = int
type elt = C.t
type cursor
type 'a result
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
val gen : ?size:int -> Random.State.t -> t
end
end
module RBMap :
sig
module PolyMap : Maps.PolyMapSig
module MonoKeyMap : Maps.MonoKeyMapSigFnStd
module GenKeyMap : Maps.GenKeyMapSigFnStd
module MonoMap : Maps.MonoMapSigFnStd
module GenMap : Maps.GenMapSigFnStd
end
module SplayMap :
sig
module rec PolyMap :
sig
type ('a, 'b) t
type 'a key = 'a
type 'a elt = 'a
type ('a, 'b) cursor
type ('a, 'b, 'c) result = 'a * ('b, 'c) PolyMap.t
type 'a key_ = 'a
type 'a elt_ = 'a
type ('a, 'b) map = ('a, 'b) t
type ('a, 'b, 'c) result_ = ('a, 'b, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = ('a, 'b) cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val gen2 :
(?size:int -> Random.State.t -> 'a key_) ->
(?size:int -> Random.State.t -> 'b elt_) ->
?size:int -> Random.State.t -> ('a, 'b) map
val to_string : ('a -> 'b -> string) -> ('a, 'b) map -> string
val compare :
('a -> 'a -> int) ->
('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
val compare_keys :
('a -> 'a -> int) -> ('a, 'b) t -> ('a, 'b) t -> int
end
module rec MonoKeyMap :
functor (C : Types.Mono.Comparable) ->
sig
type 'a t
type key = C.t
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result = 'a * 'b MonoKeyMap(C).t
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module rec GenKeyMap :
functor (C : Types.Mono.ArbitraryComparable) ->
sig
type 'a t
type key = C.t
type 'a elt = 'a
type 'a cursor
type ('a, 'b) result = 'a * 'b GenKeyMap(C).t
type 'a key_ = key
type 'a elt_ = 'a
type ('a, 'b) map = 'b t
type ('a, 'b, 'c) result_ = ('a, 'c) result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) -> ('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = 'b cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : 'a t -> 'a t -> int
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val to_string : ('a -> string) -> 'a t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
val gen1 :
(?size:int -> Random.State.t -> 'a) ->
?size:int -> Random.State.t -> 'a t
end
module rec MonoMap :
functor (K : Types.Mono.Comparable) ->
functor (V : Types.Mono.Comparable) ->
sig
type t
type key = K.t
type elt = V.t
type cursor
type 'a result = 'a * MonoMap(K)(V).t
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) ->
('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
end
module rec GenMap :
functor (K : Types.Mono.ArbitraryComparable) ->
functor (V : Types.Mono.ArbitraryComparable) ->
sig
type t
type key = K.t
type elt = V.t
type cursor
type 'a result = 'a * GenMap(K)(V).t
type 'a key_ = key
type 'a elt_ = elt
type ('a, 'b) map = t
type ('a, 'b, 'c) result_ = 'a result
val empty : ('a, 'b) map
val is_empty : ('a, 'b) map -> bool
val mem : 'a key_ -> ('a, 'b) map -> (bool, 'a, 'b) result_
val add : 'a key_ -> 'b elt_ -> ('a, 'b) map -> ('a, 'b) map
val singleton : 'a key_ -> 'b elt_ -> ('a, 'b) map
val remove : 'a key_ -> ('a, 'b) map -> ('a, 'b) map
val find : 'a key_ -> ('a, 'b) map -> ('b elt_, 'a, 'b) result_
val min_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val max_key : ('a, 'b) map -> ('a key_, 'a, 'b) result_
val min_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val max_keyval :
('a, 'b) map -> ('a key_ * 'b elt_, 'a, 'b) result_
val cardinal : ('a, 'b) map -> int
val iter : ('a key_ -> 'b elt_ -> unit) -> ('a, 'b) map -> unit
val fold :
('a -> 'b key_ -> 'c elt_ -> 'a) -> 'a -> ('b, 'c) map -> 'a
val map : ('a elt_ -> 'b elt_) -> ('c, 'a) map -> ('c, 'b) map
val mapi :
('a key_ -> 'b elt_ -> 'c elt_) ->
('a, 'b) map -> ('a, 'c) map
val union :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val inter :
('a key_ -> 'b elt_ -> 'b elt_ -> 'b elt_) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val diff :
('a key_ -> 'b elt_ -> 'b elt_ -> bool) ->
('a, 'b) map -> ('a, 'b) map -> ('a, 'b) map
val well_formed : ('a, 'b) map -> bool
val of_result : ('a, 'b, 'c) result_ -> 'a
type ('a, 'b) cursor_ = cursor
val to_cursor : ('a, 'b) map -> ('a, 'b) cursor_
val from_cursor : ('a, 'b) cursor_ -> ('a, 'b) map
val at_top : ('a, 'b) cursor_ -> bool
val at_left : ('a, 'b) cursor_ -> bool
val at_right : ('a, 'b) cursor_ -> bool
val move_up : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_left : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val move_down_right : ('a, 'b) cursor_ -> ('a, 'b) cursor_
val went_left : ('a, 'b) cursor_ -> bool
val went_right : ('a, 'b) cursor_ -> bool
val has_value : ('a, 'b) cursor_ -> bool
val get_value : ('a, 'b) cursor_ -> 'a key_ * 'b elt_
val compare_keys : t -> t -> int
val compare : t -> t -> int
val to_string : t -> string
val gen2 :
(?size:int -> Random.State.t -> key) ->
(?size:int -> Random.State.t -> elt) ->
?size:int -> Random.State.t -> t
val gen : ?size:int -> Random.State.t -> t
end
end
module Dug :
sig
module Id : Types.Integral
type ('a, 'b, 'c) kind =
Generator of 'a
| Mutator of 'b
| Observer of 'c
type ('a, 'b, 'c) edge = {
target : Id.t;
op : ('a, 'b, 'c) Reins.Dug.kind;
pos : int;
}
type ('a, 'b, 'c) t = {
mutable current_id : Id.t;
nodes : (Id.t, ('a, 'b, 'c) Reins.Dug.kind) Hashtbl.t;
edges : (Id.t, ('a, 'b, 'c) Reins.Dug.edge) Hashtbl.t;
}
val create : unit -> ('a, 'b, 'c) Reins.Dug.t
val clear : ('a, 'b, 'c) Reins.Dug.t -> unit
val size : ('a, 'b, 'c) Reins.Dug.t -> Id.t
val fresh_id : ('a, 'b, 'c) Reins.Dug.t -> Id.t
val is_mutator : ('a, 'b, 'c) Reins.Dug.kind -> bool
val is_generator : ('a, 'b, 'c) Reins.Dug.kind -> bool
val is_observer : ('a, 'b, 'c) Reins.Dug.kind -> bool
end
module DugADT :
sig
module type S =
sig
type ('a, 'b) generator
type ('a, 'b) mutator
type ('a, 'b) observer
type ('a, 'b) op
val op_to_string : ('a, 'b) Reins.DugADT.S.op -> string
val coerce_gen :
('a, 'b) Reins.DugADT.S.generator -> ('a, 'b) Reins.DugADT.S.op
val coerce_mut :
('a, 'b) Reins.DugADT.S.mutator -> ('a, 'b) Reins.DugADT.S.op
val coerce_obs :
('a, 'b) Reins.DugADT.S.observer -> ('a, 'b) Reins.DugADT.S.op
val classify :
('a, 'b) Reins.DugADT.S.op ->
(('a, 'b) Reins.DugADT.S.generator,
('a, 'b) Reins.DugADT.S.mutator,
('a, 'b) Reins.DugADT.S.observer)
Reins.Dug.kind
val strip :
('a, 'b) Reins.DugADT.S.op -> (unit, unit) Reins.DugADT.S.op
val op_dependencies :
('a, Dug.Id.t) Reins.DugADT.S.op -> Dug.Id.t list
val create_op :
(unit, unit) Reins.DugADT.S.op ->
Dug.Id.t ->
(unit -> 'a) ->
(int -> Dug.Id.t) -> ('a, Dug.Id.t) Reins.DugADT.S.op
end
end
module DugExtractor :
sig
type 'a wrap = private { data : 'a; id : Dug.Id.t; }
val mutate :
('a, 'b, 'c) Reins.Dug.t ->
(Dug.Id.t -> 'b) ->
('d -> 'd) ->
'd Reins.DugExtractor.wrap -> 'd Reins.DugExtractor.wrap
val mutate2 :
('a, 'b, 'c) Reins.Dug.t ->
(Dug.Id.t -> 'b) ->
('d -> 'd -> 'd) ->
'd Reins.DugExtractor.wrap ->
'd Reins.DugExtractor.wrap -> 'd Reins.DugExtractor.wrap
val observe :
('a, 'b, 'c) Reins.Dug.t ->
'c -> ('d -> 'e) -> 'd Reins.DugExtractor.wrap -> 'e
val observe2 :
('a, 'b, 'c) Reins.Dug.t ->
'c ->
('d -> 'd -> 'e) ->
'd Reins.DugExtractor.wrap -> 'd Reins.DugExtractor.wrap -> 'e
val generate :
('a, 'b, 'c) Reins.Dug.t ->
(Dug.Id.t -> 'a) -> 'd -> 'd Reins.DugExtractor.wrap
end
module DugProfile :
sig
module Make :
functor (DS : DugADT.S) ->
sig
type t = private {
gen_cdf : ((unit, unit) DS.generator * float) list;
mut_cdf : ((unit, unit) DS.mutator * float) list;
obs_cdf : ((unit, unit) DS.observer * float) list;
gen_ratio : float;
obs_mut_ratio : float;
mortality : float;
pmf : float;
pof : float;
}
val random_op : ('a * float) list -> 'a
val to_string : Reins.DugProfile.Make.t -> string
val profile :
(('a, 'b) DS.generator, ('a, 'b) DS.mutator,
('a, 'b) DS.observer)
Reins.Dug.t -> Reins.DugProfile.Make.t
end
end
module DugGenerator :
sig
module Make :
functor (DS : DugADT.S) ->
functor (A : Types.Mono.ArbitraryComparable) ->
sig
val generate :
DugProfile.Make(DS).t ->
int ->
((A.t, Dug.Id.t) DS.generator, (A.t, Dug.Id.t) DS.mutator,
(A.t, Dug.Id.t) DS.observer)
Reins.Dug.t
end
end
module Oracle :
sig
module type RestrictedSet =
sig
type t
type elt
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
end
module type ProfiledSet =
sig
type t
type elt
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
type ('a, 'b) generator
type ('a, 'b) mutator
type ('a, 'b) observer
type ('a, 'b) op
val op_to_string : ('a, 'b) op -> string
val coerce_gen : ('a, 'b) generator -> ('a, 'b) op
val coerce_mut : ('a, 'b) mutator -> ('a, 'b) op
val coerce_obs : ('a, 'b) observer -> ('a, 'b) op
val classify :
('a, 'b) op ->
(('a, 'b) generator, ('a, 'b) mutator, ('a, 'b) observer)
Dug.kind
val strip : ('a, 'b) op -> (unit, unit) op
val op_dependencies : ('a, Dug.Id.t) op -> Dug.Id.t list
val create_op :
(unit, unit) op ->
Dug.Id.t ->
(unit -> 'a) -> (int -> Dug.Id.t) -> ('a, Dug.Id.t) op
end
end
module OracleList :
sig
type ('a, 'b) generator
type ('a, 'b) mutator
type ('a, 'b) observer
type ('a, 'b) op
val op_to_string : ('a, 'b) op -> string
val coerce_gen : ('a, 'b) generator -> ('a, 'b) op
val coerce_mut : ('a, 'b) mutator -> ('a, 'b) op
val coerce_obs : ('a, 'b) observer -> ('a, 'b) op
val classify :
('a, 'b) op ->
(('a, 'b) generator, ('a, 'b) mutator, ('a, 'b) observer) Dug.kind
val strip : ('a, 'b) op -> (unit, unit) op
val op_dependencies : ('a, Dug.Id.t) op -> Dug.Id.t list
val create_op :
(unit, unit) op ->
Dug.Id.t -> (unit -> 'a) -> (int -> Dug.Id.t) -> ('a, Dug.Id.t) op
end
module OracleSet :
sig
type ('a, 'b) generator
type ('a, 'b) mutator
type ('a, 'b) observer
type ('a, 'b) op
val op_to_string : ('a, 'b) op -> string
val coerce_gen : ('a, 'b) generator -> ('a, 'b) op
val coerce_mut : ('a, 'b) mutator -> ('a, 'b) op
val coerce_obs : ('a, 'b) observer -> ('a, 'b) op
val classify :
('a, 'b) op ->
(('a, 'b) generator, ('a, 'b) mutator, ('a, 'b) observer) Dug.kind
val strip : ('a, 'b) op -> (unit, unit) op
val op_dependencies : ('a, Dug.Id.t) op -> Dug.Id.t list
val create_op :
(unit, unit) op ->
Dug.Id.t -> (unit -> 'a) -> (int -> Dug.Id.t) -> ('a, Dug.Id.t) op
module Extractor :
functor (A : Types.Mono.ArbitraryComparable) ->
sig
type t
type elt = A.t
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
val get_dug :
unit ->
((elt, Dug.Id.t) generator, (elt, Dug.Id.t) mutator,
(elt, Dug.Id.t) observer)
Reins.Dug.t
val clear_profile : unit -> unit
end
module Benchmark :
functor
(S : sig
type t
type elt
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
end) ->
sig
val benchmark :
((S.elt, Dug.Id.t) generator, (S.elt, Dug.Id.t) mutator,
(S.elt, Dug.Id.t) observer)
Reins.Dug.t -> float
end
end
module AVLSet :
sig
module PolySet : Sets.PolySetSigStd
module MonoSet : Sets.MonoSetSigFnStd
module GenSet : Sets.GenSetSigFnStd
module AVL_PolySet :
functor (HeightDiff : sig val v : int end) -> Sets.PolySetSigStd
module PolySet1 : Sets.PolySetSigStd
module PolySet2 : Sets.PolySetSigStd
module PolySet3 : Sets.PolySetSigStd
module AVL_MonoSet :
functor (HeightDiff : sig val v : int end) -> Sets.MonoSetSigFnStd
module MonoSet1 : Sets.MonoSetSigFnStd
module MonoSet2 : Sets.MonoSetSigFnStd
module MonoSet3 : Sets.MonoSetSigFnStd
module AVL_GenSet :
functor (HeightDiff : sig val v : int end) -> Sets.GenSetSigFnStd
module GenSet1 : Sets.GenSetSigFnStd
module GenSet2 : Sets.GenSetSigFnStd
module GenSet3 : Sets.GenSetSigFnStd
end
module PatriciaSet :
sig
module MonoSet :
sig
type t
type elt = int
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
end
module GenSet :
sig
type t
type elt = int
type cursor
type 'a result = 'a
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
end
end
module RBSet :
sig
module PolySet : Sets.PolySetSigStd
module MonoSet : Sets.MonoSetSigFnStd
module GenSet : Sets.GenSetSigFnStd
end
module SplaySet :
sig
module rec PolySet :
sig
type 'a t
type 'a cursor
type ('a, 'b) result = 'a * 'b PolySet.t
type 'a elt_ = 'a
type 'a set = 'a t
type ('a, 'b) result_ = ('a, 'b) result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = 'a cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : ('a -> string) -> 'a set -> string
end
module rec MonoSet :
functor (C : Types.Mono.Comparable) ->
sig
type t
type elt = C.t
type cursor
type 'a result = 'a * MonoSet(C).t
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
end
module rec GenSet :
functor (C : Types.Mono.ArbitraryComparable) ->
sig
type t
type elt = C.t
type cursor
type 'a result = 'a * GenSet(C).t
type 'a elt_ = elt
type 'a set = t
type ('a, 'b) result_ = 'a result
val empty : 'a set
val is_empty : 'a set -> bool
val mem : 'a elt_ -> 'a set -> (bool, 'a) result_
val add : 'a elt_ -> 'a set -> 'a set
val singleton : 'a elt_ -> 'a set
val remove : 'a elt_ -> 'a set -> 'a set
val min_elt : 'a set -> ('a elt_, 'a) result_
val max_elt : 'a set -> ('a elt_, 'a) result_
val choose : 'a set -> ('a elt_, 'a) result_
val cardinal : 'a set -> int
val compare : 'a set -> 'a set -> int
val equal : 'a set -> 'a set -> bool
val iter : ('a elt_ -> unit) -> 'a set -> unit
val fold : ('a -> 'b elt_ -> 'a) -> 'a -> 'b set -> 'a
val union : 'a set -> 'a set -> 'a set
val inter : 'a set -> 'a set -> 'a set
val diff : 'a set -> 'a set -> 'a set
val gen1 :
(?size:int -> Random.State.t -> 'a elt_) ->
?size:int -> Random.State.t -> 'a set
val well_formed : 'a set -> bool
val of_result : ('a, 'b) result_ -> 'a
type 'a cursor_ = cursor
val to_cursor : 'a set -> 'a cursor_
val from_cursor : 'a cursor_ -> 'a set
val at_top : 'a cursor_ -> bool
val at_left : 'a cursor_ -> bool
val at_right : 'a cursor_ -> bool
val move_up : 'a cursor_ -> 'a cursor_
val move_down_left : 'a cursor_ -> 'a cursor_
val move_down_right : 'a cursor_ -> 'a cursor_
val went_left : 'a cursor_ -> bool
val went_right : 'a cursor_ -> bool
val has_value : 'a cursor_ -> bool
val get_value : 'a cursor_ -> 'a elt_
val to_string : 'a set -> string
val gen : ?size:int -> Random.State.t -> t
end
end
module Version : sig val version : string end
end