package core_kernel

  1. Overview
  2. Docs
package core_kernel
Legend:
Library
Module
Module type
Parameter
Class
Class type

Provides generic signatures for container data structures.

These signatures include functions (iter, fold, exists, for_all, ...) that you would expect to find in any container. Used by including Container.S0 or Container.S1 in the signature for every container-like data structure (Array, List, String, ...) to ensure a consistent interface.

These signatures extend signatures exported by Base.Container_intf.

include module type of struct include Base.Container end
module Continue_or_stop = Base.Container.Continue_or_stop

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 = Base.Container.S0
module type S0_phantom = Base.Container.S0_phantom
module type S1 = Base.Container.S1
module type S1_phantom_invariant = Base.Container.S1_phantom_invariant
module type S1_phantom = Base.Container.S1_phantom
module type Generic = Base.Container.Generic
module type Generic_phantom = Base.Container.Generic_phantom
module type Summable = Base.Container.Summable

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
type 't length = 't -> int
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 sum : fold:('t, 'a, 'sum) fold -> (module Summable with type t = 'sum) -> 't -> f:('a -> 'sum) -> 'sum
val fold_result : fold:('t, 'a, 'b) fold -> init:'b -> f:('b -> 'a -> ('b, 'e) Base.Result.t) -> 't -> ('b, 'e) Base.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 and length.

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
val to_array : length:'t length -> iter:('t, 'a) iter -> 't -> 'a array
module Make = Base.Container.Make

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 = Base.Container.Make0
module type S1_permissions = Container_intf.S1_permissions
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