package base

  1. Overview
  2. Docs
package base
Legend:
Library
Module
Module type
Parameter
Class
Class type
module Continue_or_stop : sig ... end

Continue_or_stop.t is used by the f argument to fold_until in order to indicate whether folding should continue, or stop early.

module type S0 = sig ... end
module type S0_phantom = sig ... end
module type S1 = sig ... end
module type S1_phantom_invariant = sig ... end
module type S1_phantom = sig ... end
module type Generic = sig ... end
module type Generic_phantom = sig ... end

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 -> compare:('a -> 'a -> int) -> 'a option
val max_elt : fold:('t, 'a, 'a option) fold -> 't -> compare:('a -> 'a -> int) -> 'a option
val length : fold:('t, _, 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 fold_result : fold:('t, 'a, 'b) fold -> init:'b -> f:('b -> 'a -> ('b, 'e) Result.t) -> 't -> ('b, 'e) Result.t
val fold_until : fold:('t, 'a, 'b) fold -> init:'b -> f:('b -> 'a -> ('b, 'final) Continue_or_stop.t) -> finish:('b -> 'final) -> 't -> 'final
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 (T : sig ... end) : 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:

module Make0 (T : sig ... end) : S0 with type t := T.t and type elt := T.Elt.t
OCaml

Innovation. Community. Security.

GitHub Discord Twitter Peertube RSS
About
Changelog Releases Industrial Users Academic Users Why OCaml
Ecosystem
Packages Community Events OCaml Planet Jobs
Resources
Install OCaml Get Started Platform Tools Language Manual Standard Library API Books Exercises Papers OCaml Playground Logo
Policies
Carbon Footprint Governance Privacy Code of Conduct