module type T = sig .. end
type 'a t
val fold : 'a t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val fold_count : ('a -> init:int -> f:(int -> 'b -> int) -> 'c) -> 'a -> f:('b -> bool) -> 'c
module Make : 
functor (T : T) -> sig .. end
The idiom for using Container.Make is to bind the resulting module and to explicitly import each of the functions that one wants:
      module C = Container.Make (struct ... end)
      let count    = C.count
      let exists   = C.exists
      let find     = C.find
      ...

This is preferable to:

      include Container.Make (struct ... end)

because the include makes it to easy to shadow specialized implementations of container functions (length being a common one).

Container.Make implements iter in terms of fold, which is often slower than implementing iter directly.

val fold : 'a T.t -> init:'b -> f:('b -> 'a -> 'b) -> 'b
val count : 'a T.t -> f:('a -> bool) -> int
val iter : 'a T.t -> f:('a -> unit) -> unit
val length : 'a T.t -> int
val is_empty : 'a T.t -> bool
val exists : 'a T.t -> f:('a -> bool) -> bool
val mem : ?equal:('a -> 'a -> bool) -> 'a T.t -> 'a -> bool
val for_all : 'a T.t -> f:('a -> bool) -> bool
val find_map : 'a T.t -> f:('a -> 'b option) -> 'b option
val find : 'a T.t -> f:('a -> bool) -> 'a option
val to_list : 'a T.t -> 'a list
val to_array : 'a T.t -> 'a array
module type S0 = sig .. end
type t
type elt
val mem : ?equal:(elt -> elt -> bool) -> t -> elt -> bool
Checks whether the provided element is there using the default equality test, using the provided equal function if it is not
val length : t -> int
val is_empty : t -> bool
val iter : t -> f:(elt -> unit) -> unit
val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t
val exists : t -> f:(elt -> bool) -> bool
Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.
val for_all : t -> f:(elt -> bool) -> bool
Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.
val count : t -> f:(elt -> bool) -> int
Returns the number of elements for which the provided function evaluates to true.
val find : t -> f:(elt -> bool) -> elt option
Returns as an option the first element for which f evaluates to true.
val find_map : t -> f:(elt -> 'a option) -> 'a option
Returns the first evaluation of f that returns Some, and returns None if there is no such element.
val to_list : t -> elt list
val to_array : t -> elt array
module type S0_phantom = sig .. end
type elt
type 'a t
val mem : ?equal:(elt -> elt -> bool) -> 'a t -> elt -> bool
Checks whether the provided element is there using the default equality test, using the provided equal function if it is not
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:(elt -> unit) -> unit
val fold : 'a t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t
val exists : 'a t -> f:(elt -> bool) -> bool
Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.
val for_all : 'a t -> f:(elt -> bool) -> bool
Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.
val count : 'a t -> f:(elt -> bool) -> int
Returns the number of elements for which the provided function evaluates to true.
val find : 'a t -> f:(elt -> bool) -> elt option
Returns as an option the first element for which f evaluates to true.
val find_map : 'b t -> f:(elt -> 'a option) -> 'a option
Returns the first evaluation of f that returns Some, and returns None if there is no such element.
val to_list : 'a t -> elt list
val to_array : 'a t -> elt array
module type S1 = sig .. end
type 'a t
val mem : ?equal:('a -> 'a -> bool) -> 'a t -> 'a -> bool
Checks whether the provided element is there, using polymorphic compare if equal is not provided
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a -> unit) -> unit
val fold : 'a t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t
val exists : 'a t -> f:('a -> bool) -> bool
Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.
val for_all : 'a t -> f:('a -> bool) -> bool
Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.
val count : 'a t -> f:('a -> bool) -> int
Returns the number of elements for which the provided function evaluates to true.
val find : 'a t -> f:('a -> bool) -> 'a option
Returns as an option the first element for which f evaluates to true.
val find_map : 'a t -> f:('a -> 'b option) -> 'b option
Returns the first evaluation of f that returns Some, and returns None if there is no such element.
val to_list : 'a t -> 'a list
val to_array : 'a t -> 'a array
module type S1_phantom = sig .. end
type ('a, +'phantom) t
val mem : ?equal:('a -> 'a -> bool) -> ('a, 'b) t -> 'a -> bool
Checks whether the provided element is there, using polymorphic compare if equal is not provided
val length : ('a, 'b) t -> int
val is_empty : ('a, 'b) t -> bool
val iter : ('a, 'b) t -> f:('a -> unit) -> unit
val fold : ('a, 'b) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t
val exists : ('a, 'b) t -> f:('a -> bool) -> bool
Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.
val for_all : ('a, 'b) t -> f:('a -> bool) -> bool
Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.
val count : ('a, 'b) t -> f:('a -> bool) -> int
Returns the number of elements for which the provided function evaluates to true.
val find : ('a, 'b) t -> f:('a -> bool) -> 'a option
Returns as an option the first element for which f evaluates to true.
val find_map : ('a, 'c) t -> f:('a -> 'b option) -> 'b option
Returns the first evaluation of f that returns Some, and returns None if there is no such element.
val to_list : ('a, 'b) t -> 'a list
val to_array : ('a, 'b) t -> 'a array
module type S1_phantom_invariant = sig .. end
type ('a, 'phantom) t
val mem : ?equal:('a -> 'a -> bool) -> ('a, 'b) t -> 'a -> bool
Checks whether the provided element is there, using polymorphic compare if equal is not provided
val length : ('a, 'b) t -> int
val is_empty : ('a, 'b) t -> bool
val iter : ('a, 'b) t -> f:('a -> unit) -> unit
val fold : ('a, 'b) t -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum
fold t ~init ~f returns f (... f (f (f init e1) e2) e3 ...) en, where e1..en are the elements of t
val exists : ('a, 'b) t -> f:('a -> bool) -> bool
Returns true if and only if there exists an element for which the provided function evaluates to true. This is a short-circuiting operation.
val for_all : ('a, 'b) t -> f:('a -> bool) -> bool
Returns true if and only if the provided function evaluates to true for all elements. This is a short-circuiting operation.
val count : ('a, 'b) t -> f:('a -> bool) -> int
Returns the number of elements for which the provided function evaluates to true.
val find : ('a, 'b) t -> f:('a -> bool) -> 'a option
Returns as an option the first element for which f evaluates to true.
val find_map : ('a, 'c) t -> f:('a -> 'b option) -> 'b option
Returns the first evaluation of f that returns Some, and returns None if there is no such element.
val to_list : ('a, 'b) t -> 'a list
val to_array : ('a, 'b) t -> 'a array
module type Generic = sig .. end
type 'a t
type 'a elt
val mem : ?equal:('a elt -> 'a elt -> bool) -> 'a t -> 'a elt -> bool
val length : 'a t -> int
val is_empty : 'a t -> bool
val iter : 'a t -> f:('a elt -> unit) -> unit
val fold : 'a t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum
val exists : 'a t -> f:('a elt -> bool) -> bool
val for_all : 'a t -> f:('a elt -> bool) -> bool
val count : 'a t -> f:('a elt -> bool) -> int
val find : 'a t -> f:('a elt -> bool) -> 'a elt option
val find_map : 'a t -> f:('a elt -> 'b option) -> 'b option
val to_list : 'a t -> 'a elt list
val to_array : 'a t -> 'a elt array
module type Generic_phantom = sig .. end
type ('a, 'phantom) t
type 'a elt
val mem : ?equal:('a elt -> 'a elt -> bool) -> ('a, 'b) t -> 'a elt -> bool
val length : ('a, 'b) t -> int
val is_empty : ('a, 'b) t -> bool
val iter : ('a, 'b) t -> f:('a elt -> unit) -> unit
val fold : ('a, 'b) t -> init:'accum -> f:('accum -> 'a elt -> 'accum) -> 'accum
val exists : ('a, 'b) t -> f:('a elt -> bool) -> bool
val for_all : ('a, 'b) t -> f:('a elt -> bool) -> bool
val count : ('a, 'b) t -> f:('a elt -> bool) -> int
val find : ('a, 'b) t -> f:('a elt -> bool) -> 'a elt option
val find_map : ('a, 'c) t -> f:('a elt -> 'b option) -> 'b option
val to_list : ('a, 'b) t -> 'a elt list
val to_array : ('a, 'b) t -> 'a elt array
module Check : 
functor (T : T.T1) ->
functor (Elt : T.T1) ->
functor (M : Generic with type t := 'a T.t with type elt := 'a Elt.t) -> sig .. end
module Check_S0 : 
functor (M : S0) -> Check(sig .. end)(sig .. end)(M)
module Check_S0_phantom : 
functor (M : S0_phantom) -> Check(sig .. end)(sig .. end)(M)
module Check_S1 : 
functor (M : S1) -> Check(sig .. end)(sig .. end)(M)
type phantom
module Check_S1_phantom : 
functor (M : S1_phantom) -> Check(sig .. end)(sig .. end)(M)
module Check_S1_phantom_invariant : 
functor (M : S1_phantom_invariant) -> Check(sig .. end)(sig .. end)(M)