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
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
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:
Container.Make
is to bind the resulting module and to
explicitly import each of the functions that one wants: