# Module type Container_intf.Container

    module type Container = sig .. end

    module type S0 = Container_intf.S0

    module type S0_phantom = Container_intf.S0_phantom

    module type S1 = Container_intf.S1

    module type S1_phantom_invariant = Container_intf.S1_phantom_invariant

    module type S1_phantom = Container_intf.S1_phantom

    module type S1_permissions = Container_intf.S1_permissions

    module type Generic = Container_intf.Generic

    module type Generic_phantom = Container_intf.Generic_phantom

Generic definitions of container operations in terms of `fold`.

E.g.: `iter ~fold t ~f = fold t ~init:() ~f:(fun () a -> f a)`.

    type ('t, 'a, 'accum) fold = 't -> init:'accum -> f:('accum -> 'a -> 'accum) -> 'accum

    type ('t, 'a) iter = 't -> f:('a -> unit) -> unit

    val iter : fold:('t, 'a, unit) fold ->
           ('t, 'a) iter

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

    val min_elt : fold:('t, 'a, 'a option) fold ->
           't -> cmp:('a -> 'a -> int) -> 'a option

    val max_elt : fold:('t, 'a, 'a option) fold ->
           't -> cmp:('a -> 'a -> int) -> 'a option

    val length : fold:('t, 'a, int) fold -> 't -> int

    val to_list : fold:('t, 'a, 'a list) fold -> 't -> 'a list

    val to_array : fold:('t, 'a, 'a list) fold -> 't -> 'a array

    val sum : fold:('t, 'a, 'sum) fold ->
           (module Commutative_group.S with type t = 'sum) ->
           't -> f:('a -> 'sum) -> 'sum

    val is_empty : iter:('t, 'a) iter -> 't -> bool

Generic definitions of container operations in terms of `iter`.

    val exists : iter:('t, 'a) iter -> 't -> f:('a -> bool) -> bool

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

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

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

    module Make: functor (T : Container_intf.Make_arg) -> S1  with type 'a t := 'a T.t

The idiom for using `Container.Make` is to bind the resulting module and to explicitly import each of the functions that one wants: