Module Std_kernel.Container

module Container: Container

module type T = sig .. end
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 type S0 = sig .. end
module type S0_phantom = sig .. end
module type S1 = sig .. end
module type S1_phantom = sig .. end
module type S1_phantom_invariant = sig .. end
module type Generic = sig .. end
module type Generic_phantom = sig .. end
module Check: 
functor (T : T.T1) ->
functor (Elt : T.T1) ->
functor (M : Generic with type 'a t := 'a T.t with type 'a elt := 'a Elt.t) -> sig .. end
module Check_S0: 
functor (M : S0) -> Check(sig
type 'a t = M.t 
end)(sig
type 'a t = M.elt 
end)(M)
module Check_S0_phantom: 
functor (M : S0_phantom) -> Check(sig
type 'a t = 'a M.t 
end)(sig
type 'a t = M.elt 
end)(M)
module Check_S1: 
functor (M : S1) -> Check(sig
type 'a t = 'a M.t 
end)(sig
type 'a t = 'a 
end)(M)
type phantom 
module Check_S1_phantom: 
functor (M : S1_phantom) -> Check(sig
type 'a t = ('a, Container.phantom) M.t 
end)(sig
type 'a t = 'a 
end)(M)
module Check_S1_phantom_invariant: 
functor (M : S1_phantom_invariant) -> Check(sig
type 'a t = ('a, Container.phantom) M.t 
end)(sig
type 'a t = 'a 
end)(M)

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.