Reference

module General : sig

Some doc for General

module Pervasives : sig

Some doc for General.Pervasives

This module overrides all elements from the standard pervasives with unusable but guiding values like:

val raise: [ `Please_use_General__Exception__raise ]

The types of these values point at what replaces them in General. (In that case, General.Exception.raise).

It then brings back a small set of ubiquitous values:

Boolean operators

val not: bool -> bool

Negation. Alias of General.Bool.O.not.

val (&&): bool -> bool -> bool

Conjunction. Lazy. Alias of General.Bool.O.(&&)

val (||): bool -> bool -> bool

Disjunction. Lazy. Alias of General.Bool.O.(||)

Integer operators

val (~-): int -> int

val (~+): int -> int

val (+): int -> int -> int

val (-): int -> int -> int

val (*): int -> int -> int

val (/): int -> int -> int

val (mod): int -> int -> int

Floating point operators

val (~-.): float -> float

val (~+.): float -> float

val (+.): float -> float -> float

val (-.): float -> float -> float

val (*.): float -> float -> float

val (/.): float -> float -> float

val (**): float -> float -> float

Function composition and application

val (@@): ('a -> 'b) -> 'a -> 'b

val (|>): 'a -> ('a -> 'b) -> 'b

val (%): ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b

References

val ref: 'a -> 'a OCamlStandard.Pervasives.ref

val (:=): 'a OCamlStandard.Pervasives.ref -> 'a -> unit

val (!): 'a OCamlStandard.Pervasives.ref -> 'a

Polymorphic comparison

val (=): 'a -> 'a -> bool

val (<>): 'a -> 'a -> bool

val (<): 'a -> 'a -> bool

val (<=): 'a -> 'a -> bool

val (>=): 'a -> 'a -> bool

val (>): 'a -> 'a -> bool

Ubiquitous functions

val ignore: 'a -> unit

val identity: 'a -> 'a

Miscelaneous operators

val (@): 'a list -> 'a list -> 'a list

val (^): string -> string -> string

end

module Shorten : sig

type t = GoOn | ShortCircuit

Constructor GoOn:  Used to indicate iteration should proceed to next item Constructor ShortCircuit:  Used to indicate iteration should stop after this item

Return type for functions used in short-circuit iterations over collections. (i.e: General.Traits.Foldable.Short.S0.fold_short)

end

module Compare : sig

type t = LT | EQ | GT

module Poly : sig

val compare: 'a -> 'a -> t

val less_than: 'a -> 'a -> bool

val less_or_equal: 'a -> 'a -> bool

val greater_than: 'a -> 'a -> bool

val greater_or_equal: 'a -> 'a -> bool

val between: 'a -> low:'a -> high:'a -> bool

val between_or_equal: 'a -> low:'a -> high:'a -> bool

val min: 'a -> 'a -> 'a

val max: 'a -> 'a -> 'a

val min_max: 'a -> 'a -> 'a * 'a

module O : sig

val (<): 'a -> 'a -> bool

val (<=): 'a -> 'a -> bool

val (>): 'a -> 'a -> bool

val (>=): 'a -> 'a -> bool

end

end

end

module Equate : sig

module Poly : sig

val equal: 'a -> 'a -> bool

Polymorphic structural equality

val different: 'a -> 'a -> bool

Polymorphic inequality

module O : sig

val (=): 'a -> 'a -> bool

val (<>): 'a -> 'a -> bool

end

end

module Phys : sig

val equal: 'a -> 'a -> bool

Physical identity (address equality)

val different: 'a -> 'a -> bool

Physical inequality

end

end

module Traits : sig

Traits are isolated capabilities associated with a type.

module Representable : sig

A representation is a string representing a value for a software developer audience. When possible, it should a valid OCaml expression for the value.

module type S0 = sig

type t

val repr: t -> string

end

module type S1 = sig

type 'a t

val repr: 'a t -> repr_a:('a -> string) -> string

end

module type S2 = sig

type ('a, 'b) t

val repr: ('a, 'b) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> string

end

module type S3 = sig

type ('a, 'b, 'c) t

val repr: ('a, 'b, 'c) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> string

end

module type S4 = sig

type ('a, 'b, 'c, 'd) t

val repr: ('a, 'b, 'c, 'd) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> string

end

module type S5 = sig

type ('a, 'b, 'c, 'd, 'e) t

val repr: ('a, 'b, 'c, 'd, 'e) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> repr_e:('e -> string) -> string

end

end

module Displayable : sig

module type S0 = sig

type t

val to_string: t -> string

end

end

module Parsable : sig

module type S0 = sig

type t

val try_of_string: string -> t option

val of_string: string -> t

end

end

module Equatable : sig

module Basic : sig

module type S0 = sig

type t

val equal: t -> t -> bool

end

module type S1 = sig

type 'a t

val equal: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

end

module type S2 = sig

type ('a, 'b) t

val equal: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

end

module type S3 = sig

type ('a, 'b, 'c) t

val equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

end

module type S4 = sig

type ('a, 'b, 'c, 'd) t

val equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

end

module type S5 = sig

type ('a, 'b, 'c, 'd, 'e) t

val equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

end

end

module Operators : sig

module type S0 = sig

type t

val (=): t -> t -> bool

val (<>): t -> t -> bool

end

end

module type S0 = sig

include Basic.S0 = sig

type t

val equal: t -> t -> bool

end

val different: t -> t -> bool

module O : Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

end

end

module type S1 = sig

include Basic.S1 = sig

type 'a t

val equal: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

end

val different: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

end

module type S2 = sig

include Basic.S2 = sig

type ('a, 'b) t

val equal: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

end

val different: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

end

module type S3 = sig

include Basic.S3 = sig

type ('a, 'b, 'c) t

val equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

end

val different: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

end

module type S4 = sig

include Basic.S4 = sig

type ('a, 'b, 'c, 'd) t

val equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

end

val different: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

end

module type S5 = sig

include Basic.S5 = sig

type ('a, 'b, 'c, 'd, 'e) t

val equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

end

val different: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

end

end

module Comparable : sig

module Basic : sig

module type S0 = sig

type t

val compare: t -> t -> Compare.t

end

module type S1 = sig

type 'a t

val compare: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> Compare.t

end

module type S2 = sig

type ('a, 'b) t

val compare: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> Compare.t

end

module type S3 = sig

type ('a, 'b, 'c) t

val compare: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> Compare.t

end

module type S4 = sig

type ('a, 'b, 'c, 'd) t

val compare: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> Compare.t

end

module type S5 = sig

type ('a, 'b, 'c, 'd, 'e) t

val compare: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> Compare.t

end

end

module Operators : sig

module type S0 = sig

type t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

end

module type S0 = sig

include Basic.S0 = sig

type t

val compare: t -> t -> Compare.t

end

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

module O : Operators.S0 with type t := t = sig

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

end

module type S1 = sig

include Basic.S1 = sig

type 'a t

val compare: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> Compare.t

end

val less_than: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val less_or_equal: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val greater_than: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val greater_or_equal: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val between: 'a t -> low:'a t -> high:'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val between_or_equal: 'a t -> low:'a t -> high:'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val min: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t

val max: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t

val min_max: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t * 'a t

end

module type S2 = sig

include Basic.S2 = sig

type ('a, 'b) t

val compare: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> Compare.t

end

val less_than: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val less_or_equal: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val greater_than: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val greater_or_equal: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val between: ('a, 'b) t -> low:('a, 'b) t -> high:('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val between_or_equal: ('a, 'b) t -> low:('a, 'b) t -> high:('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val min: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t

val max: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t

val min_max: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t * ('a, 'b) t

end

module type S3 = sig

include Basic.S3 = sig

type ('a, 'b, 'c) t

val compare: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> Compare.t

end

val less_than: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val between: ('a, 'b, 'c) t -> low:('a, 'b, 'c) t -> high:('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c) t -> low:('a, 'b, 'c) t -> high:('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val min: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t

val max: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t

val min_max: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t * ('a, 'b, 'c) t

end

module type S4 = sig

include Basic.S4 = sig

type ('a, 'b, 'c, 'd) t

val compare: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> Compare.t

end

val less_than: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val between: ('a, 'b, 'c, 'd) t -> low:('a, 'b, 'c, 'd) t -> high:('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c, 'd) t -> low:('a, 'b, 'c, 'd) t -> high:('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val min: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t

val max: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t

val min_max: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t * ('a, 'b, 'c, 'd) t

end

module type S5 = sig

include Basic.S5 = sig

type ('a, 'b, 'c, 'd, 'e) t

val compare: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> Compare.t

end

val less_than: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val between: ('a, 'b, 'c, 'd, 'e) t -> low:('a, 'b, 'c, 'd, 'e) t -> high:('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c, 'd, 'e) t -> low:('a, 'b, 'c, 'd, 'e) t -> high:('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val min: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t

val max: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t

val min_max: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t * ('a, 'b, 'c, 'd, 'e) t

end

end

module Ringoid : sig

module Basic : sig

module type S0 = sig

type t

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

end

end

module Operators : sig

module type S0 = sig

type t

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

end

end

module type S0 = sig

include Basic.S0 = sig

type t

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

end

val square: t -> t

val exponentiate: t -> int -> t

module O : Operators.S0 with type t := t = sig

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

end

end

end

module PredSucc : sig

module type S0 = sig

type t

val succ: t -> t

val pred: t -> t

end

end

module FilterMapable : sig

module type S0 = sig

type elt

type t

val map: t -> f:(elt -> elt) -> t

val map_i: t -> f:(i:int -> elt -> elt) -> t

val map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * elt) -> t

val filter: t -> f:(elt -> bool) -> t

val filter_i: t -> f:(i:int -> elt -> bool) -> t

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> t

val filter_map: t -> f:(elt -> elt option) -> t

val filter_map_i: t -> f:(i:int -> elt -> elt option) -> t

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * elt option) -> t

val flat_map: t -> f:(elt -> t) -> t

val flat_map_i: t -> f:(i:int -> elt -> t) -> t

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * t) -> t

end

module type S1 = sig

type 'a t

val map: 'a t -> f:('a -> 'b) -> 'b t

val map_i: 'a t -> f:(i:int -> 'a -> 'b) -> 'b t

val map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b) -> 'b t

val filter: 'a t -> f:('a -> bool) -> 'a t

val filter_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a t

val filter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a t

val filter_map: 'a t -> f:('a -> 'b option) -> 'b t

val filter_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b t

val filter_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b t

val flat_map: 'a t -> f:('a -> 'b t) -> 'b t

val flat_map_i: 'a t -> f:(i:int -> 'a -> 'b t) -> 'b t

val flat_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b t) -> 'b t

end

module ToContainer : functor

(C : sig

type 'a t

end)

-> sig

module type S0 = sig

type elt

type t

val map: t -> f:(elt -> 'b) -> 'b C.t

val map_i: t -> f:(i:int -> elt -> 'b) -> 'b C.t

val map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b) -> 'b C.t

val filter: t -> f:(elt -> bool) -> elt C.t

val filter_i: t -> f:(i:int -> elt -> bool) -> elt C.t

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> elt C.t

val filter_map: t -> f:(elt -> 'b option) -> 'b C.t

val filter_map_i: t -> f:(i:int -> elt -> 'b option) -> 'b C.t

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b option) -> 'b C.t

val flat_map: t -> f:(elt -> 'b C.t) -> 'b C.t

val flat_map_i: t -> f:(i:int -> elt -> 'b C.t) -> 'b C.t

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b C.t) -> 'b C.t

end

module type S1 = sig

type 'a t

val map: 'a t -> f:('a -> 'b) -> 'b C.t

val map_i: 'a t -> f:(i:int -> 'a -> 'b) -> 'b C.t

val map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b) -> 'b C.t

val filter: 'a t -> f:('a -> bool) -> 'a C.t

val filter_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a C.t

val filter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a C.t

val filter_map: 'a t -> f:('a -> 'b option) -> 'b C.t

val filter_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b C.t

val filter_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b C.t

val flat_map: 'a t -> f:('a -> 'b C.t) -> 'b C.t

val flat_map_i: 'a t -> f:(i:int -> 'a -> 'b C.t) -> 'b C.t

val flat_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b C.t) -> 'b C.t

end

end

module ToList : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val map: t -> f:(elt -> 'b) -> 'b list

val map_i: t -> f:(i:int -> elt -> 'b) -> 'b list

val map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b) -> 'b list

val filter: t -> f:(elt -> bool) -> elt list

val filter_i: t -> f:(i:int -> elt -> bool) -> elt list

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> elt list

val filter_map: t -> f:(elt -> 'b option) -> 'b list

val filter_map_i: t -> f:(i:int -> elt -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b option) -> 'b list

val flat_map: t -> f:(elt -> 'b list) -> 'b list

val flat_map_i: t -> f:(i:int -> elt -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b list) -> 'b list

end

module type S1 = sig

type 'a t

val map: 'a t -> f:('a -> 'b) -> 'b list

val map_i: 'a t -> f:(i:int -> 'a -> 'b) -> 'b list

val map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b) -> 'b list

val filter: 'a t -> f:('a -> bool) -> 'a list

val filter_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a list

val filter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a list

val filter_map: 'a t -> f:('a -> 'b option) -> 'b list

val filter_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b list

val flat_map: 'a t -> f:('a -> 'b list) -> 'b list

val flat_map_i: 'a t -> f:(i:int -> 'a -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b list) -> 'b list

end

end

module ToArray : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val map: t -> f:(elt -> 'b) -> 'b array

val map_i: t -> f:(i:int -> elt -> 'b) -> 'b array

val map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b) -> 'b array

val filter: t -> f:(elt -> bool) -> elt array

val filter_i: t -> f:(i:int -> elt -> bool) -> elt array

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> elt array

val filter_map: t -> f:(elt -> 'b option) -> 'b array

val filter_map_i: t -> f:(i:int -> elt -> 'b option) -> 'b array

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b option) -> 'b array

val flat_map: t -> f:(elt -> 'b array) -> 'b array

val flat_map_i: t -> f:(i:int -> elt -> 'b array) -> 'b array

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b array) -> 'b array

end

module type S1 = sig

type 'a t

val map: 'a t -> f:('a -> 'b) -> 'b array

val map_i: 'a t -> f:(i:int -> 'a -> 'b) -> 'b array

val map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b) -> 'b array

val filter: 'a t -> f:('a -> bool) -> 'a array

val filter_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a array

val filter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a array

val filter_map: 'a t -> f:('a -> 'b option) -> 'b array

val filter_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b array

val filter_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b array

val flat_map: 'a t -> f:('a -> 'b array) -> 'b array

val flat_map_i: 'a t -> f:(i:int -> 'a -> 'b array) -> 'b array

val flat_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b array) -> 'b array

end

end

end

module Foldable : sig

module Basic : sig

module type S0 = sig

type elt

type t

val fold: init:'b -> t -> f:('b -> elt -> 'b) -> 'b

val fold_i: init:'b -> t -> f:(i:int -> 'b -> elt -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> elt -> 'acc * 'b) -> 'b

end

module type S1 = sig

type 'a t

val fold: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b

val fold_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b

end

end

module type S0 = sig

include Basic.S0 = sig

type elt

type t

val fold: init:'b -> t -> f:('b -> elt -> 'b) -> 'b

val fold_i: init:'b -> t -> f:(i:int -> 'b -> elt -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> elt -> 'acc * 'b) -> 'b

end

val reduce: t -> f:(elt -> elt -> elt) -> elt

val reduce_i: t -> f:(i:int -> elt -> elt -> elt) -> elt

val reduce_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * elt) -> elt

val try_reduce: t -> f:(elt -> elt -> elt) -> elt option

val try_reduce_i: t -> f:(i:int -> elt -> elt -> elt) -> elt option

val try_reduce_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * elt) -> elt option

val iter: t -> f:(elt -> unit) -> unit

val iter_i: t -> f:(i:int -> elt -> unit) -> unit

val iter_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc) -> unit

val count: t -> f:(elt -> bool) -> int

val count_i: t -> f:(i:int -> elt -> bool) -> int

val count_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> int

end

module type S1 = sig

include Basic.S1 = sig

type 'a t

val fold: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b

val fold_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b

end

val reduce: 'a t -> f:('a -> 'a -> 'a) -> 'a

val reduce_i: 'a t -> f:(i:int -> 'a -> 'a -> 'a) -> 'a

val reduce_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * 'a) -> 'a

val try_reduce: 'a t -> f:('a -> 'a -> 'a) -> 'a option

val try_reduce_i: 'a t -> f:(i:int -> 'a -> 'a -> 'a) -> 'a option

val try_reduce_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * 'a) -> 'a option

val iter: 'a t -> f:('a -> unit) -> unit

val iter_i: 'a t -> f:(i:int -> 'a -> unit) -> unit

val iter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc) -> unit

val count: 'a t -> f:('a -> bool) -> int

val count_i: 'a t -> f:(i:int -> 'a -> bool) -> int

val count_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> int

end

module Right : sig

module Basic : sig

module type S0 = sig

type elt

type t

val fold_right: t -> init:'b -> f:(elt -> 'b -> 'b) -> 'b

val fold_right_i: t -> init:'b -> f:(i:int -> elt -> 'b -> 'b) -> 'b

val fold_right_acc: acc:'acc -> t -> init:'b -> f:(acc:'acc -> elt -> 'b -> 'acc * 'b) -> 'b

end

module type S1 = sig

type 'a t

val fold_right: 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b

val fold_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> 'b) -> 'b

val fold_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * 'b) -> 'b

end

end

module type S0 = sig

include Basic.S0 = sig

type elt

type t

val fold_right: t -> init:'b -> f:(elt -> 'b -> 'b) -> 'b

val fold_right_i: t -> init:'b -> f:(i:int -> elt -> 'b -> 'b) -> 'b

val fold_right_acc: acc:'acc -> t -> init:'b -> f:(acc:'acc -> elt -> 'b -> 'acc * 'b) -> 'b

end

val reduce_right: t -> f:(elt -> elt -> elt) -> elt

val reduce_right_i: t -> f:(i:int -> elt -> elt -> elt) -> elt

val reduce_right_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * elt) -> elt

val try_reduce_right: t -> f:(elt -> elt -> elt) -> elt option

val try_reduce_right_i: t -> f:(i:int -> elt -> elt -> elt) -> elt option

val try_reduce_right_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * elt) -> elt option

val iter_right: t -> f:(elt -> unit) -> unit

val iter_right_i: t -> f:(i:int -> elt -> unit) -> unit

val iter_right_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * unit) -> unit

end

module type S1 = sig

include Basic.S1 = sig

type 'a t

val fold_right: 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b

val fold_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> 'b) -> 'b

val fold_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * 'b) -> 'b

end

val reduce_right: 'a t -> f:('a -> 'a -> 'a) -> 'a

val reduce_right_i: 'a t -> f:(i:int -> 'a -> 'a -> 'a) -> 'a

val reduce_right_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * 'a) -> 'a

val try_reduce_right: 'a t -> f:('a -> 'a -> 'a) -> 'a option

val try_reduce_right_i: 'a t -> f:(i:int -> 'a -> 'a -> 'a) -> 'a option

val try_reduce_right_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * 'a) -> 'a option

val iter_right: 'a t -> f:('a -> unit) -> unit

val iter_right_i: 'a t -> f:(i:int -> 'a -> unit) -> unit

val iter_right_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * unit) -> unit

end

end

module Short : sig

module Basic : sig

module type S0 = sig

type elt

type t

val fold_short: init:'b -> t -> f:('b -> elt -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> t -> f:(i:int -> 'b -> elt -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> elt -> 'acc * Shorten.t * 'b) -> 'b

end

module type S1 = sig

type 'a t

val fold_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b

end

end

module type S0 = sig

include Basic.S0 = sig

type elt

type t

val fold_short: init:'b -> t -> f:('b -> elt -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> t -> f:(i:int -> 'b -> elt -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> elt -> 'acc * Shorten.t * 'b) -> 'b

end

val reduce_short: t -> f:(elt -> elt -> Shorten.t * elt) -> elt

val reduce_short_i: t -> f:(i:int -> elt -> elt -> Shorten.t * elt) -> elt

val reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * Shorten.t * elt) -> elt

val try_reduce_short: t -> f:(elt -> elt -> Shorten.t * elt) -> elt option

val try_reduce_short_i: t -> f:(i:int -> elt -> elt -> Shorten.t * elt) -> elt option

val try_reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * Shorten.t * elt) -> elt option

val iter_short: t -> f:(elt -> Shorten.t) -> unit

val iter_short_i: t -> f:(i:int -> elt -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * Shorten.t) -> unit

val for_all: t -> f:(elt -> bool) -> bool

val for_all_i: t -> f:(i:int -> elt -> bool) -> bool

val for_all_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> bool

val there_exists: t -> f:(elt -> bool) -> bool

val there_exists_i: t -> f:(i:int -> elt -> bool) -> bool

val there_exists_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> bool

val find: t -> f:(elt -> bool) -> elt

val find_i: t -> f:(i:int -> elt -> bool) -> elt

val find_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> elt

val try_find: t -> f:(elt -> bool) -> elt option

val try_find_i: t -> f:(i:int -> elt -> bool) -> elt option

val try_find_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * bool) -> elt option

val find_map: t -> f:(elt -> 'b option) -> 'b

val find_map_i: t -> f:(i:int -> elt -> 'b option) -> 'b

val find_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b option) -> 'b

val try_find_map: t -> f:(elt -> 'b option) -> 'b option

val try_find_map_i: t -> f:(i:int -> elt -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * 'b option) -> 'b option

end

module type S1 = sig

include Basic.S1 = sig

type 'a t

val fold_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b

end

val reduce_short: 'a t -> f:('a -> 'a -> Shorten.t * 'a) -> 'a

val reduce_short_i: 'a t -> f:(i:int -> 'a -> 'a -> Shorten.t * 'a) -> 'a

val reduce_short_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * Shorten.t * 'a) -> 'a

val try_reduce_short: 'a t -> f:('a -> 'a -> Shorten.t * 'a) -> 'a option

val try_reduce_short_i: 'a t -> f:(i:int -> 'a -> 'a -> Shorten.t * 'a) -> 'a option

val try_reduce_short_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * Shorten.t * 'a) -> 'a option

val iter_short: 'a t -> f:('a -> Shorten.t) -> unit

val iter_short_i: 'a t -> f:(i:int -> 'a -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * Shorten.t) -> unit

val for_all: 'a t -> f:('a -> bool) -> bool

val for_all_i: 'a t -> f:(i:int -> 'a -> bool) -> bool

val for_all_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> bool

val there_exists: 'a t -> f:('a -> bool) -> bool

val there_exists_i: 'a t -> f:(i:int -> 'a -> bool) -> bool

val there_exists_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> bool

val find: 'a t -> f:('a -> bool) -> 'a

val find_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a

val find_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a

val try_find: 'a t -> f:('a -> bool) -> 'a option

val try_find_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a option

val try_find_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a option

val find_map: 'a t -> f:('a -> 'b option) -> 'b

val find_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b

val find_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b

val try_find_map: 'a t -> f:('a -> 'b option) -> 'b option

val try_find_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b option

end

module Right : sig

module Basic : sig

module type S0 = sig

type elt

type t

val fold_short_right: t -> init:'b -> f:(elt -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_i: t -> init:'b -> f:(i:int -> elt -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_acc: acc:'acc -> t -> init:'b -> f:(acc:'acc -> elt -> 'b -> 'acc * Shorten.t * 'b) -> 'b

end

module type S1 = sig

type 'a t

val fold_short_right: 'a t -> init:'b -> f:('a -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * Shorten.t * 'b) -> 'b

end

end

module type S0 = sig

include Basic.S0 = sig

type elt

type t

val fold_short_right: t -> init:'b -> f:(elt -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_i: t -> init:'b -> f:(i:int -> elt -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_acc: acc:'acc -> t -> init:'b -> f:(acc:'acc -> elt -> 'b -> 'acc * Shorten.t * 'b) -> 'b

end

val reduce_short_right: t -> f:(elt -> elt -> Shorten.t * elt) -> elt

val reduce_short_right_i: t -> f:(i:int -> elt -> elt -> Shorten.t * elt) -> elt

val reduce_short_right_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * Shorten.t * elt) -> elt

val try_reduce_short_right: t -> f:(elt -> elt -> Shorten.t * elt) -> elt option

val try_reduce_short_right_i: t -> f:(i:int -> elt -> elt -> Shorten.t * elt) -> elt option

val try_reduce_short_right_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> elt -> 'acc * Shorten.t * elt) -> elt option

val iter_short_right: t -> f:(elt -> Shorten.t) -> unit

val iter_short_right_i: t -> f:(i:int -> elt -> Shorten.t) -> unit

val iter_short_right_acc: acc:'acc -> t -> f:(acc:'acc -> elt -> 'acc * Shorten.t) -> unit

end

module type S1 = sig

include Basic.S1 = sig

type 'a t

val fold_short_right: 'a t -> init:'b -> f:('a -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> Shorten.t * 'b) -> 'b

val fold_short_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * Shorten.t * 'b) -> 'b

end

val reduce_short_right: 'a t -> f:('a -> 'a -> Shorten.t * 'a) -> 'a

val reduce_short_right_i: 'a t -> f:(i:int -> 'a -> 'a -> Shorten.t * 'a) -> 'a

val reduce_short_right_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * Shorten.t * 'a) -> 'a

val try_reduce_short_right: 'a t -> f:('a -> 'a -> Shorten.t * 'a) -> 'a option

val try_reduce_short_right_i: 'a t -> f:(i:int -> 'a -> 'a -> Shorten.t * 'a) -> 'a option

val try_reduce_short_right_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * Shorten.t * 'a) -> 'a option

val iter_short_right: 'a t -> f:('a -> Shorten.t) -> unit

val iter_short_right_i: 'a t -> f:(i:int -> 'a -> Shorten.t) -> unit

val iter_short_right_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * Shorten.t) -> unit

end

end

end

end

module Scanable : sig

module type S0 = sig

type elt

type t

val scan: init:elt -> t -> f:(elt -> elt -> elt) -> t

val scan_i: init:elt -> t -> f:(i:int -> elt -> elt -> elt) -> t

val scan_acc: acc:'acc -> init:elt -> t -> f:(acc:'acc -> elt -> elt -> 'acc * elt) -> t

end

module type S1 = sig

type 'a t

val scan: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b t

val scan_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b t

val scan_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b t

end

module ToContainer : functor

(C : sig

type 'a t

end)

-> sig

module type S0 = sig

type elt

type t

val scan: init:'a -> t -> f:('a -> elt -> 'a) -> 'a C.t

val scan_i: init:'a -> t -> f:(i:int -> 'a -> elt -> 'a) -> 'a C.t

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> elt -> 'acc * 'a) -> 'a C.t

end

module type S1 = sig

type 'a t

val scan: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b C.t

val scan_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b C.t

val scan_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b C.t

end

end

module ToList : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan: init:'a -> t -> f:('a -> elt -> 'a) -> 'a list

val scan_i: init:'a -> t -> f:(i:int -> 'a -> elt -> 'a) -> 'a list

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> elt -> 'acc * 'a) -> 'a list

end

module type S1 = sig

type 'a t

val scan: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b list

val scan_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b list

val scan_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b list

end

end

module ToArray : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan: init:'a -> t -> f:('a -> elt -> 'a) -> 'a array

val scan_i: init:'a -> t -> f:(i:int -> 'a -> elt -> 'a) -> 'a array

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> elt -> 'acc * 'a) -> 'a array

end

module type S1 = sig

type 'a t

val scan: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b array

val scan_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b array

val scan_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b array

end

end

module Right : sig

module type S0 = sig

type elt

type t

val scan_right: t -> init:elt -> f:(elt -> elt -> elt) -> t

val scan_right_i: t -> init:elt -> f:(i:int -> elt -> elt -> elt) -> t

val scan_right_acc: acc:'acc -> t -> init:elt -> f:(acc:'acc -> elt -> elt -> 'acc * elt) -> t

end

module type S1 = sig

type 'a t

val scan_right: 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b t

val scan_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> 'b) -> 'b t

val scan_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * 'b) -> 'b t

end

module ToContainer : functor

(C : sig

type 'a t

end)

-> sig

module type S0 = sig

type elt

type t

val scan_right: t -> init:'a -> f:(elt -> 'a -> 'a) -> 'a C.t

val scan_right_i: t -> init:'a -> f:(i:int -> elt -> 'a -> 'a) -> 'a C.t

val scan_right_acc: acc:'acc -> t -> init:'a -> f:(acc:'acc -> elt -> 'a -> 'acc * 'a) -> 'a C.t

end

module type S1 = sig

type 'a t

val scan_right: 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b C.t

val scan_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> 'b) -> 'b C.t

val scan_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * 'b) -> 'b C.t

end

end

module ToList : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan_right: t -> init:'a -> f:(elt -> 'a -> 'a) -> 'a list

val scan_right_i: t -> init:'a -> f:(i:int -> elt -> 'a -> 'a) -> 'a list

val scan_right_acc: acc:'acc -> t -> init:'a -> f:(acc:'acc -> elt -> 'a -> 'acc * 'a) -> 'a list

end

module type S1 = sig

type 'a t

val scan_right: 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b list

val scan_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> 'b) -> 'b list

val scan_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * 'b) -> 'b list

end

end

module ToArray : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan_right: t -> init:'a -> f:(elt -> 'a -> 'a) -> 'a array

val scan_right_i: t -> init:'a -> f:(i:int -> elt -> 'a -> 'a) -> 'a array

val scan_right_acc: acc:'acc -> t -> init:'a -> f:(acc:'acc -> elt -> 'a -> 'acc * 'a) -> 'a array

end

module type S1 = sig

type 'a t

val scan_right: 'a t -> init:'b -> f:('a -> 'b -> 'b) -> 'b array

val scan_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> 'b) -> 'b array

val scan_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * 'b) -> 'b array

end

end

end

module Short : sig

module type S0 = sig

type elt

type t

val scan_short: init:elt -> t -> f:(elt -> elt -> Shorten.t * elt) -> t

val scan_short_i: init:elt -> t -> f:(i:int -> elt -> elt -> Shorten.t * elt) -> t

val scan_short_acc: acc:'acc -> init:elt -> t -> f:(acc:'acc -> elt -> elt -> 'acc * Shorten.t * elt) -> t

end

module type S1 = sig

type 'a t

val scan_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b t

val scan_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b t

val scan_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b t

end

module ToContainer : functor

(C : sig

type 'a t

end)

-> sig

module type S0 = sig

type elt

type t

val scan_short: init:'a -> t -> f:('a -> elt -> Shorten.t * 'a) -> 'a C.t

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> elt -> Shorten.t * 'a) -> 'a C.t

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> elt -> 'acc * Shorten.t * 'a) -> 'a C.t

end

module type S1 = sig

type 'a t

val scan_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b C.t

val scan_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b C.t

val scan_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b C.t

end

end

module ToList : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan_short: init:'a -> t -> f:('a -> elt -> Shorten.t * 'a) -> 'a list

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> elt -> Shorten.t * 'a) -> 'a list

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> elt -> 'acc * Shorten.t * 'a) -> 'a list

end

module type S1 = sig

type 'a t

val scan_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b list

val scan_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b list

val scan_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b list

end

end

module ToArray : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan_short: init:'a -> t -> f:('a -> elt -> Shorten.t * 'a) -> 'a array

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> elt -> Shorten.t * 'a) -> 'a array

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> elt -> 'acc * Shorten.t * 'a) -> 'a array

end

module type S1 = sig

type 'a t

val scan_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b array

val scan_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b array

val scan_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b array

end

end

module Right : sig

module type S0 = sig

type elt

type t

val scan_short_right: t -> init:elt -> f:(elt -> elt -> Shorten.t * elt) -> t

val scan_short_right_i: t -> init:elt -> f:(i:int -> elt -> elt -> Shorten.t * elt) -> t

val scan_short_right_acc: acc:'acc -> t -> init:elt -> f:(acc:'acc -> elt -> elt -> 'acc * Shorten.t * elt) -> t

end

module type S1 = sig

type 'a t

val scan_short_right: 'a t -> init:'b -> f:('a -> 'b -> Shorten.t * 'b) -> 'b t

val scan_short_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> Shorten.t * 'b) -> 'b t

val scan_short_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * Shorten.t * 'b) -> 'b t

end

module ToContainer : functor

(C : sig

type 'a t

end)

-> sig

module type S0 = sig

type elt

type t

val scan_short_right: t -> init:'a -> f:(elt -> 'a -> Shorten.t * 'a) -> 'a C.t

val scan_short_right_i: t -> init:'a -> f:(i:int -> elt -> 'a -> Shorten.t * 'a) -> 'a C.t

val scan_short_right_acc: acc:'acc -> t -> init:'a -> f:(acc:'acc -> elt -> 'a -> 'acc * Shorten.t * 'a) -> 'a C.t

end

module type S1 = sig

type 'a t

val scan_short_right: 'a t -> init:'b -> f:('a -> 'b -> Shorten.t * 'b) -> 'b C.t

val scan_short_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> Shorten.t * 'b) -> 'b C.t

val scan_short_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * Shorten.t * 'b) -> 'b C.t

end

end

module ToList : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan_short_right: t -> init:'a -> f:(elt -> 'a -> Shorten.t * 'a) -> 'a list

val scan_short_right_i: t -> init:'a -> f:(i:int -> elt -> 'a -> Shorten.t * 'a) -> 'a list

val scan_short_right_acc: acc:'acc -> t -> init:'a -> f:(acc:'acc -> elt -> 'a -> 'acc * Shorten.t * 'a) -> 'a list

end

module type S1 = sig

type 'a t

val scan_short_right: 'a t -> init:'b -> f:('a -> 'b -> Shorten.t * 'b) -> 'b list

val scan_short_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> Shorten.t * 'b) -> 'b list

val scan_short_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * Shorten.t * 'b) -> 'b list

end

end

module ToArray : module type of ToContainer(struct ... end) = sig

module type S0 = sig

type elt

type t

val scan_short_right: t -> init:'a -> f:(elt -> 'a -> Shorten.t * 'a) -> 'a array

val scan_short_right_i: t -> init:'a -> f:(i:int -> elt -> 'a -> Shorten.t * 'a) -> 'a array

val scan_short_right_acc: acc:'acc -> t -> init:'a -> f:(acc:'acc -> elt -> 'a -> 'acc * Shorten.t * 'a) -> 'a array

end

module type S1 = sig

type 'a t

val scan_short_right: 'a t -> init:'b -> f:('a -> 'b -> Shorten.t * 'b) -> 'b array

val scan_short_right_i: 'a t -> init:'b -> f:(i:int -> 'a -> 'b -> Shorten.t * 'b) -> 'b array

val scan_short_right_acc: acc:'acc -> 'a t -> init:'b -> f:(acc:'acc -> 'a -> 'b -> 'acc * Shorten.t * 'b) -> 'b array

end

end

end

end

end

end

module Concepts : sig

module Identifiable : sig

module Operators = Traits.Equatable.Operators

module type S0 = sig

type t

include Traits.Equatable.S0 with type t := t = sig

val equal: t -> t -> bool

val different: t -> t -> bool

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

end

end

include Traits.Representable.S0 with type t := t = sig

val repr: t -> string

end

end

module type S1 = sig

type 'a t

include Traits.Equatable.S1 with type 'a t := 'a t = sig

val equal: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

val different: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

end

include Traits.Representable.S1 with type 'a t := 'a t = sig

val repr: 'a t -> repr_a:('a -> string) -> string

end

end

module type S2 = sig

type ('a, 'b) t

include Traits.Equatable.S2 with type ('a, 'b) t := ('a, 'b) t = sig

val equal: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

val different: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

end

include Traits.Representable.S2 with type ('a, 'b) t := ('a, 'b) t = sig

val repr: ('a, 'b) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> string

end

end

module type S3 = sig

type ('a, 'b, 'c) t

include Traits.Equatable.S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) t = sig

val equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

val different: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

end

include Traits.Representable.S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) t = sig

val repr: ('a, 'b, 'c) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> string

end

end

module type S4 = sig

type ('a, 'b, 'c, 'd) t

include Traits.Equatable.S4 with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) t = sig

val equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

val different: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

end

include Traits.Representable.S4 with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) t = sig

val repr: ('a, 'b, 'c, 'd) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> string

end

end

module type S5 = sig

type ('a, 'b, 'c, 'd, 'e) t

include Traits.Equatable.S5 with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) t = sig

val equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

val different: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

end

include Traits.Representable.S5 with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) t = sig

val repr: ('a, 'b, 'c, 'd, 'e) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> repr_e:('e -> string) -> string

end

end

end

module Able : sig

module Operators : sig

module type S0 = sig

type t

include Identifiable.Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

end

include Traits.Comparable.Operators.S0 with type t := t = sig

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

end

end

module type S0 = sig

type t

module O : Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

include Identifiable.S0 with type t := t and module O := O = sig

val equal: t -> t -> bool

val different: t -> t -> bool

val repr: t -> string

end

include Traits.Comparable.S0 with type t := t and module O := O = sig

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

end

end

module type S1 = sig

type 'a t

include Identifiable.S1 with type 'a t := 'a t = sig

val equal: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

val different: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

val repr: 'a t -> repr_a:('a -> string) -> string

end

include Traits.Comparable.S1 with type 'a t := 'a t = sig

val compare: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> Compare.t

val less_than: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val less_or_equal: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val greater_than: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val greater_or_equal: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val between: 'a t -> low:'a t -> high:'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val between_or_equal: 'a t -> low:'a t -> high:'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val min: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t

val max: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t

val min_max: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t * 'a t

end

end

module type S2 = sig

type ('a, 'b) t

include Identifiable.S2 with type ('a, 'b) t := ('a, 'b) t = sig

val equal: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

val different: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

val repr: ('a, 'b) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> string

end

include Traits.Comparable.S2 with type ('a, 'b) t := ('a, 'b) t = sig

val compare: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> Compare.t

val less_than: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val less_or_equal: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val greater_than: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val greater_or_equal: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val between: ('a, 'b) t -> low:('a, 'b) t -> high:('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val between_or_equal: ('a, 'b) t -> low:('a, 'b) t -> high:('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val min: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t

val max: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t

val min_max: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t * ('a, 'b) t

end

end

module type S3 = sig

type ('a, 'b, 'c) t

include Identifiable.S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) t = sig

val equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

val different: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

val repr: ('a, 'b, 'c) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> string

end

include Traits.Comparable.S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) t = sig

val compare: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> Compare.t

val less_than: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val between: ('a, 'b, 'c) t -> low:('a, 'b, 'c) t -> high:('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c) t -> low:('a, 'b, 'c) t -> high:('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val min: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t

val max: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t

val min_max: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t * ('a, 'b, 'c) t

end

end

module type S4 = sig

type ('a, 'b, 'c, 'd) t

include Identifiable.S4 with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) t = sig

val equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

val different: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

val repr: ('a, 'b, 'c, 'd) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> string

end

include Traits.Comparable.S4 with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) t = sig

val compare: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> Compare.t

val less_than: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val between: ('a, 'b, 'c, 'd) t -> low:('a, 'b, 'c, 'd) t -> high:('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c, 'd) t -> low:('a, 'b, 'c, 'd) t -> high:('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val min: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t

val max: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t

val min_max: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t * ('a, 'b, 'c, 'd) t

end

end

module type S5 = sig

type ('a, 'b, 'c, 'd, 'e) t

include Identifiable.S5 with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) t = sig

val equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

val different: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

val repr: ('a, 'b, 'c, 'd, 'e) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> repr_e:('e -> string) -> string

end

include Traits.Comparable.S5 with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) t = sig

val compare: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> Compare.t

val less_than: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val between: ('a, 'b, 'c, 'd, 'e) t -> low:('a, 'b, 'c, 'd, 'e) t -> high:('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c, 'd, 'e) t -> low:('a, 'b, 'c, 'd, 'e) t -> high:('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val min: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t

val max: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t

val min_max: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t * ('a, 'b, 'c, 'd, 'e) t

end

end

end

module Number : sig

module Operators : sig

module type S0 = sig

type t

include Traits.Equatable.Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

end

include Traits.Ringoid.Operators.S0 with type t := t = sig

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

end

end

end

module type S0 = sig

type t

module O : Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

end

include Traits.Displayable.S0 with type t := t = sig

val to_string: t -> string

end

include Traits.Equatable.S0 with type t := t and module O := O = sig

val equal: t -> t -> bool

val different: t -> t -> bool

end

include Traits.Parsable.S0 with type t := t = sig

val try_of_string: string -> t option

val of_string: string -> t

end

include Traits.Representable.S0 with type t := t = sig

val repr: t -> string

end

include Traits.Ringoid.S0 with type t := t and module O := O = sig

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

end

val of_int: int -> t

val of_float: float -> t

end

end

module RealNumber : sig

module Operators : sig

module type S0 = sig

type t

include Number.Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

end

include Traits.Comparable.Operators.S0 with type t := t = sig

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

val (mod): t -> t -> t

end

end

module type S0 = sig

type t

module O : Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

include Number.S0 with type t := t and module O := O = sig

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

end

include Traits.Comparable.S0 with type t := t and module O := O = sig

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

end

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

end

end

module Integer : sig

module type S0 = sig

type t

include RealNumber.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

end

include Traits.PredSucc.S0 with type t := t = sig

val succ: t -> t

val pred: t -> t

end

end

end

end

module CallStack : sig

type t = Pervasives.OCamlStandard.Printexc.raw_backtrace

include Traits.Displayable.S0 with type t := t = sig

val to_string: t -> string

end

include Traits.Representable.S0 with type t := t = sig

val repr: t -> string

end

val current: ?max_size:int -> unit -> t

module Location : sig

type t = Pervasives.OCamlStandard.Printexc.location = {filename: string; line_number: int; start_char: int; end_char: int}

include Concepts.Able.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

val equal: t -> t -> bool

val different: t -> t -> bool

val repr: t -> string

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

end

end

module Frame : sig

type t = Pervasives.OCamlStandard.Printexc.backtrace_slot

val is_raise: t -> bool

val location: t -> Location.t option

val format: int -> t -> string option

end

val frames: t -> Frame.t list

end

module Exception : sig

type t = exn

include Concepts.Identifiable.S0 with type t := t = sig

val equal: t -> t -> bool

val different: t -> t -> bool

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

end

val repr: t -> string

end

include Traits.Displayable.S0 with type t := t = sig

val to_string: t -> string

end

val register_printer: (t -> string option) -> unit

val record_backtraces: bool -> unit

val recording_backtraces: unit -> bool

val most_recent_backtrace: unit -> CallStack.t option

exception MatchFailure of (string * int * int)

exception AssertFailure of (string * int * int)

exception InvalidArgument of string

exception Failure of string

exception NotFound

exception OutOfMemory

Raised when the system could not allocate memory

exception StackOverflow

exception SysError of string

exception EndOfFile

exception DivisionByZero

exception SysBlockedIO

exception UndefinedRecursiveModule of (string * int * int)

exception Exit

val raise: t -> 'a

val raise_without_backtrace: t -> 'a

val invalid_argument: ('a, unit, string, string, string, 'b) CamlinternalFormatBasics.format6 -> 'a

val failure: ('a, unit, string, string, string, 'b) CamlinternalFormatBasics.format6 -> 'a

val name: exn -> string

val or_none: 'a lazy_t -> 'a option

end

module Exit : sig

type t = Success | Failure of int

val of_int: int -> t

val exit: t -> 'a

val at_exit: (unit -> unit) -> unit

end

module Function1 : sig

type ('a, 'z) t = 'a -> 'z

val identity: ('a, 'a) t

val apply: ('a, 'z) t -> 'a -> 'z

val rev_apply: 'a -> ('a, 'z) t -> 'z

val compose: ('a, 'b) t -> ('c, 'a) t -> ('c, 'b) t

module O : sig

val (@@): ('a, 'z) t -> 'a -> 'z

val (|>): 'a -> ('a, 'z) t -> 'z

val (%): ('a, 'b) t -> ('c, 'a) t -> ('c, 'b) t

end

end

module Function2 : sig

type ('a, 'b, 'z) t = 'a -> 'b -> 'z

val flip: ('a, 'b, 'z) t -> ('b, 'a, 'z) t

val curry: ('a * 'b, 'z) Function1.t -> ('a, 'b, 'z) t

val uncurry: ('a, 'b, 'z) t -> ('a * 'b, 'z) Function1.t

end

module Function3 : sig

type ('a, 'b, 'c, 'z) t = 'a -> 'b -> 'c -> 'z

val flip: ('a, 'b, 'c, 'z) t -> ('c, 'b, 'a, 'z) t

val curry: ('a * 'b * 'c, 'z) Function1.t -> ('a, 'b, 'c, 'z) t

val uncurry: ('a, 'b, 'c, 'z) t -> ('a * 'b * 'c, 'z) Function1.t

end

module Function4 : sig

type ('a, 'b, 'c, 'd, 'z) t = 'a -> 'b -> 'c -> 'd -> 'z

val flip: ('a, 'b, 'c, 'd, 'z) t -> ('d, 'c, 'b, 'a, 'z) t

val curry: ('a * 'b * 'c * 'd, 'z) Function1.t -> ('a, 'b, 'c, 'd, 'z) t

val uncurry: ('a, 'b, 'c, 'd, 'z) t -> ('a * 'b * 'c * 'd, 'z) Function1.t

end

module Function5 : sig

type ('a, 'b, 'c, 'd, 'e, 'z) t = 'a -> 'b -> 'c -> 'd -> 'e -> 'z

val flip: ('a, 'b, 'c, 'd, 'e, 'z) t -> ('e, 'd, 'c, 'b, 'a, 'z) t

val curry: ('a * 'b * 'c * 'd * 'e, 'z) Function1.t -> ('a, 'b, 'c, 'd, 'e, 'z) t

val uncurry: ('a, 'b, 'c, 'd, 'e, 'z) t -> ('a * 'b * 'c * 'd * 'e, 'z) Function1.t

end

module Unit : sig

type t = unit

val ignore: 'a -> t

end

module Bool : sig

type t = bool

module O : sig

include Concepts.Able.Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

val not: t -> t

val (&&): t -> t -> t

val (||): t -> t -> t

end

include Concepts.Able.S0 with type t := t and module O := O = sig

val equal: t -> t -> bool

val different: t -> t -> bool

val repr: t -> string

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

end

include Traits.Displayable.S0 with type t := t = sig

val to_string: t -> string

end

include Traits.Parsable.S0 with type t := t = sig

val try_of_string: string -> t option

val of_string: string -> t

end

val not: t -> t

val and_: t -> t -> t

val or_: t -> t -> t

val xor: t -> t -> t

end

module Char : sig

type t = char

include Traits.Comparable.S0 with type t := t = sig

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

module O : sig

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

end

val of_int: int -> t

val to_int: t -> int

val to_string: t -> string

val repeat: t -> len:int -> string

end

module Int : sig

type t = int

include Concepts.Integer.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

val succ: t -> t

val pred: t -> t

end

val smallest: t

val greatest: t

module Bitwise : sig

val logical_and: t -> t -> t

val logical_or: t -> t -> t

val logical_xor: t -> t -> t

val logical_not: t -> t

val logical_shift_left: t -> shift:t -> t

val logical_shift_right: t -> shift:t -> t

val arithmetic_shift_right: t -> shift:t -> t

end

end

module Int32 : sig

type t = int32

include Concepts.Integer.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

val succ: t -> t

val pred: t -> t

end

val smallest: t

val greatest: t

end

module Int64 : sig

type t = int64

include Concepts.Integer.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

val succ: t -> t

val pred: t -> t

end

val smallest: t

val greatest: t

end

module NativeInt : sig

type t = nativeint

include Concepts.Integer.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

val succ: t -> t

val pred: t -> t

end

val smallest: t

val greatest: t

end

module BigInt : sig

type t = Pervasives.OCamlStandard.Big_int.big_int

include Concepts.Integer.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

val succ: t -> t

val pred: t -> t

end

end

module Float : sig

type t = float

include Concepts.RealNumber.S0 with type t := t = sig

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (~+): t -> t

val (~-): t -> t

val (+): t -> t -> t

val (-): t -> t -> t

val (*): t -> t -> t

val (/): t -> t -> t

val (**): t -> int -> t

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

val (mod): t -> t -> t

end

val to_string: t -> string

val equal: t -> t -> bool

val different: t -> t -> bool

val try_of_string: string -> t option

val of_string: string -> t

val repr: t -> string

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

val square: t -> t

val exponentiate: t -> int -> t

val of_int: int -> t

val of_float: float -> t

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

val abs: t -> t

val modulo: t -> t -> t

val to_int: t -> int

val to_float: t -> float

end

val epsilon: t

val smallest: t

val greatest: t

val infinity: t

val negative_infinity: t

val not_a_number: t

val pi: float

val e: float

val of_parts: significand:float -> exponent:int -> t

val to_parts: t -> float * int

val to_fractional_and_integral: t -> float * float

val sqrt: float -> float

val exp: float -> float

val log: float -> float

val log10: float -> float

val expm1: float -> float

val log1p: float -> float

val cos: float -> float

val sin: float -> float

val tan: float -> float

val acos: float -> float

val asin: float -> float

val atan: float -> float

val atan2: y:float -> x:float -> float

val hypot: float -> float -> float

val cosh: float -> float

val sinh: float -> float

val tanh: float -> float

val ceil: float -> float

val floor: float -> float

val copy_sign: t -> sign:t -> t

module Class : sig

type t = Normal | SubNormal | Zero | Infinite | NotANumber

include Traits.Representable.S0 with type t := t = sig

val repr: t -> string

end

val of_float: float -> t

end

end

module String : sig

type t = string

val of_char: char -> t

val of_list: char list -> t

val to_list: t -> char list

val size: t -> int

val get: t -> int -> char

val set: bytes -> int -> char -> unit

val of_bytes: bytes -> t

val to_bytes: t -> bytes

module O : sig

include Concepts.Able.Operators.S0 with type t := t = sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

val (<): t -> t -> bool

val (<=): t -> t -> bool

val (>): t -> t -> bool

val (>=): t -> t -> bool

end

val (^): t -> t -> t

end

include Traits.Displayable.S0 with type t := t = sig

val to_string: t -> string

end

include Traits.Parsable.S0 with type t := t = sig

val try_of_string: string -> t option

val of_string: string -> t

end

include Concepts.Able.S0 with type t := t and module O := O = sig

val equal: t -> t -> bool

val different: t -> t -> bool

val repr: t -> string

val compare: t -> t -> Compare.t

val less_than: t -> t -> bool

val less_or_equal: t -> t -> bool

val greater_than: t -> t -> bool

val greater_or_equal: t -> t -> bool

val between: t -> low:t -> high:t -> bool

val between_or_equal: t -> low:t -> high:t -> bool

val min: t -> t -> t

val max: t -> t -> t

val min_max: t -> t -> t * t

end

val concat: t -> t -> t

val substring: t -> pos:int -> len:int -> t

val prefix: t -> len:int -> t

val suffix: t -> len:int -> t

val has_prefix: t -> pre:t -> bool

val try_drop_prefix: t -> pre:t -> t option

val drop_prefix: t -> pre:t -> t

val drop_prefix': t -> len:int -> t

val has_suffix: t -> suf:t -> bool

val try_drop_suffix: t -> suf:t -> t option

val drop_suffix: t -> suf:t -> t

val drop_suffix': t -> len:int -> t

val split: t -> sep:t -> t list

val split': t -> seps:char list -> t list

val fold: init:'a -> t -> f:('a -> char -> 'a) -> 'a

val filter: t -> f:(char -> bool) -> t

end

module Bytes : sig

type t = bytes

val size: t -> int

val of_string: string -> t

val to_string: t -> string

val get: t -> int -> char

val set: t -> int -> char -> unit

val make: len:int -> t

end

module Option : sig

type 'a t = 'a option

include Concepts.Able.S1 with type 'a t := 'a t = sig

val equal: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

val different: 'a t -> 'a t -> equal_a:('a -> 'a -> bool) -> bool

val repr: 'a t -> repr_a:('a -> string) -> string

val compare: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> Compare.t

val less_than: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val less_or_equal: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val greater_than: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val greater_or_equal: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val between: 'a t -> low:'a t -> high:'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val between_or_equal: 'a t -> low:'a t -> high:'a t -> compare_a:('a -> 'a -> Compare.t) -> bool

val min: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t

val max: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t

val min_max: 'a t -> 'a t -> compare_a:('a -> 'a -> Compare.t) -> 'a t * 'a t

end

val none: 'a t

val some: 'a -> 'a t

val some_if: bool -> 'a lazy_t -> 'a t

val some_if': bool -> 'a -> 'a t

val is_some: 'a t -> bool

val is_none: 'a t -> bool

val value_def: 'a t -> def:'a -> 'a

val value: ?exc:exn -> 'a t -> 'a

val or_failure: ('a, unit, string, string, string, 'b t -> 'b) CamlinternalFormatBasics.format6 -> 'a

val map: 'a t -> f:('a -> 'b) -> 'b t

val iter: 'a t -> f:('a -> unit) -> unit

val filter: 'a t -> f:('a -> bool) -> 'a t

val filter_map: 'a t -> f:('a -> 'b option) -> 'b t

val value_map: 'a t -> def:'b -> f:('a -> 'b) -> 'b

module Specialize : functor

(A : sig

type t

end)

-> sig

type t = A.t option

val some_if: bool -> A.t lazy_t -> t

val some_if': bool -> A.t -> t

val is_some: t -> bool

val is_none: t -> bool

val value_def: t -> def:A.t -> A.t

val value: ?exc:exn -> t -> A.t

val or_failure: ('a, unit, string, string, string, t -> A.t) CamlinternalFormatBasics.format6 -> 'a

val map: t -> f:(A.t -> 'a) -> 'a option

val iter: t -> f:(A.t -> unit) -> unit

val filter: t -> f:(A.t -> bool) -> t

val filter_map: t -> f:(A.t -> 'a option) -> 'a option

val value_map: t -> def:'a -> f:(A.t -> 'a) -> 'a

end

end

module Lazy : sig

type 'a t = 'a lazy_t

val is_value: 'a t -> bool

val value: 'a t -> 'a

val map: 'a t -> f:('a -> 'b) -> 'b t

end

module Reference : sig

type 'a t = 'a Pervasives.OCamlStandard.Pervasives.ref = {mutable contents: 'a}

val of_contents: 'a -> 'a t

val contents: 'a t -> 'a

val assign: 'a t -> 'a -> unit

module O : sig

val ref: 'a -> 'a t

val (!): 'a t -> 'a

val (:=): 'a t -> 'a -> unit

end

module SpecializeOperators : functor

(A : sig

type t

end)

-> sig

type t = A.t t

val ref: A.t -> t

val (!): t -> A.t

val (:=): t -> A.t -> unit

end

module Specialize : functor

(A : sig

type t

end)

-> sig

type t = A.t t

val of_contents: A.t -> t

val contents: t -> A.t

val assign: t -> A.t -> unit

module O : module type of SpecializeOperators(A) with type t := t = sig

val ref: A.t -> t

val (!): t -> A.t

val (:=): t -> A.t -> unit

end

end

module SpecializePredSucc : functor

(A : Traits.PredSucc.S0 = sig

type t

val succ: t -> t

val pred: t -> t

end)

-> sig

type t = A.t t

val increment: t -> unit

val decrement: t -> unit

end

module SpecializeRingoidOperators : functor

(A : Traits.Ringoid.Basic.S0 = sig

type t

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

end)

-> sig

type t = A.t t

val (=+): t -> A.t -> unit

val (=-): t -> A.t -> unit

val (=*): t -> A.t -> unit

val (=/): t -> A.t -> unit

end

module SpecializeRingoid : functor

(A : Traits.Ringoid.Basic.S0 = sig

type t

val zero: t

val one: t

val negate: t -> t

val add: t -> t -> t

val substract: t -> t -> t

val multiply: t -> t -> t

val divide: t -> t -> t

end)

-> sig

type t = A.t t

module O : module type of SpecializeRingoidOperators(A) with type t := t = sig

val (=+): t -> A.t -> unit

val (=-): t -> A.t -> unit

val (=*): t -> A.t -> unit

val (=/): t -> A.t -> unit

end

end

end

module Tuple2 : sig

type ('a, 'b) t = 'a * 'b

include Concepts.Able.S2 with type ('a, 'b) t := ('a, 'b) t = sig

val equal: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

val different: ('a, 'b) t -> ('a, 'b) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> bool

val repr: ('a, 'b) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> string

val compare: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> Compare.t

val less_than: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val less_or_equal: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val greater_than: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val greater_or_equal: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val between: ('a, 'b) t -> low:('a, 'b) t -> high:('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val between_or_equal: ('a, 'b) t -> low:('a, 'b) t -> high:('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> bool

val min: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t

val max: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t

val min_max: ('a, 'b) t -> ('a, 'b) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> ('a, 'b) t * ('a, 'b) t

end

val make: 'a -> 'b -> ('a, 'b) t

val get_0: ('a, 'b) t -> 'a

val get_1: ('a, 'b) t -> 'b

val flip: ('a, 'b) t -> ('b, 'a) t

end

module Tuple3 : sig

type ('a, 'b, 'c) t = 'a * 'b * 'c

include Concepts.Able.S3 with type ('a, 'b, 'c) t := ('a, 'b, 'c) t = sig

val equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

val different: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> bool

val repr: ('a, 'b, 'c) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> string

val compare: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> Compare.t

val less_than: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val between: ('a, 'b, 'c) t -> low:('a, 'b, 'c) t -> high:('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c) t -> low:('a, 'b, 'c) t -> high:('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> bool

val min: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t

val max: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t

val min_max: ('a, 'b, 'c) t -> ('a, 'b, 'c) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> ('a, 'b, 'c) t * ('a, 'b, 'c) t

end

val make: 'a -> 'b -> 'c -> ('a, 'b, 'c) t

val get_0: ('a, 'b, 'c) t -> 'a

val get_1: ('a, 'b, 'c) t -> 'b

val get_2: ('a, 'b, 'c) t -> 'c

val flip: ('a, 'b, 'c) t -> ('c, 'b, 'a) t

end

module Tuple4 : sig

type ('a, 'b, 'c, 'd) t = 'a * 'b * 'c * 'd

include Concepts.Able.S4 with type ('a, 'b, 'c, 'd) t := ('a, 'b, 'c, 'd) t = sig

val equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

val different: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> bool

val repr: ('a, 'b, 'c, 'd) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> string

val compare: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> Compare.t

val less_than: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val between: ('a, 'b, 'c, 'd) t -> low:('a, 'b, 'c, 'd) t -> high:('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c, 'd) t -> low:('a, 'b, 'c, 'd) t -> high:('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> bool

val min: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t

val max: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t

val min_max: ('a, 'b, 'c, 'd) t -> ('a, 'b, 'c, 'd) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> ('a, 'b, 'c, 'd) t * ('a, 'b, 'c, 'd) t

end

val make: 'a -> 'b -> 'c -> 'd -> ('a, 'b, 'c, 'd) t

val get_0: ('a, 'b, 'c, 'd) t -> 'a

val get_1: ('a, 'b, 'c, 'd) t -> 'b

val get_2: ('a, 'b, 'c, 'd) t -> 'c

val get_3: ('a, 'b, 'c, 'd) t -> 'd

val flip: ('a, 'b, 'c, 'd) t -> ('d, 'c, 'b, 'a) t

end

module Tuple5 : sig

type ('a, 'b, 'c, 'd, 'e) t = 'a * 'b * 'c * 'd * 'e

include Concepts.Able.S5 with type ('a, 'b, 'c, 'd, 'e) t := ('a, 'b, 'c, 'd, 'e) t = sig

val equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

val different: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> equal_a:('a -> 'a -> bool) -> equal_b:('b -> 'b -> bool) -> equal_c:('c -> 'c -> bool) -> equal_d:('d -> 'd -> bool) -> equal_e:('e -> 'e -> bool) -> bool

val repr: ('a, 'b, 'c, 'd, 'e) t -> repr_a:('a -> string) -> repr_b:('b -> string) -> repr_c:('c -> string) -> repr_d:('d -> string) -> repr_e:('e -> string) -> string

val compare: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> Compare.t

val less_than: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val less_or_equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val greater_than: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val greater_or_equal: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val between: ('a, 'b, 'c, 'd, 'e) t -> low:('a, 'b, 'c, 'd, 'e) t -> high:('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val between_or_equal: ('a, 'b, 'c, 'd, 'e) t -> low:('a, 'b, 'c, 'd, 'e) t -> high:('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> bool

val min: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t

val max: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t

val min_max: ('a, 'b, 'c, 'd, 'e) t -> ('a, 'b, 'c, 'd, 'e) t -> compare_a:('a -> 'a -> Compare.t) -> compare_b:('b -> 'b -> Compare.t) -> compare_c:('c -> 'c -> Compare.t) -> compare_d:('d -> 'd -> Compare.t) -> compare_e:('e -> 'e -> Compare.t) -> ('a, 'b, 'c, 'd, 'e) t * ('a, 'b, 'c, 'd, 'e) t

end

val make: 'a -> 'b -> 'c -> 'd -> 'e -> ('a, 'b, 'c, 'd, 'e) t

val get_0: ('a, 'b, 'c, 'd, 'e) t -> 'a

val get_1: ('a, 'b, 'c, 'd, 'e) t -> 'b

val get_2: ('a, 'b, 'c, 'd, 'e) t -> 'c

val get_3: ('a, 'b, 'c, 'd, 'e) t -> 'd

val get_4: ('a, 'b, 'c, 'd, 'e) t -> 'e

val flip: ('a, 'b, 'c, 'd, 'e) t -> ('e, 'd, 'c, 'b, 'a) t

end

module IntOption : sig

include module type of Option.Specialize(Int) = sig

type t = Int.t option

val some_if: bool -> Int.t lazy_t -> t

val some_if': bool -> Int.t -> t

val is_some: t -> bool

val is_none: t -> bool

val value_def: t -> def:Int.t -> Int.t

val value: ?exc:exn -> t -> Int.t

val or_failure: ('a, unit, string, string, string, t -> Int.t) CamlinternalFormatBasics.format6 -> 'a

val map: t -> f:(Int.t -> 'a) -> 'a option

val iter: t -> f:(Int.t -> unit) -> unit

val filter: t -> f:(Int.t -> bool) -> t

val filter_map: t -> f:(Int.t -> 'a option) -> 'a option

val value_map: t -> def:'a -> f:(Int.t -> 'a) -> 'a

end

end

module FloatOption : sig

include module type of Option.Specialize(Float) = sig

type t = Float.t option

val some_if: bool -> Float.t lazy_t -> t

val some_if': bool -> Float.t -> t

val is_some: t -> bool

val is_none: t -> bool

val value_def: t -> def:Float.t -> Float.t

val value: ?exc:exn -> t -> Float.t

val or_failure: ('a, unit, string, string, string, t -> Float.t) CamlinternalFormatBasics.format6 -> 'a

val map: t -> f:(Float.t -> 'a) -> 'a option

val iter: t -> f:(Float.t -> unit) -> unit

val filter: t -> f:(Float.t -> bool) -> t

val filter_map: t -> f:(Float.t -> 'a option) -> 'a option

val value_map: t -> def:'a -> f:(Float.t -> 'a) -> 'a

end

end

module StringOption : sig

include module type of Option.Specialize(String) = sig

type t = String.t option

val some_if: bool -> String.t lazy_t -> t

val some_if': bool -> String.t -> t

val is_some: t -> bool

val is_none: t -> bool

val value_def: t -> def:String.t -> String.t

val value: ?exc:exn -> t -> String.t

val or_failure: ('a, unit, string, string, string, t -> String.t) CamlinternalFormatBasics.format6 -> 'a

val map: t -> f:(String.t -> 'a) -> 'a option

val iter: t -> f:(String.t -> unit) -> unit

val filter: t -> f:(String.t -> bool) -> t

val filter_map: t -> f:(String.t -> 'a option) -> 'a option

val value_map: t -> def:'a -> f:(String.t -> 'a) -> 'a

end

end

module IntReference : sig

type t = int Reference.t

module O : sig

include module type of Reference.SpecializeOperators(Int) with type t := t = sig

val ref: Int.t -> t

val (!): t -> Int.t

val (:=): t -> Int.t -> unit

end

include module type of Reference.SpecializeRingoidOperators(Int) with type t := t = sig

val (=+): t -> Int.t -> unit

val (=-): t -> Int.t -> unit

val (=*): t -> Int.t -> unit

val (=/): t -> Int.t -> unit

end

end

include module type of Reference.Specialize(Int) with type t := t and module O := O = sig

val of_contents: Int.t -> t

val contents: t -> Int.t

val assign: t -> Int.t -> unit

end

include module type of Reference.SpecializePredSucc(Int) with type t := t = sig

val increment: t -> unit

val decrement: t -> unit

end

include module type of Reference.SpecializeRingoid(Int) with type t := t and module O := O = sig

end

end

module FloatReference : sig

type t = float Reference.t

module O : sig

include module type of Reference.SpecializeOperators(Float) with type t := t = sig

val ref: Float.t -> t

val (!): t -> Float.t

val (:=): t -> Float.t -> unit

end

include module type of Reference.SpecializeRingoidOperators(Float) with type t := t = sig

val (=+): t -> Float.t -> unit

val (=-): t -> Float.t -> unit

val (=*): t -> Float.t -> unit

val (=/): t -> Float.t -> unit

end

end

include module type of Reference.Specialize(Float) with type t := t and module O := O = sig

val of_contents: Float.t -> t

val contents: t -> Float.t

val assign: t -> Float.t -> unit

end

include module type of Reference.SpecializeRingoid(Float) with type t := t and module O := O = sig

end

end

module StringReference : sig

type t = string Reference.t

module O : sig

include module type of Reference.SpecializeOperators(String) with type t := t = sig

val ref: String.t -> t

val (!): t -> String.t

val (:=): t -> String.t -> unit

end

val (=^): t -> string -> unit

end

include module type of Reference.Specialize(String) with type t := t and module O := O = sig

val of_contents: String.t -> t

val contents: t -> String.t

val assign: t -> String.t -> unit

end

end

module List : sig

type 'a t = 'a list

module O : sig

val (@): 'a t -> 'a t -> 'a t

end

val empty: 'a t

val singleton: 'a -> 'a t

val of_list: 'a list -> 'a t

val to_list: 'a t -> 'a list

val of_array: 'a array -> 'a t

val to_array: 'a t -> 'a array

val size: 'a t -> int

val is_empty: 'a t -> bool

val head: 'a t -> 'a

val tail: 'a t -> 'a t

val try_head: 'a t -> 'a option

val try_tail: 'a t -> 'a t option

val contains: 'a t -> 'a -> equal_a:('a -> 'a -> bool) -> bool

module Poly : sig

val contains: 'a t -> 'a -> bool

end

val prepend: 'a -> 'a t -> 'a t

val reverse: 'a t -> 'a t

val concat: 'a t -> 'a t -> 'a t

include Traits.FilterMapable.S1 with type 'a t := 'a t = sig

val map: 'a t -> f:('a -> 'b) -> 'b t

val map_i: 'a t -> f:(i:int -> 'a -> 'b) -> 'b t

val map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b) -> 'b t

val filter: 'a t -> f:('a -> bool) -> 'a t

val filter_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a t

val filter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a t

val filter_map: 'a t -> f:('a -> 'b option) -> 'b t

val filter_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b t

val filter_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b t

val flat_map: 'a t -> f:('a -> 'b t) -> 'b t

val flat_map_i: 'a t -> f:(i:int -> 'a -> 'b t) -> 'b t

val flat_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b t) -> 'b t

end

include Traits.Foldable.S1 with type 'a t := 'a t = sig

val fold: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b

val fold_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b

val reduce: 'a t -> f:('a -> 'a -> 'a) -> 'a

val reduce_i: 'a t -> f:(i:int -> 'a -> 'a -> 'a) -> 'a

val reduce_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * 'a) -> 'a

val try_reduce: 'a t -> f:('a -> 'a -> 'a) -> 'a option

val try_reduce_i: 'a t -> f:(i:int -> 'a -> 'a -> 'a) -> 'a option

val try_reduce_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * 'a) -> 'a option

val iter: 'a t -> f:('a -> unit) -> unit

val iter_i: 'a t -> f:(i:int -> 'a -> unit) -> unit

val iter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc) -> unit

val count: 'a t -> f:('a -> bool) -> int

val count_i: 'a t -> f:(i:int -> 'a -> bool) -> int

val count_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> int

end

include Traits.Foldable.Short.S1 with type 'a t := 'a t = sig

val fold_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b

val reduce_short: 'a t -> f:('a -> 'a -> Shorten.t * 'a) -> 'a

val reduce_short_i: 'a t -> f:(i:int -> 'a -> 'a -> Shorten.t * 'a) -> 'a

val reduce_short_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * Shorten.t * 'a) -> 'a

val try_reduce_short: 'a t -> f:('a -> 'a -> Shorten.t * 'a) -> 'a option

val try_reduce_short_i: 'a t -> f:(i:int -> 'a -> 'a -> Shorten.t * 'a) -> 'a option

val try_reduce_short_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'a -> 'acc * Shorten.t * 'a) -> 'a option

val iter_short: 'a t -> f:('a -> Shorten.t) -> unit

val iter_short_i: 'a t -> f:(i:int -> 'a -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * Shorten.t) -> unit

val for_all: 'a t -> f:('a -> bool) -> bool

val for_all_i: 'a t -> f:(i:int -> 'a -> bool) -> bool

val for_all_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> bool

val there_exists: 'a t -> f:('a -> bool) -> bool

val there_exists_i: 'a t -> f:(i:int -> 'a -> bool) -> bool

val there_exists_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> bool

val find: 'a t -> f:('a -> bool) -> 'a

val find_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a

val find_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a

val try_find: 'a t -> f:('a -> bool) -> 'a option

val try_find_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a option

val try_find_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a option

val find_map: 'a t -> f:('a -> 'b option) -> 'b

val find_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b

val find_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b

val try_find_map: 'a t -> f:('a -> 'b option) -> 'b option

val try_find_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b option

end

include Traits.Scanable.S1 with type 'a t := 'a t = sig

val scan: init:'b -> 'a t -> f:('b -> 'a -> 'b) -> 'b t

val scan_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> 'b) -> 'b t

val scan_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * 'b) -> 'b t

end

include Traits.Scanable.Short.S1 with type 'a t := 'a t = sig

val scan_short: init:'b -> 'a t -> f:('b -> 'a -> Shorten.t * 'b) -> 'b t

val scan_short_i: init:'b -> 'a t -> f:(i:int -> 'b -> 'a -> Shorten.t * 'b) -> 'b t

val scan_short_acc: acc:'acc -> init:'b -> 'a t -> f:(acc:'acc -> 'b -> 'a -> 'acc * Shorten.t * 'b) -> 'b t

end

module Two : sig

val to_pair_list: 'a t -> 'b t -> ('a * 'b) t

end

module Specialize : functor

(A : sig

type t

end)

-> sig

type t = A.t list

module O : sig

val (@): t -> t -> t

end

val empty: t

val singleton: A.t -> t

val of_list: A.t list -> t

val to_list: t -> A.t list

val of_array: A.t array -> t

val to_array: t -> A.t array

val size: t -> int

val is_empty: t -> bool

val head: t -> A.t

val tail: t -> t

val try_head: t -> A.t option

val try_tail: t -> t option

val prepend: A.t -> t -> t

val reverse: t -> t

val concat: t -> t -> t

include Traits.FilterMapable.S0 with type elt := A.t and type t := t = sig

val map: t -> f:(A.t -> A.t) -> t

val map_i: t -> f:(i:int -> A.t -> A.t) -> t

val map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * A.t) -> t

val filter: t -> f:(A.t -> bool) -> t

val filter_i: t -> f:(i:int -> A.t -> bool) -> t

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * bool) -> t

val filter_map: t -> f:(A.t -> A.t option) -> t

val filter_map_i: t -> f:(i:int -> A.t -> A.t option) -> t

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * A.t option) -> t

val flat_map: t -> f:(A.t -> t) -> t

val flat_map_i: t -> f:(i:int -> A.t -> t) -> t

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * t) -> t

end

include Traits.Foldable.S0 with type elt := A.t and type t := t = sig

val fold: init:'b -> t -> f:('b -> A.t -> 'b) -> 'b

val fold_i: init:'b -> t -> f:(i:int -> 'b -> A.t -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> A.t -> 'acc * 'b) -> 'b

val reduce: t -> f:(A.t -> A.t -> A.t) -> A.t

val reduce_i: t -> f:(i:int -> A.t -> A.t -> A.t) -> A.t

val reduce_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> A.t -> 'acc * A.t) -> A.t

val try_reduce: t -> f:(A.t -> A.t -> A.t) -> A.t option

val try_reduce_i: t -> f:(i:int -> A.t -> A.t -> A.t) -> A.t option

val try_reduce_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> A.t -> 'acc * A.t) -> A.t option

val iter: t -> f:(A.t -> unit) -> unit

val iter_i: t -> f:(i:int -> A.t -> unit) -> unit

val iter_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc) -> unit

val count: t -> f:(A.t -> bool) -> int

val count_i: t -> f:(i:int -> A.t -> bool) -> int

val count_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * bool) -> int

end

include Traits.Foldable.Short.S0 with type elt := A.t and type t := t = sig

val fold_short: init:'b -> t -> f:('b -> A.t -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> t -> f:(i:int -> 'b -> A.t -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> A.t -> 'acc * Shorten.t * 'b) -> 'b

val reduce_short: t -> f:(A.t -> A.t -> Shorten.t * A.t) -> A.t

val reduce_short_i: t -> f:(i:int -> A.t -> A.t -> Shorten.t * A.t) -> A.t

val reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> A.t -> 'acc * Shorten.t * A.t) -> A.t

val try_reduce_short: t -> f:(A.t -> A.t -> Shorten.t * A.t) -> A.t option

val try_reduce_short_i: t -> f:(i:int -> A.t -> A.t -> Shorten.t * A.t) -> A.t option

val try_reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> A.t -> 'acc * Shorten.t * A.t) -> A.t option

val iter_short: t -> f:(A.t -> Shorten.t) -> unit

val iter_short_i: t -> f:(i:int -> A.t -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * Shorten.t) -> unit

val for_all: t -> f:(A.t -> bool) -> bool

val for_all_i: t -> f:(i:int -> A.t -> bool) -> bool

val for_all_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * bool) -> bool

val there_exists: t -> f:(A.t -> bool) -> bool

val there_exists_i: t -> f:(i:int -> A.t -> bool) -> bool

val there_exists_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * bool) -> bool

val find: t -> f:(A.t -> bool) -> A.t

val find_i: t -> f:(i:int -> A.t -> bool) -> A.t

val find_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * bool) -> A.t

val try_find: t -> f:(A.t -> bool) -> A.t option

val try_find_i: t -> f:(i:int -> A.t -> bool) -> A.t option

val try_find_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * bool) -> A.t option

val find_map: t -> f:(A.t -> 'b option) -> 'b

val find_map_i: t -> f:(i:int -> A.t -> 'b option) -> 'b

val find_map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * 'b option) -> 'b

val try_find_map: t -> f:(A.t -> 'b option) -> 'b option

val try_find_map_i: t -> f:(i:int -> A.t -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * 'b option) -> 'b option

end

include Traits.Scanable.S0 with type elt := A.t and type t := t = sig

val scan: init:A.t -> t -> f:(A.t -> A.t -> A.t) -> t

val scan_i: init:A.t -> t -> f:(i:int -> A.t -> A.t -> A.t) -> t

val scan_acc: acc:'acc -> init:A.t -> t -> f:(acc:'acc -> A.t -> A.t -> 'acc * A.t) -> t

end

include Traits.Scanable.Short.S0 with type elt := A.t and type t := t = sig

val scan_short: init:A.t -> t -> f:(A.t -> A.t -> Shorten.t * A.t) -> t

val scan_short_i: init:A.t -> t -> f:(i:int -> A.t -> A.t -> Shorten.t * A.t) -> t

val scan_short_acc: acc:'acc -> init:A.t -> t -> f:(acc:'acc -> A.t -> A.t -> 'acc * Shorten.t * A.t) -> t

end

module ToList : sig

include Traits.FilterMapable.ToList.S0 with type elt := A.t and type t := t = sig

val map: t -> f:(A.t -> 'b) -> 'b list

val map_i: t -> f:(i:int -> A.t -> 'b) -> 'b list

val map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * 'b) -> 'b list

val filter: t -> f:(A.t -> bool) -> A.t list

val filter_i: t -> f:(i:int -> A.t -> bool) -> A.t list

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * bool) -> A.t list

val filter_map: t -> f:(A.t -> 'b option) -> 'b list

val filter_map_i: t -> f:(i:int -> A.t -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * 'b option) -> 'b list

val flat_map: t -> f:(A.t -> 'b list) -> 'b list

val flat_map_i: t -> f:(i:int -> A.t -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> A.t -> 'acc * 'b list) -> 'b list

end

include Traits.Scanable.ToList.S0 with type elt := A.t and type t := t = sig

val scan: init:'a -> t -> f:('a -> A.t -> 'a) -> 'a list

val scan_i: init:'a -> t -> f:(i:int -> 'a -> A.t -> 'a) -> 'a list

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> A.t -> 'acc * 'a) -> 'a list

end

include Traits.Scanable.Short.ToList.S0 with type elt := A.t and type t := t = sig

val scan_short: init:'a -> t -> f:('a -> A.t -> Shorten.t * 'a) -> 'a list

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> A.t -> Shorten.t * 'a) -> 'a list

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> A.t -> 'acc * Shorten.t * 'a) -> 'a list

end

end

end

module SpecializeEquatable : functor

(A : Traits.Equatable.Basic.S0 = sig

type t

val equal: t -> t -> bool

end)

-> sig

type t = A.t list

val contains: t -> A.t -> bool

end

end

module Array : sig

type 'a t = 'a array

val size: 'a t -> int

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

val set: 'a t -> int -> 'a -> unit

end

module Stream : sig

type 'a t = 'a Pervasives.OCamlStandard.Stream.t

val empty: 'a t

val singleton: 'a -> 'a t

val to_list: 'a t -> 'a list

val of_list: 'a list -> 'a t

val prepend: 'a -> 'a t -> 'a t

val concat: 'a t -> 'a t -> 'a t

include Traits.FilterMapable.S1 with type 'a t := 'a t = sig

val map: 'a t -> f:('a -> 'b) -> 'b t

val map_i: 'a t -> f:(i:int -> 'a -> 'b) -> 'b t

val map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b) -> 'b t

val filter: 'a t -> f:('a -> bool) -> 'a t

val filter_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a t

val filter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a t

val filter_map: 'a t -> f:('a -> 'b option) -> 'b t

val filter_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b t

val filter_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b t

val flat_map: 'a t -> f:('a -> 'b t) -> 'b t

val flat_map_i: 'a t -> f:(i:int -> 'a -> 'b t) -> 'b t

val flat_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b t) -> 'b t

end

module ToList : sig

include Traits.FilterMapable.ToList.S1 with type 'a t := 'a t = sig

val map: 'a t -> f:('a -> 'b) -> 'b list

val map_i: 'a t -> f:(i:int -> 'a -> 'b) -> 'b list

val map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b) -> 'b list

val filter: 'a t -> f:('a -> bool) -> 'a list

val filter_i: 'a t -> f:(i:int -> 'a -> bool) -> 'a list

val filter_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * bool) -> 'a list

val filter_map: 'a t -> f:('a -> 'b option) -> 'b list

val filter_map_i: 'a t -> f:(i:int -> 'a -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b option) -> 'b list

val flat_map: 'a t -> f:('a -> 'b list) -> 'b list

val flat_map_i: 'a t -> f:(i:int -> 'a -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> 'a t -> f:(acc:'acc -> 'a -> 'acc * 'b list) -> 'b list

end

end

end

module SortedSet : sig

module Poly : sig

type 'a t

val empty: 'a t

val of_list: 'a list -> 'a t

val to_list: 'a t -> 'a list

val is_empty: 'a t -> bool

val size: 'a t -> int

val add: 'a t -> v:'a -> bool * 'a t

val replace: 'a t -> v:'a -> 'a t

val remove: 'a t -> v:'a -> bool * 'a t

val contains: 'a t -> v:'a -> bool

end

module Make : functor

(E : Traits.Comparable.Basic.S0 = sig

type t

val compare: t -> t -> Compare.t

end)

-> sig

type t

val empty: t

val of_list: E.t list -> t

val to_list: t -> E.t list

val is_empty: t -> bool

val size: t -> int

val add: t -> v:E.t -> bool * t

val replace: t -> v:E.t -> t

val remove: t -> v:E.t -> bool * t

val contains: t -> v:E.t -> bool

end

end

module SortedMap : sig

module Poly : sig

type ('a, 'b) t

val empty: ('a, 'b) t

val of_list_first: ('a * 'b) list -> ('a, 'b) t

val of_list_last: ('a * 'b) list -> ('a, 'b) t

val to_list: ('a, 'b) t -> ('a * 'b) list

val is_empty: ('a, 'b) t -> bool

val size: ('a, 'b) t -> int

val add: ('a, 'b) t -> k:'a -> v:'b -> bool * ('a, 'b) t

val replace: ('a, 'b) t -> k:'a -> v:'b -> ('a, 'b) t

val remove: ('a, 'b) t -> k:'a -> bool * ('a, 'b) t

val try_get: ('a, 'b) t -> k:'a -> 'b option

val get: ('a, 'b) t -> k:'a -> 'b

end

module Make : functor

(K : Traits.Comparable.Basic.S0 = sig

type t

val compare: t -> t -> Compare.t

end)

-> sig

type 'a t

val empty: 'a t

val of_list_first: (K.t * 'a) list -> 'a t

val of_list_last: (K.t * 'a) list -> 'a t

val to_list: 'a t -> (K.t * 'a) list

val is_empty: 'a t -> bool

val size: 'a t -> int

val add: 'a t -> k:K.t -> v:'a -> bool * 'a t

val replace: 'a t -> k:K.t -> v:'a -> 'a t

val remove: 'a t -> k:K.t -> bool * 'a t

val try_get: 'a t -> k:K.t -> 'a option

val get: 'a t -> k:K.t -> 'a

end

end

module IntRange : sig

type t

include Concepts.Identifiable.S0 with type t := t = sig

val equal: t -> t -> bool

val different: t -> t -> bool

module O : sig

val (=): t -> t -> bool

val (<>): t -> t -> bool

end

val repr: t -> string

end

val empty: t

val make: ?start:int -> ?step:int -> int -> t

val to_list: t -> int list

val to_array: t -> int array

include Traits.Foldable.S0 with type elt := int and type t := t = sig

val fold: init:'b -> t -> f:('b -> int -> 'b) -> 'b

val fold_i: init:'b -> t -> f:(i:int -> 'b -> int -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> int -> 'acc * 'b) -> 'b

val reduce: t -> f:(int -> int -> int) -> int

val reduce_i: t -> f:(i:int -> int -> int -> int) -> int

val reduce_acc: acc:'acc -> t -> f:(acc:'acc -> int -> int -> 'acc * int) -> int

val try_reduce: t -> f:(int -> int -> int) -> int option

val try_reduce_i: t -> f:(i:int -> int -> int -> int) -> int option

val try_reduce_acc: acc:'acc -> t -> f:(acc:'acc -> int -> int -> 'acc * int) -> int option

val iter: t -> f:(int -> unit) -> unit

val iter_i: t -> f:(i:int -> int -> unit) -> unit

val iter_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc) -> unit

val count: t -> f:(int -> bool) -> int

val count_i: t -> f:(i:int -> int -> bool) -> int

val count_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * bool) -> int

end

include Traits.Foldable.Short.S0 with type elt := int and type t := t = sig

val fold_short: init:'b -> t -> f:('b -> int -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> t -> f:(i:int -> 'b -> int -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> int -> 'acc * Shorten.t * 'b) -> 'b

val reduce_short: t -> f:(int -> int -> Shorten.t * int) -> int

val reduce_short_i: t -> f:(i:int -> int -> int -> Shorten.t * int) -> int

val reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> int -> int -> 'acc * Shorten.t * int) -> int

val try_reduce_short: t -> f:(int -> int -> Shorten.t * int) -> int option

val try_reduce_short_i: t -> f:(i:int -> int -> int -> Shorten.t * int) -> int option

val try_reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> int -> int -> 'acc * Shorten.t * int) -> int option

val iter_short: t -> f:(int -> Shorten.t) -> unit

val iter_short_i: t -> f:(i:int -> int -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * Shorten.t) -> unit

val for_all: t -> f:(int -> bool) -> bool

val for_all_i: t -> f:(i:int -> int -> bool) -> bool

val for_all_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * bool) -> bool

val there_exists: t -> f:(int -> bool) -> bool

val there_exists_i: t -> f:(i:int -> int -> bool) -> bool

val there_exists_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * bool) -> bool

val find: t -> f:(int -> bool) -> int

val find_i: t -> f:(i:int -> int -> bool) -> int

val find_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * bool) -> int

val try_find: t -> f:(int -> bool) -> int option

val try_find_i: t -> f:(i:int -> int -> bool) -> int option

val try_find_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * bool) -> int option

val find_map: t -> f:(int -> 'b option) -> 'b

val find_map_i: t -> f:(i:int -> int -> 'b option) -> 'b

val find_map_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * 'b option) -> 'b

val try_find_map: t -> f:(int -> 'b option) -> 'b option

val try_find_map_i: t -> f:(i:int -> int -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * 'b option) -> 'b option

end

module ToList : sig

include Traits.FilterMapable.ToList.S0 with type elt := int and type t := t = sig

val map: t -> f:(int -> 'b) -> 'b list

val map_i: t -> f:(i:int -> int -> 'b) -> 'b list

val map_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * 'b) -> 'b list

val filter: t -> f:(int -> bool) -> int list

val filter_i: t -> f:(i:int -> int -> bool) -> int list

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * bool) -> int list

val filter_map: t -> f:(int -> 'b option) -> 'b list

val filter_map_i: t -> f:(i:int -> int -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * 'b option) -> 'b list

val flat_map: t -> f:(int -> 'b list) -> 'b list

val flat_map_i: t -> f:(i:int -> int -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> int -> 'acc * 'b list) -> 'b list

end

include Traits.Scanable.ToList.S0 with type elt := int and type t := t = sig

val scan: init:'a -> t -> f:('a -> int -> 'a) -> 'a list

val scan_i: init:'a -> t -> f:(i:int -> 'a -> int -> 'a) -> 'a list

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> int -> 'acc * 'a) -> 'a list

end

include Traits.Scanable.Short.ToList.S0 with type elt := int and type t := t = sig

val scan_short: init:'a -> t -> f:('a -> int -> Shorten.t * 'a) -> 'a list

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> int -> Shorten.t * 'a) -> 'a list

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> int -> 'acc * Shorten.t * 'a) -> 'a list

end

end

end

module IntList : sig

include module type of List.Specialize(Int) = sig

type t = Int.t list

module O : sig

val (@): t -> t -> t

end

val empty: t

val singleton: Int.t -> t

val of_list: Int.t list -> t

val to_list: t -> Int.t list

val of_array: Int.t array -> t

val to_array: t -> Int.t array

val size: t -> int

val is_empty: t -> bool

val head: t -> Int.t

val tail: t -> t

val try_head: t -> Int.t option

val try_tail: t -> t option

val prepend: Int.t -> t -> t

val reverse: t -> t

val concat: t -> t -> t

val map: t -> f:(Int.t -> Int.t) -> t

val map_i: t -> f:(i:int -> Int.t -> Int.t) -> t

val map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * Int.t) -> t

val filter: t -> f:(Int.t -> bool) -> t

val filter_i: t -> f:(i:int -> Int.t -> bool) -> t

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * bool) -> t

val filter_map: t -> f:(Int.t -> Int.t option) -> t

val filter_map_i: t -> f:(i:int -> Int.t -> Int.t option) -> t

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * Int.t option) -> t

val flat_map: t -> f:(Int.t -> t) -> t

val flat_map_i: t -> f:(i:int -> Int.t -> t) -> t

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * t) -> t

val fold: init:'b -> t -> f:('b -> Int.t -> 'b) -> 'b

val fold_i: init:'b -> t -> f:(i:int -> 'b -> Int.t -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> Int.t -> 'acc * 'b) -> 'b

val reduce: t -> f:(Int.t -> Int.t -> Int.t) -> Int.t

val reduce_i: t -> f:(i:int -> Int.t -> Int.t -> Int.t) -> Int.t

val reduce_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> Int.t -> 'acc * Int.t) -> Int.t

val try_reduce: t -> f:(Int.t -> Int.t -> Int.t) -> Int.t option

val try_reduce_i: t -> f:(i:int -> Int.t -> Int.t -> Int.t) -> Int.t option

val try_reduce_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> Int.t -> 'acc * Int.t) -> Int.t option

val iter: t -> f:(Int.t -> unit) -> unit

val iter_i: t -> f:(i:int -> Int.t -> unit) -> unit

val iter_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc) -> unit

val count: t -> f:(Int.t -> bool) -> int

val count_i: t -> f:(i:int -> Int.t -> bool) -> int

val count_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * bool) -> int

val fold_short: init:'b -> t -> f:('b -> Int.t -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> t -> f:(i:int -> 'b -> Int.t -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> Int.t -> 'acc * Shorten.t * 'b) -> 'b

val reduce_short: t -> f:(Int.t -> Int.t -> Shorten.t * Int.t) -> Int.t

val reduce_short_i: t -> f:(i:int -> Int.t -> Int.t -> Shorten.t * Int.t) -> Int.t

val reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> Int.t -> 'acc * Shorten.t * Int.t) -> Int.t

val try_reduce_short: t -> f:(Int.t -> Int.t -> Shorten.t * Int.t) -> Int.t option

val try_reduce_short_i: t -> f:(i:int -> Int.t -> Int.t -> Shorten.t * Int.t) -> Int.t option

val try_reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> Int.t -> 'acc * Shorten.t * Int.t) -> Int.t option

val iter_short: t -> f:(Int.t -> Shorten.t) -> unit

val iter_short_i: t -> f:(i:int -> Int.t -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * Shorten.t) -> unit

val for_all: t -> f:(Int.t -> bool) -> bool

val for_all_i: t -> f:(i:int -> Int.t -> bool) -> bool

val for_all_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * bool) -> bool

val there_exists: t -> f:(Int.t -> bool) -> bool

val there_exists_i: t -> f:(i:int -> Int.t -> bool) -> bool

val there_exists_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * bool) -> bool

val find: t -> f:(Int.t -> bool) -> Int.t

val find_i: t -> f:(i:int -> Int.t -> bool) -> Int.t

val find_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * bool) -> Int.t

val try_find: t -> f:(Int.t -> bool) -> Int.t option

val try_find_i: t -> f:(i:int -> Int.t -> bool) -> Int.t option

val try_find_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * bool) -> Int.t option

val find_map: t -> f:(Int.t -> 'b option) -> 'b

val find_map_i: t -> f:(i:int -> Int.t -> 'b option) -> 'b

val find_map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * 'b option) -> 'b

val try_find_map: t -> f:(Int.t -> 'b option) -> 'b option

val try_find_map_i: t -> f:(i:int -> Int.t -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * 'b option) -> 'b option

val scan: init:Int.t -> t -> f:(Int.t -> Int.t -> Int.t) -> t

val scan_i: init:Int.t -> t -> f:(i:int -> Int.t -> Int.t -> Int.t) -> t

val scan_acc: acc:'acc -> init:Int.t -> t -> f:(acc:'acc -> Int.t -> Int.t -> 'acc * Int.t) -> t

val scan_short: init:Int.t -> t -> f:(Int.t -> Int.t -> Shorten.t * Int.t) -> t

val scan_short_i: init:Int.t -> t -> f:(i:int -> Int.t -> Int.t -> Shorten.t * Int.t) -> t

val scan_short_acc: acc:'acc -> init:Int.t -> t -> f:(acc:'acc -> Int.t -> Int.t -> 'acc * Shorten.t * Int.t) -> t

module ToList : sig

val map: t -> f:(Int.t -> 'b) -> 'b list

val map_i: t -> f:(i:int -> Int.t -> 'b) -> 'b list

val map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * 'b) -> 'b list

val filter: t -> f:(Int.t -> bool) -> Int.t list

val filter_i: t -> f:(i:int -> Int.t -> bool) -> Int.t list

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * bool) -> Int.t list

val filter_map: t -> f:(Int.t -> 'b option) -> 'b list

val filter_map_i: t -> f:(i:int -> Int.t -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * 'b option) -> 'b list

val flat_map: t -> f:(Int.t -> 'b list) -> 'b list

val flat_map_i: t -> f:(i:int -> Int.t -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> Int.t -> 'acc * 'b list) -> 'b list

val scan: init:'a -> t -> f:('a -> Int.t -> 'a) -> 'a list

val scan_i: init:'a -> t -> f:(i:int -> 'a -> Int.t -> 'a) -> 'a list

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> Int.t -> 'acc * 'a) -> 'a list

val scan_short: init:'a -> t -> f:('a -> Int.t -> Shorten.t * 'a) -> 'a list

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> Int.t -> Shorten.t * 'a) -> 'a list

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> Int.t -> 'acc * Shorten.t * 'a) -> 'a list

end

end

include module type of List.SpecializeEquatable(Int) with type t := t = sig

val contains: t -> Int.t -> bool

end

end

module FloatList : sig

include module type of List.Specialize(Float) = sig

type t = Float.t list

module O : sig

val (@): t -> t -> t

end

val empty: t

val singleton: Float.t -> t

val of_list: Float.t list -> t

val to_list: t -> Float.t list

val of_array: Float.t array -> t

val to_array: t -> Float.t array

val size: t -> int

val is_empty: t -> bool

val head: t -> Float.t

val tail: t -> t

val try_head: t -> Float.t option

val try_tail: t -> t option

val prepend: Float.t -> t -> t

val reverse: t -> t

val concat: t -> t -> t

val map: t -> f:(Float.t -> Float.t) -> t

val map_i: t -> f:(i:int -> Float.t -> Float.t) -> t

val map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * Float.t) -> t

val filter: t -> f:(Float.t -> bool) -> t

val filter_i: t -> f:(i:int -> Float.t -> bool) -> t

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * bool) -> t

val filter_map: t -> f:(Float.t -> Float.t option) -> t

val filter_map_i: t -> f:(i:int -> Float.t -> Float.t option) -> t

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * Float.t option) -> t

val flat_map: t -> f:(Float.t -> t) -> t

val flat_map_i: t -> f:(i:int -> Float.t -> t) -> t

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * t) -> t

val fold: init:'b -> t -> f:('b -> Float.t -> 'b) -> 'b

val fold_i: init:'b -> t -> f:(i:int -> 'b -> Float.t -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> Float.t -> 'acc * 'b) -> 'b

val reduce: t -> f:(Float.t -> Float.t -> Float.t) -> Float.t

val reduce_i: t -> f:(i:int -> Float.t -> Float.t -> Float.t) -> Float.t

val reduce_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> Float.t -> 'acc * Float.t) -> Float.t

val try_reduce: t -> f:(Float.t -> Float.t -> Float.t) -> Float.t option

val try_reduce_i: t -> f:(i:int -> Float.t -> Float.t -> Float.t) -> Float.t option

val try_reduce_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> Float.t -> 'acc * Float.t) -> Float.t option

val iter: t -> f:(Float.t -> unit) -> unit

val iter_i: t -> f:(i:int -> Float.t -> unit) -> unit

val iter_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc) -> unit

val count: t -> f:(Float.t -> bool) -> int

val count_i: t -> f:(i:int -> Float.t -> bool) -> int

val count_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * bool) -> int

val fold_short: init:'b -> t -> f:('b -> Float.t -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> t -> f:(i:int -> 'b -> Float.t -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> Float.t -> 'acc * Shorten.t * 'b) -> 'b

val reduce_short: t -> f:(Float.t -> Float.t -> Shorten.t * Float.t) -> Float.t

val reduce_short_i: t -> f:(i:int -> Float.t -> Float.t -> Shorten.t * Float.t) -> Float.t

val reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> Float.t -> 'acc * Shorten.t * Float.t) -> Float.t

val try_reduce_short: t -> f:(Float.t -> Float.t -> Shorten.t * Float.t) -> Float.t option

val try_reduce_short_i: t -> f:(i:int -> Float.t -> Float.t -> Shorten.t * Float.t) -> Float.t option

val try_reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> Float.t -> 'acc * Shorten.t * Float.t) -> Float.t option

val iter_short: t -> f:(Float.t -> Shorten.t) -> unit

val iter_short_i: t -> f:(i:int -> Float.t -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * Shorten.t) -> unit

val for_all: t -> f:(Float.t -> bool) -> bool

val for_all_i: t -> f:(i:int -> Float.t -> bool) -> bool

val for_all_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * bool) -> bool

val there_exists: t -> f:(Float.t -> bool) -> bool

val there_exists_i: t -> f:(i:int -> Float.t -> bool) -> bool

val there_exists_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * bool) -> bool

val find: t -> f:(Float.t -> bool) -> Float.t

val find_i: t -> f:(i:int -> Float.t -> bool) -> Float.t

val find_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * bool) -> Float.t

val try_find: t -> f:(Float.t -> bool) -> Float.t option

val try_find_i: t -> f:(i:int -> Float.t -> bool) -> Float.t option

val try_find_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * bool) -> Float.t option

val find_map: t -> f:(Float.t -> 'b option) -> 'b

val find_map_i: t -> f:(i:int -> Float.t -> 'b option) -> 'b

val find_map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * 'b option) -> 'b

val try_find_map: t -> f:(Float.t -> 'b option) -> 'b option

val try_find_map_i: t -> f:(i:int -> Float.t -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * 'b option) -> 'b option

val scan: init:Float.t -> t -> f:(Float.t -> Float.t -> Float.t) -> t

val scan_i: init:Float.t -> t -> f:(i:int -> Float.t -> Float.t -> Float.t) -> t

val scan_acc: acc:'acc -> init:Float.t -> t -> f:(acc:'acc -> Float.t -> Float.t -> 'acc * Float.t) -> t

val scan_short: init:Float.t -> t -> f:(Float.t -> Float.t -> Shorten.t * Float.t) -> t

val scan_short_i: init:Float.t -> t -> f:(i:int -> Float.t -> Float.t -> Shorten.t * Float.t) -> t

val scan_short_acc: acc:'acc -> init:Float.t -> t -> f:(acc:'acc -> Float.t -> Float.t -> 'acc * Shorten.t * Float.t) -> t

module ToList : sig

val map: t -> f:(Float.t -> 'b) -> 'b list

val map_i: t -> f:(i:int -> Float.t -> 'b) -> 'b list

val map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * 'b) -> 'b list

val filter: t -> f:(Float.t -> bool) -> Float.t list

val filter_i: t -> f:(i:int -> Float.t -> bool) -> Float.t list

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * bool) -> Float.t list

val filter_map: t -> f:(Float.t -> 'b option) -> 'b list

val filter_map_i: t -> f:(i:int -> Float.t -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * 'b option) -> 'b list

val flat_map: t -> f:(Float.t -> 'b list) -> 'b list

val flat_map_i: t -> f:(i:int -> Float.t -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> Float.t -> 'acc * 'b list) -> 'b list

val scan: init:'a -> t -> f:('a -> Float.t -> 'a) -> 'a list

val scan_i: init:'a -> t -> f:(i:int -> 'a -> Float.t -> 'a) -> 'a list

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> Float.t -> 'acc * 'a) -> 'a list

val scan_short: init:'a -> t -> f:('a -> Float.t -> Shorten.t * 'a) -> 'a list

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> Float.t -> Shorten.t * 'a) -> 'a list

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> Float.t -> 'acc * Shorten.t * 'a) -> 'a list

end

end

include module type of List.SpecializeEquatable(Float) with type t := t = sig

val contains: t -> Float.t -> bool

end

end

module StringList : sig

include module type of List.Specialize(String) = sig

type t = String.t list

module O : sig

val (@): t -> t -> t

end

val empty: t

val singleton: String.t -> t

val of_list: String.t list -> t

val to_list: t -> String.t list

val of_array: String.t array -> t

val to_array: t -> String.t array

val size: t -> int

val is_empty: t -> bool

val head: t -> String.t

val tail: t -> t

val try_head: t -> String.t option

val try_tail: t -> t option

val prepend: String.t -> t -> t

val reverse: t -> t

val concat: t -> t -> t

val map: t -> f:(String.t -> String.t) -> t

val map_i: t -> f:(i:int -> String.t -> String.t) -> t

val map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * String.t) -> t

val filter: t -> f:(String.t -> bool) -> t

val filter_i: t -> f:(i:int -> String.t -> bool) -> t

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * bool) -> t

val filter_map: t -> f:(String.t -> String.t option) -> t

val filter_map_i: t -> f:(i:int -> String.t -> String.t option) -> t

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * String.t option) -> t

val flat_map: t -> f:(String.t -> t) -> t

val flat_map_i: t -> f:(i:int -> String.t -> t) -> t

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * t) -> t

val fold: init:'b -> t -> f:('b -> String.t -> 'b) -> 'b

val fold_i: init:'b -> t -> f:(i:int -> 'b -> String.t -> 'b) -> 'b

val fold_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> String.t -> 'acc * 'b) -> 'b

val reduce: t -> f:(String.t -> String.t -> String.t) -> String.t

val reduce_i: t -> f:(i:int -> String.t -> String.t -> String.t) -> String.t

val reduce_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> String.t -> 'acc * String.t) -> String.t

val try_reduce: t -> f:(String.t -> String.t -> String.t) -> String.t option

val try_reduce_i: t -> f:(i:int -> String.t -> String.t -> String.t) -> String.t option

val try_reduce_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> String.t -> 'acc * String.t) -> String.t option

val iter: t -> f:(String.t -> unit) -> unit

val iter_i: t -> f:(i:int -> String.t -> unit) -> unit

val iter_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc) -> unit

val count: t -> f:(String.t -> bool) -> int

val count_i: t -> f:(i:int -> String.t -> bool) -> int

val count_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * bool) -> int

val fold_short: init:'b -> t -> f:('b -> String.t -> Shorten.t * 'b) -> 'b

val fold_short_i: init:'b -> t -> f:(i:int -> 'b -> String.t -> Shorten.t * 'b) -> 'b

val fold_short_acc: acc:'acc -> init:'b -> t -> f:(acc:'acc -> 'b -> String.t -> 'acc * Shorten.t * 'b) -> 'b

val reduce_short: t -> f:(String.t -> String.t -> Shorten.t * String.t) -> String.t

val reduce_short_i: t -> f:(i:int -> String.t -> String.t -> Shorten.t * String.t) -> String.t

val reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> String.t -> 'acc * Shorten.t * String.t) -> String.t

val try_reduce_short: t -> f:(String.t -> String.t -> Shorten.t * String.t) -> String.t option

val try_reduce_short_i: t -> f:(i:int -> String.t -> String.t -> Shorten.t * String.t) -> String.t option

val try_reduce_short_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> String.t -> 'acc * Shorten.t * String.t) -> String.t option

val iter_short: t -> f:(String.t -> Shorten.t) -> unit

val iter_short_i: t -> f:(i:int -> String.t -> Shorten.t) -> unit

val iter_short_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * Shorten.t) -> unit

val for_all: t -> f:(String.t -> bool) -> bool

val for_all_i: t -> f:(i:int -> String.t -> bool) -> bool

val for_all_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * bool) -> bool

val there_exists: t -> f:(String.t -> bool) -> bool

val there_exists_i: t -> f:(i:int -> String.t -> bool) -> bool

val there_exists_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * bool) -> bool

val find: t -> f:(String.t -> bool) -> String.t

val find_i: t -> f:(i:int -> String.t -> bool) -> String.t

val find_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * bool) -> String.t

val try_find: t -> f:(String.t -> bool) -> String.t option

val try_find_i: t -> f:(i:int -> String.t -> bool) -> String.t option

val try_find_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * bool) -> String.t option

val find_map: t -> f:(String.t -> 'b option) -> 'b

val find_map_i: t -> f:(i:int -> String.t -> 'b option) -> 'b

val find_map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * 'b option) -> 'b

val try_find_map: t -> f:(String.t -> 'b option) -> 'b option

val try_find_map_i: t -> f:(i:int -> String.t -> 'b option) -> 'b option

val try_find_map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * 'b option) -> 'b option

val scan: init:String.t -> t -> f:(String.t -> String.t -> String.t) -> t

val scan_i: init:String.t -> t -> f:(i:int -> String.t -> String.t -> String.t) -> t

val scan_acc: acc:'acc -> init:String.t -> t -> f:(acc:'acc -> String.t -> String.t -> 'acc * String.t) -> t

val scan_short: init:String.t -> t -> f:(String.t -> String.t -> Shorten.t * String.t) -> t

val scan_short_i: init:String.t -> t -> f:(i:int -> String.t -> String.t -> Shorten.t * String.t) -> t

val scan_short_acc: acc:'acc -> init:String.t -> t -> f:(acc:'acc -> String.t -> String.t -> 'acc * Shorten.t * String.t) -> t

module ToList : sig

val map: t -> f:(String.t -> 'b) -> 'b list

val map_i: t -> f:(i:int -> String.t -> 'b) -> 'b list

val map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * 'b) -> 'b list

val filter: t -> f:(String.t -> bool) -> String.t list

val filter_i: t -> f:(i:int -> String.t -> bool) -> String.t list

val filter_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * bool) -> String.t list

val filter_map: t -> f:(String.t -> 'b option) -> 'b list

val filter_map_i: t -> f:(i:int -> String.t -> 'b option) -> 'b list

val filter_map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * 'b option) -> 'b list

val flat_map: t -> f:(String.t -> 'b list) -> 'b list

val flat_map_i: t -> f:(i:int -> String.t -> 'b list) -> 'b list

val flat_map_acc: acc:'acc -> t -> f:(acc:'acc -> String.t -> 'acc * 'b list) -> 'b list

val scan: init:'a -> t -> f:('a -> String.t -> 'a) -> 'a list

val scan_i: init:'a -> t -> f:(i:int -> 'a -> String.t -> 'a) -> 'a list

val scan_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> String.t -> 'acc * 'a) -> 'a list

val scan_short: init:'a -> t -> f:('a -> String.t -> Shorten.t * 'a) -> 'a list

val scan_short_i: init:'a -> t -> f:(i:int -> 'a -> String.t -> Shorten.t * 'a) -> 'a list

val scan_short_acc: acc:'acc -> init:'a -> t -> f:(acc:'acc -> 'a -> String.t -> 'acc * Shorten.t * 'a) -> 'a list

end

end

include module type of List.SpecializeEquatable(String) with type t := t = sig

val contains: t -> String.t -> bool

end

val join: ?sep:string -> t -> string

end

module IntSortedSet : sig

include module type of SortedSet.Make(Int) = sig

type t = SortedSet.Make(Int).t

val empty: t

val of_list: Int.t list -> t

val to_list: t -> Int.t list

val is_empty: t -> bool

val size: t -> int

val add: t -> v:Int.t -> bool * t

val replace: t -> v:Int.t -> t

val remove: t -> v:Int.t -> bool * t

val contains: t -> v:Int.t -> bool

end

end

module FloatSortedSet : sig

include module type of SortedSet.Make(Float) = sig

type t = SortedSet.Make(Float).t

val empty: t

val of_list: Float.t list -> t

val to_list: t -> Float.t list

val is_empty: t -> bool

val size: t -> int

val add: t -> v:Float.t -> bool * t

val replace: t -> v:Float.t -> t

val remove: t -> v:Float.t -> bool * t

val contains: t -> v:Float.t -> bool

end

end

module StringSortedSet : sig

include module type of SortedSet.Make(String) = sig

type t = SortedSet.Make(String).t

val empty: t

val of_list: String.t list -> t

val to_list: t -> String.t list

val is_empty: t -> bool

val size: t -> int

val add: t -> v:String.t -> bool * t

val replace: t -> v:String.t -> t

val remove: t -> v:String.t -> bool * t

val contains: t -> v:String.t -> bool

end

end

module CharSortedSet : sig

include module type of SortedSet.Make(Char) = sig

type t = SortedSet.Make(Char).t

val empty: t

val of_list: Char.t list -> t

val to_list: t -> Char.t list

val is_empty: t -> bool

val size: t -> int

val add: t -> v:Char.t -> bool * t

val replace: t -> v:Char.t -> t

val remove: t -> v:Char.t -> bool * t

val contains: t -> v:Char.t -> bool

end

end

module IntSortedMap : sig

include module type of SortedMap.Make(Int) = sig

type 'a t = 'a SortedMap.Make(Int).t

val empty: 'a t

val of_list_first: (Int.t * 'a) list -> 'a t

val of_list_last: (Int.t * 'a) list -> 'a t

val to_list: 'a t -> (Int.t * 'a) list

val is_empty: 'a t -> bool

val size: 'a t -> int

val add: 'a t -> k:Int.t -> v:'a -> bool * 'a t

val replace: 'a t -> k:Int.t -> v:'a -> 'a t

val remove: 'a t -> k:Int.t -> bool * 'a t

val try_get: 'a t -> k:Int.t -> 'a option

val get: 'a t -> k:Int.t -> 'a

end

end

module FloatSortedMap : sig

include module type of SortedMap.Make(Float) = sig

type 'a t = 'a SortedMap.Make(Float).t

val empty: 'a t

val of_list_first: (Float.t * 'a) list -> 'a t

val of_list_last: (Float.t * 'a) list -> 'a t

val to_list: 'a t -> (Float.t * 'a) list

val is_empty: 'a t -> bool

val size: 'a t -> int

val add: 'a t -> k:Float.t -> v:'a -> bool * 'a t

val replace: 'a t -> k:Float.t -> v:'a -> 'a t

val remove: 'a t -> k:Float.t -> bool * 'a t

val try_get: 'a t -> k:Float.t -> 'a option

val get: 'a t -> k:Float.t -> 'a

end

end

module StringSortedMap : sig

include module type of SortedMap.Make(String) = sig

type 'a t = 'a SortedMap.Make(String).t

val empty: 'a t

val of_list_first: (String.t * 'a) list -> 'a t

val of_list_last: (String.t * 'a) list -> 'a t

val to_list: 'a t -> (String.t * 'a) list

val is_empty: 'a t -> bool

val size: 'a t -> int

val add: 'a t -> k:String.t -> v:'a -> bool * 'a t

val replace: 'a t -> k:String.t -> v:'a -> 'a t

val remove: 'a t -> k:String.t -> bool * 'a t

val try_get: 'a t -> k:String.t -> 'a option

val get: 'a t -> k:String.t -> 'a

end

end

module CharSortedMap : sig

include module type of SortedMap.Make(Char) = sig

type 'a t = 'a SortedMap.Make(Char).t

val empty: 'a t

val of_list_first: (Char.t * 'a) list -> 'a t

val of_list_last: (Char.t * 'a) list -> 'a t

val to_list: 'a t -> (Char.t * 'a) list

val is_empty: 'a t -> bool

val size: 'a t -> int

val add: 'a t -> k:Char.t -> v:'a -> bool * 'a t

val replace: 'a t -> k:Char.t -> v:'a -> 'a t

val remove: 'a t -> k:Char.t -> bool * 'a t

val try_get: 'a t -> k:Char.t -> 'a option

val get: 'a t -> k:Char.t -> 'a

end

end

module Format : sig

type ('a, 'b, 'c, 'd, 'e, 'f) t = ('a, 'b, 'c, 'd, 'e, 'f) CamlinternalFormatBasics.format6

val with_result: ('b, unit, string, string, string, 'a) t -> f:(string -> 'a) -> 'b

val apply: ('a, unit, string, string, string, string) t -> 'a

val to_string: ('a, 'b, 'c, 'd, 'e, 'f) t -> string

val of_string: ('a, 'b, 'c, 'd, 'e, 'f) t -> ('a, 'b, 'c, 'd, 'e, 'f) t

val concat: ('a, 'b, 'c, 'd, 'e, 'f) t -> ('f, 'b, 'c, 'e, 'g, 'h) t -> ('a, 'b, 'c, 'd, 'g, 'h) t

end

module InChannel : sig

type t = Pervasives.OCamlStandard.Pervasives.in_channel

end

module InFile : sig

type t

val with_file: string -> f:(t -> 'a) -> 'a

val with_channel: string -> f:(InChannel.t -> 'a) -> 'a

val channel: t -> InChannel.t

val seek: t -> pos:int64 -> unit

val pos: t -> int64

val size: t -> int64

end

module OutChannel : sig

type t = Pervasives.OCamlStandard.Pervasives.out_channel

val print: t -> ('a, t, unit, unit, unit, unit) Format.t -> 'a

val output: t -> bytes -> unit

val flush: t -> unit

end

module OutFile : sig

type t

val with_file: string -> f:(t -> 'a) -> 'a

val with_channel: string -> f:(OutChannel.t -> 'a) -> 'a

val channel: t -> OutChannel.t

val seek: t -> pos:int64 -> unit

val pos: t -> int64

val size: t -> int64

end

module StdIn : sig

val channel: InChannel.t

end

module StdOut : sig

val channel: OutChannel.t

val print: ('a, OutChannel.t, unit, unit, unit, unit) Format.t -> 'a

val output: bytes -> unit

val flush: unit -> unit

end

module StdErr : sig

val channel: OutChannel.t

val print: ('a, OutChannel.t, unit, unit, unit, unit) Format.t -> 'a

val output: bytes -> unit

val flush: unit -> unit

end

module Testing : sig

module Result : sig

type t

end

module Test : sig

type t

val run: ?record_backtrace:bool -> t -> Result.t

end

val command_line_main: argv:string list -> Test.t -> Exit.t

val (>::): string -> Test.t list -> Test.t

val (>:): string -> unit lazy_t -> Test.t

val (~:): ('a, unit, string, string, string, unit lazy_t -> Test.t) CamlinternalFormatBasics.format6 -> 'a

val (~::): ('a, unit, string, string, string, Test.t list -> Test.t) CamlinternalFormatBasics.format6 -> 'a

val fail: ('a, unit, string, string, string, 'b) CamlinternalFormatBasics.format6 -> 'a

val expect_exception: expected:exn -> 'a lazy_t -> unit

val expect_exception_named: expected:string -> 'a lazy_t -> unit

val check: repr:('a -> string) -> equal:('a -> 'a -> bool) -> expected:'a -> 'a -> unit

val check_poly: repr:('a -> string) -> expected:'a -> 'a -> unit

val check_string: expected:string -> string -> unit

val check_bool: expected:bool -> bool -> unit

val check_true: bool -> unit

val check_false: bool -> unit

val check_int: expected:int -> int -> unit

val check_float_exact: expected:float -> float -> unit

val check_option: repr:('a -> string) -> equal:('a -> 'a -> bool) -> expected:'a option -> 'a option -> unit

val check_some: repr:('a -> string) -> equal:('a -> 'a -> bool) -> expected:'a -> 'a option -> unit

val check_none: repr:('a -> string) -> equal:('a -> 'a -> bool) -> 'a option -> unit

val check_int_option: expected:int option -> int option -> unit

val check_some_int: expected:int -> int option -> unit

val check_none_int: int option -> unit

val check_string_option: expected:string option -> string option -> unit

val check_some_string: expected:string -> string option -> unit

val check_none_string: string option -> unit

val check_list: repr:('a -> string) -> equal:('a -> 'a -> bool) -> expected:'a list -> 'a list -> unit

val check_string_list: expected:string list -> string list -> unit

val check_int_list: expected:int list -> int list -> unit

end

Modules to be opened

module Standard : sig

This modules defines aliases for all standard modules in General:

module Testing = Testing

module Array = Array

module BigInt = BigInt

module Bool = Bool

module Bytes = Bytes

module CallStack = CallStack

module Char = Char

module Exception = Exception

module Exit = Exit

module Float = Float

module Format = Format

module Function1 = Function1

module Function2 = Function2

module Function3 = Function3

module Function4 = Function4

module Function5 = Function5

module InChannel = InChannel

module InFile = InFile

module Int = Int

module Int32 = Int32

module Int64 = Int64

module Lazy = Lazy

module List = List

module NativeInt = NativeInt

module Option = Option

module OutChannel = OutChannel

module OutFile = OutFile

module Reference = Reference

module SortedMap = SortedMap

module SortedSet = SortedSet

module StdErr = StdErr

module StdIn = StdIn

module StdOut = StdOut

module Stream = Stream

module String = String

module Tuple2 = Tuple2

module Tuple3 = Tuple3

module Tuple4 = Tuple4

module Tuple5 = Tuple5

module Unit = Unit

module IntRange = IntRange

module FloatOption = FloatOption

module IntOption = IntOption

module StringOption = StringOption

module FloatReference = FloatReference

module IntReference = IntReference

module StringReference = StringReference

module FloatList = FloatList

module IntList = IntList

module StringList = StringList

module CharSortedSet = CharSortedSet

module FloatSortedSet = FloatSortedSet

module IntSortedSet = IntSortedSet

module StringSortedSet = StringSortedSet

module CharSortedMap = CharSortedMap

module FloatSortedMap = FloatSortedMap

module IntSortedMap = IntSortedMap

module StringSortedMap = StringSortedMap

It also includes General.Pervasives.

end

module Abbr : sig

This modules defines abbreviated aliases for all standard modules in General:

module Tst = Testing

module Ar = Array

module BigInt = BigInt

module Bo = Bool

module By = Bytes

module CallStack = CallStack

module Ch = Char

module Exit = Exit

module Exn = Exception

module Fl = Float

module Frmt = Format

module Fun1 = Function1

module Fun2 = Function2

module Fun3 = Function3

module Fun4 = Function4

module Fun5 = Function5

module InCh = InChannel

module InFile = InFile

module Int = Int

module Int32 = Int32

module Int64 = Int64

module Laz = Lazy

module Li = List

module NativeInt = NativeInt

module Opt = Option

module OutCh = OutChannel

module OutFile = OutFile

module Ref = Reference

module SoMap = SortedMap

module SoSet = SortedSet

module StdErr = StdErr

module StdIn = StdIn

module StdOut = StdOut

module Str = String

module Strm = Stream

module Tu2 = Tuple2

module Tu3 = Tuple3

module Tu4 = Tuple4

module Tu5 = Tuple5

module Unit = Unit

module IntRa = IntRange

module FlOpt = FloatOption

module IntOpt = IntOption

module StrOpt = StringOption

module FlRef = FloatReference

module IntRef = IntReference

module StrRef = StringReference

module FlLi = FloatList

module IntLi = IntList

module StrLi = StringList

module ChSoSet = CharSortedSet

module FlSoSet = FloatSortedSet

module IntSoSet = IntSortedSet

module StrSoSet = StringSortedSet

module ChSoMap = CharSortedMap

module FlSoMap = FloatSortedMap

module IntSoMap = IntSortedMap

module StrSoMap = StringSortedMap

It also includes General.Pervasives.

end

end