From f6559e0a70f8f36f49b2da4a08f108cd46f0ae59 Mon Sep 17 00:00:00 2001 From: c-cube Date: Fri, 2 Apr 2021 02:24:56 +0000 Subject: [PATCH] deploy: 739dd4412c1af1c170ecdc9b42f427eea89cba2a --- dev/containers/CCCanonical_sexp/index.html | 2 +- dev/containers/CCChar/Infix/index.html | 2 +- dev/containers/CCChar/index.html | 2 +- dev/containers/CCFormat/index.html | 2 +- dev/containers/CCHashtbl/Poly/index.html | 2 +- dev/containers/CCHashtbl/index.html | 2 +- dev/containers/CCHashtbl/module-type-S/index.html | 2 +- dev/containers/CCList/index.html | 4 ++-- dev/containers/CCListLabels/index.html | 4 ++-- dev/containers/CCMap/module-type-S/index.html | 2 +- dev/containers/CCSeq/index.html | 2 +- dev/containers/CCSexp/Decoder/index.html | 2 +- dev/containers/CCSexp/Make/Decoder/index.html | 2 +- dev/containers/CCSexp/Make/index.html | 2 +- dev/containers/CCSexp/index.html | 2 +- dev/containers/CCSexp/module-type-S/Decoder/index.html | 2 +- dev/containers/CCSexp/module-type-S/index.html | 2 +- .../CCSexp_intf/module-type-BASIC_SEXP/index.html | 2 +- dev/containers/CCSexp_intf/module-type-S/Decoder/index.html | 2 +- dev/containers/CCSexp_intf/module-type-S/index.html | 2 +- dev/containers/CCString/index.html | 2 +- dev/containers/CCStringLabels/index.html | 2 +- dev/containers/Containers/Hashtbl/index.html | 2 +- dev/containers/Containers/Hashtbl/module-type-S'/index.html | 2 +- dev/containers/ContainersLabels/Hashtbl/index.html | 2 +- .../ContainersLabels/Hashtbl/module-type-S'/index.html | 2 +- dev/index.html | 6 +++--- 27 files changed, 31 insertions(+), 31 deletions(-) diff --git a/dev/containers/CCCanonical_sexp/index.html b/dev/containers/CCCanonical_sexp/index.html index 111bd39b..2ae09eee 100644 --- a/dev/containers/CCCanonical_sexp/index.html +++ b/dev/containers/CCCanonical_sexp/index.html @@ -1,2 +1,2 @@ -CCCanonical_sexp (containers.CCCanonical_sexp)

Module CCCanonical_sexp

Canonical S-expressions

See wikipedia. These S-expressions are binary safe.

since
NEXT_RELEASE
type 'a or_error = ('a, string) Stdlib.result
type 'a gen = unit -> 'a option
module type S = CCSexp_intf.S0
module Make : functor (Sexp : SEXP) -> S with type t = Sexp.t

Basics

type t = [
| `Atom of string
| `List of t list
]

A simple, structural representation of S-expressions. Compatible with CCSexp.

include S with type S.t := t
type t
type sexp = t

Re-exports

val atom : string -> t

Make an atom out of this string.

since
2.8
val list : t list -> t

Make a Sexpr of this list.

since
2.8

Constructors

val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t

Reverse the list.

val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t

of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.

val of_field : string -> t -> t

Used to represent one record field.

val of_record : (string * t) list -> t

Represent a record by its named fields.

Printing

val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit

Print the given iter of expressions to a file.

val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit

Pretty-printer nice on human eyes (including indentation).

val pp_noindent : Stdlib.Format.formatter -> t -> unit

Raw, direct printing as compact as possible.

Parsing

val parse_string : string -> t CCSexp_intf.or_error

Parse a string.

val parse_string_list : string -> t list CCSexp_intf.or_error

Parse a string into a list of S-exprs.

since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error

Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).

val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen

Parse a channel into a generator of S-expressions.

val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error

Open the file and read a S-exp from it.

val parse_file_list : string -> t list CCSexp_intf.or_error

Open the file and read a S-exp from it.

val equal : t -> t -> bool
val compare : t -> t -> int
val atom : string -> t
\ No newline at end of file +CCCanonical_sexp (containers.CCCanonical_sexp)

Module CCCanonical_sexp

Canonical S-expressions

See wikipedia. These S-expressions are binary safe.

since
3.3
type 'a or_error = ('a, string) Stdlib.result
type 'a gen = unit -> 'a option
module type S = CCSexp_intf.S0
module Make : functor (Sexp : SEXP) -> S with type t = Sexp.t

Basics

type t = [
| `Atom of string
| `List of t list
]

A simple, structural representation of S-expressions. Compatible with CCSexp.

include S with type S.t := t
type t
type sexp = t

Re-exports

val atom : string -> t

Make an atom out of this string.

since
2.8
val list : t list -> t

Make a Sexpr of this list.

since
2.8

Constructors

val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t

Reverse the list.

val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t

of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.

val of_field : string -> t -> t

Used to represent one record field.

val of_record : (string * t) list -> t

Represent a record by its named fields.

Printing

val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit

Print the given iter of expressions to a file.

val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit

Pretty-printer nice on human eyes (including indentation).

val pp_noindent : Stdlib.Format.formatter -> t -> unit

Raw, direct printing as compact as possible.

Parsing

val parse_string : string -> t CCSexp_intf.or_error

Parse a string.

val parse_string_list : string -> t list CCSexp_intf.or_error

Parse a string into a list of S-exprs.

since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error

Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).

val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen

Parse a channel into a generator of S-expressions.

val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error

Open the file and read a S-exp from it.

val parse_file_list : string -> t list CCSexp_intf.or_error

Open the file and read a S-exp from it.

val equal : t -> t -> bool
val compare : t -> t -> int
val atom : string -> t
\ No newline at end of file diff --git a/dev/containers/CCChar/Infix/index.html b/dev/containers/CCChar/Infix/index.html index 80d9c93a..ea861d77 100644 --- a/dev/containers/CCChar/Infix/index.html +++ b/dev/containers/CCChar/Infix/index.html @@ -1,2 +1,2 @@ -Infix (containers.CCChar.Infix)

Module CCChar.Infix

val (=) : t -> t -> bool
since
NEXT_RELEASE
val (<>) : t -> t -> bool
since
NEXT_RELEASE
val (<) : t -> t -> bool
since
NEXT_RELEASE
val (>) : t -> t -> bool
since
NEXT_RELEASE
val (<=) : t -> t -> bool
since
NEXT_RELEASE
val (>=) : t -> t -> bool
since
NEXT_RELEASE
\ No newline at end of file +Infix (containers.CCChar.Infix)

Module CCChar.Infix

val (=) : t -> t -> bool
since
3.3
val (<>) : t -> t -> bool
since
3.3
val (<) : t -> t -> bool
since
3.3
val (>) : t -> t -> bool
since
3.3
val (<=) : t -> t -> bool
since
3.3
val (>=) : t -> t -> bool
since
3.3
\ No newline at end of file diff --git a/dev/containers/CCChar/index.html b/dev/containers/CCChar/index.html index 0062ffc2..757e56cd 100644 --- a/dev/containers/CCChar/index.html +++ b/dev/containers/CCChar/index.html @@ -1,2 +1,2 @@ -CCChar (containers.CCChar)

Module CCChar

Utils around char

since
0.14

Documentation for the standard Char module

include module type of sig ... end
val code : char -> int
val chr : int -> char
val escaped : char -> string
val lowercase : char -> char
val uppercase : char -> char
val lowercase_ascii : char -> char
val uppercase_ascii : char -> char
type t = char
val compare : t -> t -> int
val equal : t -> t -> bool
val unsafe_chr : int -> char
val compare : t -> t -> int

The comparison function for characters, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Char to be passed as argument to the functors Set.Make and Map.Make.

val of_int_exn : int -> t

Alias to Char.chr. Return the character with the given ASCII code.

raises Invalid_argument

if the int is not within 0 … 255.

since
1.0
val of_int : int -> t option

Safe version of of_int_exn.

since
1.0
val to_int : t -> int

Alias to Char.code. Return the ASCII code of the argument.

since
1.0
val to_string : t -> string

to_string c returns a string containing c

since
2.7
val pp_buf : Stdlib.Buffer.t -> t -> unit

Renamed from pp since 2.0.

val pp : Stdlib.Format.formatter -> t -> unit

Renamed from print since 2.0.

Infix Operators

since
NEXT_RELEASE
module Infix : sig ... end
include module type of Infix
val (=) : t -> t -> bool
since
NEXT_RELEASE
val (<>) : t -> t -> bool
since
NEXT_RELEASE
val (<) : t -> t -> bool
since
NEXT_RELEASE
val (>) : t -> t -> bool
since
NEXT_RELEASE
val (<=) : t -> t -> bool
since
NEXT_RELEASE
val (>=) : t -> t -> bool
since
NEXT_RELEASE
\ No newline at end of file +CCChar (containers.CCChar)

Module CCChar

Utils around char

since
0.14

Documentation for the standard Char module

include module type of sig ... end
val code : char -> int
val chr : int -> char
val escaped : char -> string
val lowercase : char -> char
val uppercase : char -> char
val lowercase_ascii : char -> char
val uppercase_ascii : char -> char
type t = char
val compare : t -> t -> int
val equal : t -> t -> bool
val unsafe_chr : int -> char
val compare : t -> t -> int

The comparison function for characters, with the same specification as Stdlib.compare. Along with the type t, this function compare allows the module Char to be passed as argument to the functors Set.Make and Map.Make.

val of_int_exn : int -> t

Alias to Char.chr. Return the character with the given ASCII code.

raises Invalid_argument

if the int is not within 0 … 255.

since
1.0
val of_int : int -> t option

Safe version of of_int_exn.

since
1.0
val to_int : t -> int

Alias to Char.code. Return the ASCII code of the argument.

since
1.0
val to_string : t -> string

to_string c returns a string containing c

since
2.7
val pp_buf : Stdlib.Buffer.t -> t -> unit

Renamed from pp since 2.0.

val pp : Stdlib.Format.formatter -> t -> unit

Renamed from print since 2.0.

Infix Operators

since
3.3
module Infix : sig ... end
include module type of Infix
val (=) : t -> t -> bool
since
3.3
val (<>) : t -> t -> bool
since
3.3
val (<) : t -> t -> bool
since
3.3
val (>) : t -> t -> bool
since
3.3
val (<=) : t -> t -> bool
since
3.3
val (>=) : t -> t -> bool
since
3.3
\ No newline at end of file diff --git a/dev/containers/CCFormat/index.html b/dev/containers/CCFormat/index.html index 8d9d6af8..f23d5513 100644 --- a/dev/containers/CCFormat/index.html +++ b/dev/containers/CCFormat/index.html @@ -1,5 +1,5 @@ -CCFormat (containers.CCFormat)

Module CCFormat

Helpers for Format

since
0.8
type 'a iter = ('a -> unit) -> unit

Documentation for the standard Format module

include module type of sig ... end
type formatter = Stdlib__format.formatter
val pp_open_box : formatter -> int -> unit
val open_box : int -> unit
val pp_close_box : formatter -> unit -> unit
val close_box : unit -> unit
val pp_open_hbox : formatter -> unit -> unit
val open_hbox : unit -> unit
val pp_open_vbox : formatter -> int -> unit
val open_vbox : int -> unit
val pp_open_hvbox : formatter -> int -> unit
val open_hvbox : int -> unit
val pp_open_hovbox : formatter -> int -> unit
val open_hovbox : int -> unit
val pp_print_string : formatter -> string -> unit
val print_string : string -> unit
val pp_print_as : formatter -> int -> string -> unit
val print_as : int -> string -> unit
val pp_print_int : formatter -> int -> unit
val print_int : int -> unit
val pp_print_float : formatter -> float -> unit
val print_float : float -> unit
val pp_print_char : formatter -> char -> unit
val print_char : char -> unit
val pp_print_bool : formatter -> bool -> unit
val print_bool : bool -> unit
val pp_print_space : formatter -> unit -> unit
val print_space : unit -> unit
val pp_print_cut : formatter -> unit -> unit
val print_cut : unit -> unit
val pp_print_break : formatter -> int -> int -> unit
val print_break : int -> int -> unit
val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit
val pp_force_newline : formatter -> unit -> unit
val force_newline : unit -> unit
val pp_print_if_newline : formatter -> unit -> unit
val print_if_newline : unit -> unit
val pp_print_flush : formatter -> unit -> unit
val print_flush : unit -> unit
val pp_print_newline : formatter -> unit -> unit
val print_newline : unit -> unit
val pp_set_margin : formatter -> int -> unit
val set_margin : int -> unit
val pp_get_margin : formatter -> unit -> int
val get_margin : unit -> int
val pp_set_max_indent : formatter -> int -> unit
val set_max_indent : int -> unit
val pp_get_max_indent : formatter -> unit -> int
val get_max_indent : unit -> int
type geometry = Stdlib__format.geometry = {
max_indent : int;
margin : int;
}
val check_geometry : geometry -> bool
val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit
val set_geometry : max_indent:int -> margin:int -> unit
val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit
val safe_set_geometry : max_indent:int -> margin:int -> unit
val pp_update_geometry : formatter -> (geometry -> geometry) -> unit
val update_geometry : (geometry -> geometry) -> unit
val pp_get_geometry : formatter -> unit -> geometry
val get_geometry : unit -> geometry
val pp_set_max_boxes : formatter -> int -> unit
val set_max_boxes : int -> unit
val pp_get_max_boxes : formatter -> unit -> int
val get_max_boxes : unit -> int
val pp_over_max_boxes : formatter -> unit -> bool
val over_max_boxes : unit -> bool
val pp_open_tbox : formatter -> unit -> unit
val open_tbox : unit -> unit
val pp_close_tbox : formatter -> unit -> unit
val close_tbox : unit -> unit
val pp_set_tab : formatter -> unit -> unit
val set_tab : unit -> unit
val pp_print_tab : formatter -> unit -> unit
val print_tab : unit -> unit
val pp_print_tbreak : formatter -> int -> int -> unit
val print_tbreak : int -> int -> unit
val pp_set_ellipsis_text : formatter -> string -> unit
val set_ellipsis_text : string -> unit
val pp_get_ellipsis_text : formatter -> unit -> string
val get_ellipsis_text : unit -> string
type stag = Stdlib__format.stag = ..
type tag = string
type stag += String_tag of tag
val pp_open_stag : formatter -> stag -> unit
val open_stag : stag -> unit
val pp_close_stag : formatter -> unit -> unit
val close_stag : unit -> unit
val pp_set_tags : formatter -> bool -> unit
val set_tags : bool -> unit
val pp_set_print_tags : formatter -> bool -> unit
val set_print_tags : bool -> unit
val pp_set_mark_tags : formatter -> bool -> unit
val set_mark_tags : bool -> unit
val pp_get_print_tags : formatter -> unit -> bool
val get_print_tags : unit -> bool
val pp_get_mark_tags : formatter -> unit -> bool
val get_mark_tags : unit -> bool
val pp_set_formatter_out_channel : formatter -> Stdlib.out_channel -> unit
val set_formatter_out_channel : Stdlib.out_channel -> unit
val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit
val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit
val pp_get_formatter_output_functions : formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit)
val get_formatter_output_functions : unit -> (string -> int -> int -> unit) * (unit -> unit)
type formatter_out_functions = Stdlib__format.formatter_out_functions = {
out_string : string -> int -> int -> unit;
out_flush : unit -> unit;
out_newline : unit -> unit;
out_spaces : int -> unit;
out_indent : int -> unit;
}
val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit
val set_formatter_out_functions : formatter_out_functions -> unit
val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions
val get_formatter_out_functions : unit -> formatter_out_functions
type formatter_stag_functions = Stdlib__format.formatter_stag_functions = {
mark_open_stag : stag -> string;
mark_close_stag : stag -> string;
print_open_stag : stag -> unit;
print_close_stag : stag -> unit;
}
val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit
val set_formatter_stag_functions : formatter_stag_functions -> unit
val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions
val get_formatter_stag_functions : unit -> formatter_stag_functions
val formatter_of_out_channel : Stdlib.out_channel -> formatter
val std_formatter : formatter
val err_formatter : formatter
val formatter_of_buffer : Stdlib.Buffer.t -> formatter
val stdbuf : Stdlib.Buffer.t
val str_formatter : formatter
val flush_str_formatter : unit -> string
val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter
val formatter_of_out_functions : formatter_out_functions -> formatter
type symbolic_output_item = Stdlib__format.symbolic_output_item =
| Output_flush
| Output_newline
| Output_string of string
| Output_spaces of int
| Output_indent of int
type symbolic_output_buffer = Stdlib__format.symbolic_output_buffer
val make_symbolic_output_buffer : unit -> symbolic_output_buffer
val clear_symbolic_output_buffer : symbolic_output_buffer -> unit
val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list
val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list
val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit
val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter
val pp_print_list : ?⁠pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit
val pp_print_text : formatter -> string -> unit
val pp_print_option : ?⁠none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit
val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) Stdlib.result -> unit
val fprintf : formatter -> ('a, formatter, unit) Stdlib.format -> 'a
val printf : ('a, formatter, unit) Stdlib.format -> 'a
val eprintf : ('a, formatter, unit) Stdlib.format -> 'a
val sprintf : ('a, unit, string) Stdlib.format -> 'a
val asprintf : ('a, formatter, unit, string) Stdlib.format4 -> 'a
val dprintf : ('a, formatter, unit, formatter -> unit) Stdlib.format4 -> 'a
val ifprintf : formatter -> ('a, formatter, unit) Stdlib.format -> 'a
val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) Stdlib.format4 -> 'b
val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val bprintf : Stdlib.Buffer.t -> ('a, formatter, unit) Stdlib.format -> 'a
val kprintf : (string -> 'a) -> ('b, unit, string, 'a) Stdlib.format4 -> 'b
val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit
val get_all_formatter_output_functions : unit -> (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)
val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit
val pp_get_all_formatter_output_functions : formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)
val pp_open_tag : formatter -> tag -> unit
val open_tag : tag -> unit
val pp_close_tag : formatter -> unit -> unit
val close_tag : unit -> unit
type formatter_tag_functions = Stdlib__format.formatter_tag_functions = {
mark_open_tag : tag -> string;
mark_close_tag : tag -> string;
print_open_tag : tag -> unit;
print_close_tag : tag -> unit;
}
val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit
val set_formatter_tag_functions : formatter_tag_functions -> unit
val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions
val get_formatter_tag_functions : unit -> formatter_tag_functions
type t = Stdlib.Format.formatter
type 'a printer = t -> 'a -> unit

Combinators

val silent : 'a printer

Prints nothing.

val unit : unit printer

Prints "()".

val int : int printer
val string : string printer
val bool : bool printer
val float3 : float printer
val float : float printer
val exn : exn printer

Printer using Printexc.to_string.

since
3.0
val space : unit printer

Alias to pp_print_space.

since
3.2
val cut : unit printer

Alias to pp_print_cut.

since
3.2
val break : (int * int) printer

Tuple-ized printer form of pp_print_break.

since
3.2
val newline : unit printer

Force newline (see Format.pp_force_newline).

since
1.2
val substring : (string * int * int) printer

substring (s,i,len) prints the substring (s,i,len), where i is the offset in s and len the number of bytes in the substring.

raises Invalid_argument

if the triple (s,i,len) does not describe a proper substring.

since
1.2
val text : string printer

Print string, but replacing spaces with breaks and newlines with newline. See pp_print_text on recent versions of OCaml.

since
1.2
val string_lines : string printer

string_lines out s prints s with all newlines ('\n') replaced by a cut, in a vertical box. It does NOT insert breakable spaces in place of spaces, unlike text. This means an already formatted string can be displayed inside another formatter without mangling the indentation.

since
NEXT_RELEASE
val char : char printer
since
0.14
val int32 : int32 printer
since
0.14
val int64 : int64 printer
since
0.14
val nativeint : nativeint printer
since
0.14
val flush : unit printer

Alias to Format.pp_print_flush.

since
1.2
val string_quoted : string printer

Similar to CCString.print.

since
0.14
val list : ?⁠sep:unit printer -> 'a printer -> 'a list printer
val array : ?⁠sep:unit printer -> 'a printer -> 'a array printer
val arrayi : ?⁠sep:unit printer -> (int * 'a) printer -> 'a array printer
val seq : ?⁠sep:unit printer -> 'a printer -> 'a Stdlib.Seq.t printer
val iter : ?⁠sep:unit printer -> 'a printer -> 'a iter printer
val opt : 'a printer -> 'a option printer

opt pp prints options as follows:

  • Some x will become "some foo" if pp x ---> "foo".
  • None will become "none".
val pair : ?⁠sep:unit printer -> 'a printer -> 'b printer -> ('a * 'b) printer
val triple : ?⁠sep:unit printer -> 'a printer -> 'b printer -> 'c printer -> ('a * 'b * 'c) printer
val quad : ?⁠sep:unit printer -> 'a printer -> 'b printer -> 'c printer -> 'd printer -> ('a * 'b * 'c * 'd) printer
val append : unit printer -> unit printer -> unit printer

append ppa ppb first prints ppa (), then prints ppb ().

since
3.2
val append_l : unit printer list -> unit printer

append_l pps runs the printers in pps sequentially.

since
3.2
val within : string -> string -> 'a printer -> 'a printer

within a b p wraps p inside the strings a and b. Convenient, for instances, for brackets, parenthesis, quotes, etc.

since
0.17
val map : ('a -> 'b) -> 'b printer -> 'a printer
val vbox : ?⁠i:int -> 'a printer -> 'a printer

Wrap the printer in a vertical box.

parameter i

level of indentation within the box (default 0).

since
0.16
val hvbox : ?⁠i:int -> 'a printer -> 'a printer

Wrap the printer in a horizontal/vertical box.

parameter i

level of indentation within the box (default 0).

since
0.16
val hovbox : ?⁠i:int -> 'a printer -> 'a printer

Wrap the printer in a horizontal or vertical box.

parameter i

level of indentation within the box (default 0).

since
0.16
val hbox : 'a printer -> 'a printer

Wrap the printer in an horizontal box.

since
0.16
val return : ('a, _, _, 'a) Stdlib.format4 -> unit printer

return "some_format_string" takes a argument-less format string and returns a printer actionable by (). Examples:

  • return ",@ "
  • return "@{<Red>and then@}@,"
  • return "@[<v>a@ b@]"
since
1.0
val of_to_string : ('a -> string) -> 'a printer

of_to_string f converts its input to a string using f, then prints the string.

since
1.0
val const : 'a printer -> 'a -> unit printer

const pp x is a unit printer that uses pp on x.

since
1.0
val some : 'a printer -> 'a option printer

some pp will print options as follows:

  • Some x is printed using pp on x
  • None is not printed at all
since
1.0
val lazy_force : 'a printer -> 'a lazy_t printer

lazy_force pp out x forces x and prints the result with pp.

since
2.0
val lazy_or : ?⁠default:unit printer -> 'a printer -> 'a lazy_t printer

lazy_or ?default pp out x prints default if x is not evaluated yet, or uses pp otherwise.

since
2.0

ANSI codes

Use ANSI escape codes https://en.wikipedia.org/wiki/ANSI_escape_code to put some colors on the terminal.

This uses tags in format strings to specify the style. Current styles are the following:

  • "reset" resets style
  • "black"
  • "red"
  • "green"
  • "yellow"
  • "blue"
  • "magenta"
  • "cyan"
  • "white"
  • "bold" bold font
  • "Black" bold black
  • "Red" bold red
  • "Green" bold green
  • "Yellow" bold yellow
  • "Blue" bold blue
  • "Magenta" bold magenta
  • "Cyan" bold cyan
  • "White" bold white

Example:

set_color_default true;;
+CCFormat (containers.CCFormat)
Module CCFormat
Helpers for Format
since
0.8
type 'a iter = ('a -> unit) -> unit
Documentation for the standard Format module
include module type of sig ... end
type formatter = Stdlib__format.formatter
val pp_open_box : formatter -> int -> unit
val open_box : int -> unit
val pp_close_box : formatter -> unit -> unit
val close_box : unit -> unit
val pp_open_hbox : formatter -> unit -> unit
val open_hbox : unit -> unit
val pp_open_vbox : formatter -> int -> unit
val open_vbox : int -> unit
val pp_open_hvbox : formatter -> int -> unit
val open_hvbox : int -> unit
val pp_open_hovbox : formatter -> int -> unit
val open_hovbox : int -> unit
val pp_print_string : formatter -> string -> unit
val print_string : string -> unit
val pp_print_as : formatter -> int -> string -> unit
val print_as : int -> string -> unit
val pp_print_int : formatter -> int -> unit
val print_int : int -> unit
val pp_print_float : formatter -> float -> unit
val print_float : float -> unit
val pp_print_char : formatter -> char -> unit
val print_char : char -> unit
val pp_print_bool : formatter -> bool -> unit
val print_bool : bool -> unit
val pp_print_space : formatter -> unit -> unit
val print_space : unit -> unit
val pp_print_cut : formatter -> unit -> unit
val print_cut : unit -> unit
val pp_print_break : formatter -> int -> int -> unit
val print_break : int -> int -> unit
val pp_print_custom_break : formatter -> fits:(string * int * string) -> breaks:(string * int * string) -> unit
val pp_force_newline : formatter -> unit -> unit
val force_newline : unit -> unit
val pp_print_if_newline : formatter -> unit -> unit
val print_if_newline : unit -> unit
val pp_print_flush : formatter -> unit -> unit
val print_flush : unit -> unit
val pp_print_newline : formatter -> unit -> unit
val print_newline : unit -> unit
val pp_set_margin : formatter -> int -> unit
val set_margin : int -> unit
val pp_get_margin : formatter -> unit -> int
val get_margin : unit -> int
val pp_set_max_indent : formatter -> int -> unit
val set_max_indent : int -> unit
val pp_get_max_indent : formatter -> unit -> int
val get_max_indent : unit -> int
type geometry = Stdlib__format.geometry = {
max_indent : int;
margin : int;
}
val check_geometry : geometry -> bool
val pp_set_geometry : formatter -> max_indent:int -> margin:int -> unit
val set_geometry : max_indent:int -> margin:int -> unit
val pp_safe_set_geometry : formatter -> max_indent:int -> margin:int -> unit
val safe_set_geometry : max_indent:int -> margin:int -> unit
val pp_update_geometry : formatter -> (geometry -> geometry) -> unit
val update_geometry : (geometry -> geometry) -> unit
val pp_get_geometry : formatter -> unit -> geometry
val get_geometry : unit -> geometry
val pp_set_max_boxes : formatter -> int -> unit
val set_max_boxes : int -> unit
val pp_get_max_boxes : formatter -> unit -> int
val get_max_boxes : unit -> int
val pp_over_max_boxes : formatter -> unit -> bool
val over_max_boxes : unit -> bool
val pp_open_tbox : formatter -> unit -> unit
val open_tbox : unit -> unit
val pp_close_tbox : formatter -> unit -> unit
val close_tbox : unit -> unit
val pp_set_tab : formatter -> unit -> unit
val set_tab : unit -> unit
val pp_print_tab : formatter -> unit -> unit
val print_tab : unit -> unit
val pp_print_tbreak : formatter -> int -> int -> unit
val print_tbreak : int -> int -> unit
val pp_set_ellipsis_text : formatter -> string -> unit
val set_ellipsis_text : string -> unit
val pp_get_ellipsis_text : formatter -> unit -> string
val get_ellipsis_text : unit -> string
type stag = Stdlib__format.stag = ..
type tag = string
type stag += String_tag of tag
val pp_open_stag : formatter -> stag -> unit
val open_stag : stag -> unit
val pp_close_stag : formatter -> unit -> unit
val close_stag : unit -> unit
val pp_set_tags : formatter -> bool -> unit
val set_tags : bool -> unit
val pp_set_print_tags : formatter -> bool -> unit
val set_print_tags : bool -> unit
val pp_set_mark_tags : formatter -> bool -> unit
val set_mark_tags : bool -> unit
val pp_get_print_tags : formatter -> unit -> bool
val get_print_tags : unit -> bool
val pp_get_mark_tags : formatter -> unit -> bool
val get_mark_tags : unit -> bool
val pp_set_formatter_out_channel : formatter -> Stdlib.out_channel -> unit
val set_formatter_out_channel : Stdlib.out_channel -> unit
val pp_set_formatter_output_functions : formatter -> (string -> int -> int -> unit) -> (unit -> unit) -> unit
val set_formatter_output_functions : (string -> int -> int -> unit) -> (unit -> unit) -> unit
val pp_get_formatter_output_functions : formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit)
val get_formatter_output_functions : unit -> (string -> int -> int -> unit) * (unit -> unit)
type formatter_out_functions = Stdlib__format.formatter_out_functions = {
out_string : string -> int -> int -> unit;
out_flush : unit -> unit;
out_newline : unit -> unit;
out_spaces : int -> unit;
out_indent : int -> unit;
}
val pp_set_formatter_out_functions : formatter -> formatter_out_functions -> unit
val set_formatter_out_functions : formatter_out_functions -> unit
val pp_get_formatter_out_functions : formatter -> unit -> formatter_out_functions
val get_formatter_out_functions : unit -> formatter_out_functions
type formatter_stag_functions = Stdlib__format.formatter_stag_functions = {
mark_open_stag : stag -> string;
mark_close_stag : stag -> string;
print_open_stag : stag -> unit;
print_close_stag : stag -> unit;
}
val pp_set_formatter_stag_functions : formatter -> formatter_stag_functions -> unit
val set_formatter_stag_functions : formatter_stag_functions -> unit
val pp_get_formatter_stag_functions : formatter -> unit -> formatter_stag_functions
val get_formatter_stag_functions : unit -> formatter_stag_functions
val formatter_of_out_channel : Stdlib.out_channel -> formatter
val std_formatter : formatter
val err_formatter : formatter
val formatter_of_buffer : Stdlib.Buffer.t -> formatter
val stdbuf : Stdlib.Buffer.t
val str_formatter : formatter
val flush_str_formatter : unit -> string
val make_formatter : (string -> int -> int -> unit) -> (unit -> unit) -> formatter
val formatter_of_out_functions : formatter_out_functions -> formatter
type symbolic_output_item = Stdlib__format.symbolic_output_item = 
| Output_flush
| Output_newline
| Output_string of string
| Output_spaces of int
| Output_indent of int
type symbolic_output_buffer = Stdlib__format.symbolic_output_buffer
val make_symbolic_output_buffer : unit -> symbolic_output_buffer
val clear_symbolic_output_buffer : symbolic_output_buffer -> unit
val get_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list
val flush_symbolic_output_buffer : symbolic_output_buffer -> symbolic_output_item list
val add_symbolic_output_item : symbolic_output_buffer -> symbolic_output_item -> unit
val formatter_of_symbolic_output_buffer : symbolic_output_buffer -> formatter
val pp_print_list : ?⁠pp_sep:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a list -> unit
val pp_print_text : formatter -> string -> unit
val pp_print_option : ?⁠none:(formatter -> unit -> unit) -> (formatter -> 'a -> unit) -> formatter -> 'a option -> unit
val pp_print_result : ok:(formatter -> 'a -> unit) -> error:(formatter -> 'e -> unit) -> formatter -> ('a, 'e) Stdlib.result -> unit
val fprintf : formatter -> ('a, formatter, unit) Stdlib.format -> 'a
val printf : ('a, formatter, unit) Stdlib.format -> 'a
val eprintf : ('a, formatter, unit) Stdlib.format -> 'a
val sprintf : ('a, unit, string) Stdlib.format -> 'a
val asprintf : ('a, formatter, unit, string) Stdlib.format4 -> 'a
val dprintf : ('a, formatter, unit, formatter -> unit) Stdlib.format4 -> 'a
val ifprintf : formatter -> ('a, formatter, unit) Stdlib.format -> 'a
val kfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val kdprintf : ((formatter -> unit) -> 'a) -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val ikfprintf : (formatter -> 'a) -> formatter -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val ksprintf : (string -> 'a) -> ('b, unit, string, 'a) Stdlib.format4 -> 'b
val kasprintf : (string -> 'a) -> ('b, formatter, unit, 'a) Stdlib.format4 -> 'b
val bprintf : Stdlib.Buffer.t -> ('a, formatter, unit) Stdlib.format -> 'a
val kprintf : (string -> 'a) -> ('b, unit, string, 'a) Stdlib.format4 -> 'b
val set_all_formatter_output_functions : out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit
val get_all_formatter_output_functions : unit -> (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)
val pp_set_all_formatter_output_functions : formatter -> out:(string -> int -> int -> unit) -> flush:(unit -> unit) -> newline:(unit -> unit) -> spaces:(int -> unit) -> unit
val pp_get_all_formatter_output_functions : formatter -> unit -> (string -> int -> int -> unit) * (unit -> unit) * (unit -> unit) * (int -> unit)
val pp_open_tag : formatter -> tag -> unit
val open_tag : tag -> unit
val pp_close_tag : formatter -> unit -> unit
val close_tag : unit -> unit
type formatter_tag_functions = Stdlib__format.formatter_tag_functions = {
mark_open_tag : tag -> string;
mark_close_tag : tag -> string;
print_open_tag : tag -> unit;
print_close_tag : tag -> unit;
}
val pp_set_formatter_tag_functions : formatter -> formatter_tag_functions -> unit
val set_formatter_tag_functions : formatter_tag_functions -> unit
val pp_get_formatter_tag_functions : formatter -> unit -> formatter_tag_functions
val get_formatter_tag_functions : unit -> formatter_tag_functions
type t = Stdlib.Format.formatter
type 'a printer = t -> 'a -> unit
Combinators
val silent : 'a printer
Prints nothing.
val unit : unit printer
Prints "()".
val int : int printer
val string : string printer
val bool : bool printer
val float3 : float printer
val float : float printer
val exn : exn printer
Printer using Printexc.to_string.
since
3.0
val space : unit printer
Alias to pp_print_space.
since
3.2
val cut : unit printer
Alias to pp_print_cut.
since
3.2
val break : (int * int) printer
Tuple-ized printer form of pp_print_break.
since
3.2
val newline : unit printer
Force newline (see Format.pp_force_newline).
since
1.2
val substring : (string * int * int) printer
substring (s,i,len) prints the substring (s,i,len), where i is the offset in s and len the number of bytes in the substring.
raises Invalid_argument
if the triple (s,i,len) does not describe a proper substring.
since
1.2
val text : string printer
Print string, but replacing spaces with breaks and newlines with newline. See pp_print_text on recent versions of OCaml.
since
1.2
val string_lines : string printer
string_lines out s prints s with all newlines ('\n') replaced by a cut, in a vertical box. It does NOT insert breakable spaces in place of spaces, unlike text. This means an already formatted string can be displayed inside another formatter without mangling the indentation.
since
3.3
val char : char printer
since
0.14
val int32 : int32 printer
since
0.14
val int64 : int64 printer
since
0.14
val nativeint : nativeint printer
since
0.14
val flush : unit printer
Alias to Format.pp_print_flush.
since
1.2
val string_quoted : string printer
Similar to CCString.print.
since
0.14
val list : ?⁠sep:unit printer -> 'a printer -> 'a list printer
val array : ?⁠sep:unit printer -> 'a printer -> 'a array printer
val arrayi : ?⁠sep:unit printer -> (int * 'a) printer -> 'a array printer
val seq : ?⁠sep:unit printer -> 'a printer -> 'a Stdlib.Seq.t printer
val iter : ?⁠sep:unit printer -> 'a printer -> 'a iter printer
val opt : 'a printer -> 'a option printer
opt pp prints options as follows:
  • Some x will become "some foo" if pp x ---> "foo".
  • None will become "none".
val pair : ?⁠sep:unit printer -> 'a printer -> 'b printer -> ('a * 'b) printer
val triple : ?⁠sep:unit printer -> 'a printer -> 'b printer -> 'c printer -> ('a * 'b * 'c) printer
val quad : ?⁠sep:unit printer -> 'a printer -> 'b printer -> 'c printer -> 'd printer -> ('a * 'b * 'c * 'd) printer
val append : unit printer -> unit printer -> unit printer
append ppa ppb first prints ppa (), then prints ppb ().
since
3.2
val append_l : unit printer list -> unit printer
append_l pps runs the printers in pps sequentially.
since
3.2
val within : string -> string -> 'a printer -> 'a printer
within a b p wraps p inside the strings a and b. Convenient, for instances, for brackets, parenthesis, quotes, etc.
since
0.17
val map : ('a -> 'b) -> 'b printer -> 'a printer
val vbox : ?⁠i:int -> 'a printer -> 'a printer
Wrap the printer in a vertical box.
parameter i
level of indentation within the box (default 0).
since
0.16
val hvbox : ?⁠i:int -> 'a printer -> 'a printer
Wrap the printer in a horizontal/vertical box.
parameter i
level of indentation within the box (default 0).
since
0.16
val hovbox : ?⁠i:int -> 'a printer -> 'a printer
Wrap the printer in a horizontal or vertical box.
parameter i
level of indentation within the box (default 0).
since
0.16
val hbox : 'a printer -> 'a printer
Wrap the printer in an horizontal box.
since
0.16
val return : ('a, _, _, 'a) Stdlib.format4 -> unit printer
return "some_format_string" takes a argument-less format string and returns a printer actionable by (). Examples:
  • return ",@ "
  • return "@{<Red>and then@}@,"
  • return "@[<v>a@ b@]"
since
1.0
val of_to_string : ('a -> string) -> 'a printer
of_to_string f converts its input to a string using f, then prints the string.
since
1.0
val const : 'a printer -> 'a -> unit printer
const pp x is a unit printer that uses pp on x.
since
1.0
val some : 'a printer -> 'a option printer
some pp will print options as follows:
  • Some x is printed using pp on x
  • None is not printed at all
since
1.0
val lazy_force : 'a printer -> 'a lazy_t printer
lazy_force pp out x forces x and prints the result with pp.
since
2.0
val lazy_or : ?⁠default:unit printer -> 'a printer -> 'a lazy_t printer
lazy_or ?default pp out x prints default if x is not evaluated yet, or uses pp otherwise.
since
2.0
ANSI codes
Use ANSI escape codes https://en.wikipedia.org/wiki/ANSI_escape_code to put some colors on the terminal.
This uses tags in format strings to specify the style. Current styles are the following:
  • "reset" resets style
  • "black"
  • "red"
  • "green"
  • "yellow"
  • "blue"
  • "magenta"
  • "cyan"
  • "white"
  • "bold" bold font
  • "Black" bold black
  • "Red" bold red
  • "Green" bold green
  • "Yellow" bold yellow
  • "Blue" bold blue
  • "Magenta" bold magenta
  • "Cyan" bold cyan
  • "White" bold white
Example:
set_color_default true;;
 
 Format.printf
   "what is your @{<White>favorite color@}? @{<blue>blue@}! No, @{<red>red@}! Ahhhhhhh@.";;
status: unstable
since
0.15
val set_color_tag_handling : t -> unit
Add functions to support color tags to the given formatter.
since
0.15
val set_color_default : bool -> unit
set_color_default b enables color handling on the standard formatters (stdout, stderr) if b = true as well as on sprintf formatters; it disables the color handling if b = false.
val with_color : string -> 'a printer -> 'a printer
with_color "Blue" pp behaves like the printer pp, but with the given style.
status: unstable
since
0.16
val with_colorf : string -> t -> ('a, t, unit, unit) Stdlib.format4 -> 'a
with_colorf "Blue" out "%s %d" "yolo" 42 will behave like Format.fprintf, but wrapping the content with the given style.
status: unstable
since
0.16
val with_color_sf : string -> ('a, t, unit, string) Stdlib.format4 -> 'a
with_color_sf "Blue" out "%s %d" "yolo" 42 will behave like sprintf, but wrapping the content with the given style.
Example:
CCFormat.with_color_sf "red" "%a" CCFormat.Dump.(list int) [1;2;3] |> print_endline;;
status: unstable
since
0.21
val with_color_ksf : f:(string -> 'b) -> string -> ('a, t, unit, 'b) Stdlib.format4 -> 'a
with_color_ksf "Blue" ~f "%s %d" "yolo" 42 will behave like ksprintf, but wrapping the content with the given style.
Example: the following with raise Failure with a colored message
CCFormat.with_color_ksf "red" ~f:failwith "%a" CCFormat.Dump.(list int) [1;2;3];;
since
1.2
IO
val output : t -> 'a printer -> 'a -> unit
val to_string : 'a printer -> 'a -> string
val of_chan : Stdlib.out_channel -> t
Alias to Format.formatter_of_out_channel.
since
1.2
val with_out_chan : Stdlib.out_channel -> (t -> 'a) -> 'a
with_out_chan oc f turns oc into a formatter fmt, and call f fmt. Behaves like f fmt from then on, but whether the call to f fails or returns, fmt is flushed before the call terminates.
since
1.2
val stdout : t
val stderr : t
val tee : t -> t -> t
tee a b makes a new formatter that writes in both a and b.
since
1.0
val sprintf : ('a, t, unit, string) Stdlib.format4 -> 'a
Print into a string any format string that would usually be compatible with fprintf. Like Format.asprintf.
val sprintf_no_color : ('a, t, unit, string) Stdlib.format4 -> 'a
Like sprintf but never prints colors.
since
0.16
val sprintf_dyn_color : colors:bool -> ('a, t, unit, string) Stdlib.format4 -> 'a
Like sprintf but enable/disable colors depending on colors.
Example:
(* with colors *)
diff --git a/dev/containers/CCHashtbl/Poly/index.html b/dev/containers/CCHashtbl/Poly/index.html
index 0a508d1c..58532a20 100644
--- a/dev/containers/CCHashtbl/Poly/index.html
+++ b/dev/containers/CCHashtbl/Poly/index.html
@@ -1,2 +1,2 @@
 
-Poly (containers.CCHashtbl.Poly)
Module CCHashtbl.Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_iter : ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> ?⁠pp_arrow:unit printer -> 'a printer -> 'b printer -> ('a, 'b) Stdlib.Hashtbl.t printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
+Poly (containers.CCHashtbl.Poly)
Module CCHashtbl.Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_iter : ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> ?⁠pp_arrow:unit printer -> 'a printer -> 'b printer -> ('a, 'b) Stdlib.Hashtbl.t printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
diff --git a/dev/containers/CCHashtbl/index.html b/dev/containers/CCHashtbl/index.html
index ae927f96..a19a4817 100644
--- a/dev/containers/CCHashtbl/index.html
+++ b/dev/containers/CCHashtbl/index.html
@@ -1,2 +1,2 @@
 
-CCHashtbl (containers.CCHashtbl)
Module CCHashtbl
Extension to the standard Hashtbl
since
0.4
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a eq = 'a -> 'a -> bool
type 'a hash = 'a -> int
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
Polymorphic tables
module Poly : sig ... end
include module type of Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_iter : ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> ?⁠pp_arrow:unit printer -> 'a printer -> 'b printer -> ('a, 'b) Stdlib.Hashtbl.t printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13
Functor
module type S = sig ... end
module Make : functor (X : Stdlib.Hashtbl.HashedType) -> S with type Make.key = X.t and type 'a Make.t = 'a Stdlib.Hashtbl.Make(X).t

\ No newline at end of file
+CCHashtbl (containers.CCHashtbl)
Module CCHashtbl
Extension to the standard Hashtbl
since
0.4
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a eq = 'a -> 'a -> bool
type 'a hash = 'a -> int
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
Polymorphic tables
module Poly : sig ... end
include module type of Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_iter : ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> ?⁠pp_arrow:unit printer -> 'a printer -> 'b printer -> ('a, 'b) Stdlib.Hashtbl.t printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13
Functor
module type S = sig ... end
module Make : functor (X : Stdlib.Hashtbl.HashedType) -> S with type Make.key = X.t and type 'a Make.t = 'a Stdlib.Hashtbl.Make(X).t

\ No newline at end of file
diff --git a/dev/containers/CCHashtbl/module-type-S/index.html b/dev/containers/CCHashtbl/module-type-S/index.html
index 16355699..06af019a 100644
--- a/dev/containers/CCHashtbl/module-type-S/index.html
+++ b/dev/containers/CCHashtbl/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (containers.CCHashtbl.S)
Module type CCHashtbl.S
include Stdlib.Hashtbl.S
type key
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : 'a t -> key -> 'a option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : 'a t -> key -> default:'a -> 'a
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val add_list : 'a list t -> key -> 'a -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val incr : ?⁠by:int -> int t -> key -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> int t -> key -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val keys : 'a t -> key iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : 'a t -> 'a iter
values tbl f iterates on values in the table.
val keys_list : _ t -> key list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : 'a t -> 'a list
values_list t is the list of values in t.
since
0.8
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
Map on a hashtable's items, collect into a list.
val to_iter : 'a t -> (key * 'a) iter
Iterate on bindings in the table.
since
2.8
val add_iter : 'a t -> (key * 'a) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_iter : (key * 'a) iter -> 'a t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) iter -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_iter_count : int t -> key iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.
since
3.0
val of_iter_count : key iter -> int t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : key Stdlib.Seq.t -> int t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : 'a t -> (key * 'a) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> ?⁠pp_arrow:unit printer -> key printer -> 'a printer -> 'a t printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
+S (containers.CCHashtbl.S)
Module type CCHashtbl.S
include Stdlib.Hashtbl.S
type key
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : 'a t -> key -> 'a option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : 'a t -> key -> default:'a -> 'a
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val add_list : 'a list t -> key -> 'a -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val incr : ?⁠by:int -> int t -> key -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> int t -> key -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val keys : 'a t -> key iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : 'a t -> 'a iter
values tbl f iterates on values in the table.
val keys_list : _ t -> key list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : 'a t -> 'a list
values_list t is the list of values in t.
since
0.8
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
Map on a hashtable's items, collect into a list.
val to_iter : 'a t -> (key * 'a) iter
Iterate on bindings in the table.
since
2.8
val add_iter : 'a t -> (key * 'a) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_iter : (key * 'a) iter -> 'a t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) iter -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_iter_count : int t -> key iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.
since
3.0
val of_iter_count : key iter -> int t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : key Stdlib.Seq.t -> int t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : 'a t -> (key * 'a) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> ?⁠pp_arrow:unit printer -> key printer -> 'a printer -> 'a t printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
diff --git a/dev/containers/CCList/index.html b/dev/containers/CCList/index.html
index b42eb467..2a427917 100644
--- a/dev/containers/CCList/index.html
+++ b/dev/containers/CCList/index.html
@@ -1,9 +1,9 @@
 
-CCList (containers.CCList)
Module CCList
Complements to list
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
type 'a random_gen = Stdlib.Random.State.t -> 'a
Documentation for the standard List module
include module type of Stdlib.List
type !'a t = 'a list = 
| ([])
| (::) of 'a * 'a list
val length : 'a list -> int
val compare_lengths : 'a list -> 'b list -> int
val compare_length_with : 'a list -> int -> int
val cons : 'a -> 'a list -> 'a list
val hd : 'a list -> 'a
val tl : 'a list -> 'a list
val nth : 'a list -> int -> 'a
val nth_opt : 'a list -> int -> 'a option
val rev : 'a list -> 'a list
val init : int -> (int -> 'a) -> 'a list
val append : 'a list -> 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
val iter : ('a -> unit) -> 'a list -> unit
val iteri : (int -> 'a -> unit) -> 'a list -> unit
val map : ('a -> 'b) -> 'a list -> 'b list
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val filter_map : ('a -> 'b option) -> 'a list -> 'b list
val concat_map : ('a -> 'b list) -> 'a list -> 'b list
val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val for_all : ('a -> bool) -> 'a list -> bool
val exists : ('a -> bool) -> 'a list -> bool
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val mem : 'a -> 'a list -> bool
val memq : 'a -> 'a list -> bool
val find : ('a -> bool) -> 'a list -> 'a
val find_opt : ('a -> bool) -> 'a list -> 'a option
val find_map : ('a -> 'b option) -> 'a list -> 'b option
val filter : ('a -> bool) -> 'a list -> 'a list
val find_all : ('a -> bool) -> 'a list -> 'a list
val filteri : (int -> 'a -> bool) -> 'a list -> 'a list
val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
val assoc : 'a -> ('a * 'b) list -> 'b
val assoc_opt : 'a -> ('a * 'b) list -> 'b option
val assq : 'a -> ('a * 'b) list -> 'b
val assq_opt : 'a -> ('a * 'b) list -> 'b option
val mem_assoc : 'a -> ('a * 'b) list -> bool
val mem_assq : 'a -> ('a * 'b) list -> bool
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val combine : 'a list -> 'b list -> ('a * 'b) list
val sort : ('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list
val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val to_seq : 'a list -> 'a Stdlib.Seq.t
val of_seq : 'a Stdlib.Seq.t -> 'a list
type 'a t = 'a list
val empty : 'a t
empty is [].
val is_empty : _ t -> bool
is_empty l returns true iff l = [].
since
0.11
val map : ('a -> 'b) -> 'a t -> 'b t
map f [a0; a1; …; an] applies function f in turn to a0; a1; …; an. Safe version of List.map.
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
l >|= f is the infix version of map with reversed arguments.
since
0.5
val append : 'a t -> 'a t -> 'a t
append l1 l2 returns the list that is the concatenation of l1 and l2. Safe version of List.append.
val cons_maybe : 'a option -> 'a t -> 'a t
cons_maybe (Some x) l is x :: l. cons_maybe None l is l.
since
0.13
val cons' : 'a t -> 'a -> 'a t
cons' l x is the same as x :: l. This is convenient for fold functions such as List.fold_left or Array.fold_left.
since
NEXT_RELEASE
val (@) : 'a t -> 'a t -> 'a t
l1 @ l2 is like append l1 l2. Concatenate the two lists l1 and l2.
val filter : ('a -> bool) -> 'a t -> 'a t
filter p l returns all the elements of the list l that satisfy the predicate p. The order of the elements in the input list l is preserved. Safe version of List.filter.
val fold_right : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
fold_right f [a1; …; an] b is f a1 (f a2 ( … (f an b) … )). Safe version of List.fold_right.
val fold_while : ('a -> 'b -> 'a * [ `Stop | `Continue ]) -> 'a -> 'b t -> 'a
fold_while f init l folds until a stop condition via ('a, `Stop) is indicated by the accumulator.
since
0.8
val fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list
fold_map f init l is a fold_left-like function, but it also maps the list to another list.
since
0.14
val fold_map_i : ('acc -> int -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list
fold_map_i f init l is a foldi-like function, but it also maps the list to another list.
since
2.8
val fold_on_map : f:('a -> 'b) -> reduce:('acc -> 'b -> 'acc) -> 'acc -> 'a list -> 'acc
fold_on_map ~f ~reduce init l combines map f and fold_left reduce init in one operation.
since
2.8
val scan_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc list
scan_left f init l returns the list [init; f init x0; f (f init x0) x1; …] where x0, x1, etc. are the elements of l.
since
1.2, but only
since
2.2 with labels
val reduce : ('a -> 'a -> 'a) -> 'a list -> 'a option
reduce f (hd::tl) returns Some (fold_left f hd tl). If l is empty, then None is returned.
since
3.2
val reduce_exn : ('a -> 'a -> 'a) -> 'a list -> 'a
reduce_exn is the unsafe version of reduce.
raises Invalid_argument
if the given list is empty.
since
3.2
val fold_map2 : ('acc -> 'a -> 'b -> 'acc * 'c) -> 'acc -> 'a list -> 'b list -> 'acc * 'c list
fold_map2 f init l1 l2 is to fold_map what List.map2 is to List.map.
raises Invalid_argument
if the lists do not have the same length.
since
0.16
val fold_filter_map : ('acc -> 'a -> 'acc * 'b option) -> 'acc -> 'a list -> 'acc * 'b list
fold_filter_map f init l is a fold_left-like function, but also generates a list of output in a way similar to filter_map.
since
0.17
val fold_filter_map_i : ('acc -> int -> 'a -> 'acc * 'b option) -> 'acc -> 'a list -> 'acc * 'b list
fold_filter_map_i f init l is a foldi-like function, but also generates a list of output in a way similar to filter_map.
since
2.8
val fold_flat_map : ('acc -> 'a -> 'acc * 'b list) -> 'acc -> 'a list -> 'acc * 'b list
fold_flat_map f init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
0.14
val fold_flat_map_i : ('acc -> int -> 'a -> 'acc * 'b list) -> 'acc -> 'a list -> 'acc * 'b list
fold_flat_map_i f init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
2.8
val count : ('a -> bool) -> 'a list -> int
count p l counts how many elements of l satisfy predicate p.
since
1.5, but only
since
2.2 with labels
val count_true_false : ('a -> bool) -> 'a list -> int * int
count_true_false p l returns a pair (int1,int2) where int1 is the number of elements in l that satisfy the predicate p, and int2 the number of elements that do not satisfy p.
since
2.4
val init : int -> (int -> 'a) -> 'a t
init len f is f 0; f 1; …; f (len-1).
raises Invalid_argument
if len < 0.
since
0.6
val combine : 'a list -> 'b list -> ('a * 'b) list
combine [a1; …; an] [b1; …; bn] is [(a1,b1); …; (an,bn)]. Transform two lists into a list of pairs. Like List.combine but tail-recursive.
raises Invalid_argument
if the lists have distinct lengths.
since
1.2, but only
since
2.2 with labels
val combine_gen : 'a list -> 'b list -> ('a * 'b) gen
combine_gen l1 l2 transforms two lists into a gen of pairs. Lazy version of combine. Unlike combine, it does not fail if the lists have different lengths; instead, the output has as many pairs as the smallest input list.
since
1.2, but only
since
2.2 with labels
val combine_shortest : 'a list -> 'b list -> ('a * 'b) list
combine_shortest [a1; …; am] [b1; …; bn] is [(a1,b1); …; (am,bm)] if m <= n. Like combine but stops at the shortest list rather than raising.
since
3.1
val split : ('a * 'b) t -> 'a t * 'b t
split [(a1,b1); …; (an,bn)] is ([a1; …; an], [b1; …; bn]). Transform a list of pairs into a pair of lists. A tail-recursive version of List.split.
since
1.2, but only
since
2.2 with labels
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
compare cmp l1 l2 compares the two lists l1 and l2 using the given comparison function cmp.
val compare_lengths : 'a t -> 'b t -> int
compare_lengths l1 l2 compare the lengths of the two lists l1 and l2. Equivalent to compare (length l1) (length l2) but more efficient.
since
1.5, but only
since
2.2 with labels
val compare_length_with : 'a t -> int -> int
compare_length_with l x compares the length of the list l to an integer x. Equivalent to compare (length l) x but more efficient.
since
1.5, but only
since
2.2 with labels
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
equal p l1 l2 returns true if l1 and l2 are equal.
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
flat_map f l maps and flattens at the same time (safe). Evaluation order is not guaranteed.
val flat_map_i : (int -> 'a -> 'b t) -> 'a t -> 'b t
flat_map_i f l maps with index and flattens at the same time (safe). Evaluation order is not guaranteed.
since
2.8
val flatten : 'a t t -> 'a t
flatten [l1]; [l2]; … concatenates a list of lists. Safe version of List.flatten.
val product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
product comb l1 l2 computes the cartesian product of the two lists, with the given combinator comb.
val fold_product : ('c -> 'a -> 'b -> 'c) -> 'c -> 'a t -> 'b t -> 'c
fold_product f init l1 l2 applies the function f with the accumulator init on all the pair of elements of l1 and l2. Fold on the cartesian product.
val cartesian_product : 'a t t -> 'a t t
cartesian_product [[l1]; [l2]; …; [ln]] produces the cartesian product of this list of lists, by returning all the ways of picking one element per sublist. NOTE the order of the returned list is unspecified. For example:
# cartesian_product [[1;2];[3];[4;5;6]] |> sort =
+CCList (containers.CCList)
Module CCList
Complements to list
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
type 'a random_gen = Stdlib.Random.State.t -> 'a
Documentation for the standard List module
include module type of Stdlib.List
type !'a t = 'a list = 
| ([])
| (::) of 'a * 'a list
val length : 'a list -> int
val compare_lengths : 'a list -> 'b list -> int
val compare_length_with : 'a list -> int -> int
val cons : 'a -> 'a list -> 'a list
val hd : 'a list -> 'a
val tl : 'a list -> 'a list
val nth : 'a list -> int -> 'a
val nth_opt : 'a list -> int -> 'a option
val rev : 'a list -> 'a list
val init : int -> (int -> 'a) -> 'a list
val append : 'a list -> 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
val iter : ('a -> unit) -> 'a list -> unit
val iteri : (int -> 'a -> unit) -> 'a list -> unit
val map : ('a -> 'b) -> 'a list -> 'b list
val mapi : (int -> 'a -> 'b) -> 'a list -> 'b list
val rev_map : ('a -> 'b) -> 'a list -> 'b list
val filter_map : ('a -> 'b option) -> 'a list -> 'b list
val concat_map : ('a -> 'b list) -> 'a list -> 'b list
val fold_left_map : ('a -> 'b -> 'a * 'c) -> 'a -> 'b list -> 'a * 'c list
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b list -> 'a
val fold_right : ('a -> 'b -> 'b) -> 'a list -> 'b -> 'b
val iter2 : ('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : ('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : ('a -> 'b -> 'c -> 'a) -> 'a -> 'b list -> 'c list -> 'a
val fold_right2 : ('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> 'c -> 'c
val for_all : ('a -> bool) -> 'a list -> bool
val exists : ('a -> bool) -> 'a list -> bool
val for_all2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : ('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val mem : 'a -> 'a list -> bool
val memq : 'a -> 'a list -> bool
val find : ('a -> bool) -> 'a list -> 'a
val find_opt : ('a -> bool) -> 'a list -> 'a option
val find_map : ('a -> 'b option) -> 'a list -> 'b option
val filter : ('a -> bool) -> 'a list -> 'a list
val find_all : ('a -> bool) -> 'a list -> 'a list
val filteri : (int -> 'a -> bool) -> 'a list -> 'a list
val partition : ('a -> bool) -> 'a list -> 'a list * 'a list
val assoc : 'a -> ('a * 'b) list -> 'b
val assoc_opt : 'a -> ('a * 'b) list -> 'b option
val assq : 'a -> ('a * 'b) list -> 'b
val assq_opt : 'a -> ('a * 'b) list -> 'b option
val mem_assoc : 'a -> ('a * 'b) list -> bool
val mem_assq : 'a -> ('a * 'b) list -> bool
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val combine : 'a list -> 'b list -> ('a * 'b) list
val sort : ('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : ('a -> 'a -> int) -> 'a list -> 'a list
val sort_uniq : ('a -> 'a -> int) -> 'a list -> 'a list
val merge : ('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val to_seq : 'a list -> 'a Stdlib.Seq.t
val of_seq : 'a Stdlib.Seq.t -> 'a list
type 'a t = 'a list
val empty : 'a t
empty is [].
val is_empty : _ t -> bool
is_empty l returns true iff l = [].
since
0.11
val map : ('a -> 'b) -> 'a t -> 'b t
map f [a0; a1; …; an] applies function f in turn to a0; a1; …; an. Safe version of List.map.
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
l >|= f is the infix version of map with reversed arguments.
since
0.5
val append : 'a t -> 'a t -> 'a t
append l1 l2 returns the list that is the concatenation of l1 and l2. Safe version of List.append.
val cons_maybe : 'a option -> 'a t -> 'a t
cons_maybe (Some x) l is x :: l. cons_maybe None l is l.
since
0.13
val cons' : 'a t -> 'a -> 'a t
cons' l x is the same as x :: l. This is convenient for fold functions such as List.fold_left or Array.fold_left.
since
3.3
val (@) : 'a t -> 'a t -> 'a t
l1 @ l2 is like append l1 l2. Concatenate the two lists l1 and l2.
val filter : ('a -> bool) -> 'a t -> 'a t
filter p l returns all the elements of the list l that satisfy the predicate p. The order of the elements in the input list l is preserved. Safe version of List.filter.
val fold_right : ('a -> 'b -> 'b) -> 'a t -> 'b -> 'b
fold_right f [a1; …; an] b is f a1 (f a2 ( … (f an b) … )). Safe version of List.fold_right.
val fold_while : ('a -> 'b -> 'a * [ `Stop | `Continue ]) -> 'a -> 'b t -> 'a
fold_while f init l folds until a stop condition via ('a, `Stop) is indicated by the accumulator.
since
0.8
val fold_map : ('acc -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list
fold_map f init l is a fold_left-like function, but it also maps the list to another list.
since
0.14
val fold_map_i : ('acc -> int -> 'a -> 'acc * 'b) -> 'acc -> 'a list -> 'acc * 'b list
fold_map_i f init l is a foldi-like function, but it also maps the list to another list.
since
2.8
val fold_on_map : f:('a -> 'b) -> reduce:('acc -> 'b -> 'acc) -> 'acc -> 'a list -> 'acc
fold_on_map ~f ~reduce init l combines map f and fold_left reduce init in one operation.
since
2.8
val scan_left : ('acc -> 'a -> 'acc) -> 'acc -> 'a list -> 'acc list
scan_left f init l returns the list [init; f init x0; f (f init x0) x1; …] where x0, x1, etc. are the elements of l.
since
1.2, but only
since
2.2 with labels
val reduce : ('a -> 'a -> 'a) -> 'a list -> 'a option
reduce f (hd::tl) returns Some (fold_left f hd tl). If l is empty, then None is returned.
since
3.2
val reduce_exn : ('a -> 'a -> 'a) -> 'a list -> 'a
reduce_exn is the unsafe version of reduce.
raises Invalid_argument
if the given list is empty.
since
3.2
val fold_map2 : ('acc -> 'a -> 'b -> 'acc * 'c) -> 'acc -> 'a list -> 'b list -> 'acc * 'c list
fold_map2 f init l1 l2 is to fold_map what List.map2 is to List.map.
raises Invalid_argument
if the lists do not have the same length.
since
0.16
val fold_filter_map : ('acc -> 'a -> 'acc * 'b option) -> 'acc -> 'a list -> 'acc * 'b list
fold_filter_map f init l is a fold_left-like function, but also generates a list of output in a way similar to filter_map.
since
0.17
val fold_filter_map_i : ('acc -> int -> 'a -> 'acc * 'b option) -> 'acc -> 'a list -> 'acc * 'b list
fold_filter_map_i f init l is a foldi-like function, but also generates a list of output in a way similar to filter_map.
since
2.8
val fold_flat_map : ('acc -> 'a -> 'acc * 'b list) -> 'acc -> 'a list -> 'acc * 'b list
fold_flat_map f init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
0.14
val fold_flat_map_i : ('acc -> int -> 'a -> 'acc * 'b list) -> 'acc -> 'a list -> 'acc * 'b list
fold_flat_map_i f init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
2.8
val count : ('a -> bool) -> 'a list -> int
count p l counts how many elements of l satisfy predicate p.
since
1.5, but only
since
2.2 with labels
val count_true_false : ('a -> bool) -> 'a list -> int * int
count_true_false p l returns a pair (int1,int2) where int1 is the number of elements in l that satisfy the predicate p, and int2 the number of elements that do not satisfy p.
since
2.4
val init : int -> (int -> 'a) -> 'a t
init len f is f 0; f 1; …; f (len-1).
raises Invalid_argument
if len < 0.
since
0.6
val combine : 'a list -> 'b list -> ('a * 'b) list
combine [a1; …; an] [b1; …; bn] is [(a1,b1); …; (an,bn)]. Transform two lists into a list of pairs. Like List.combine but tail-recursive.
raises Invalid_argument
if the lists have distinct lengths.
since
1.2, but only
since
2.2 with labels
val combine_gen : 'a list -> 'b list -> ('a * 'b) gen
combine_gen l1 l2 transforms two lists into a gen of pairs. Lazy version of combine. Unlike combine, it does not fail if the lists have different lengths; instead, the output has as many pairs as the smallest input list.
since
1.2, but only
since
2.2 with labels
val combine_shortest : 'a list -> 'b list -> ('a * 'b) list
combine_shortest [a1; …; am] [b1; …; bn] is [(a1,b1); …; (am,bm)] if m <= n. Like combine but stops at the shortest list rather than raising.
since
3.1
val split : ('a * 'b) t -> 'a t * 'b t
split [(a1,b1); …; (an,bn)] is ([a1; …; an], [b1; …; bn]). Transform a list of pairs into a pair of lists. A tail-recursive version of List.split.
since
1.2, but only
since
2.2 with labels
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
compare cmp l1 l2 compares the two lists l1 and l2 using the given comparison function cmp.
val compare_lengths : 'a t -> 'b t -> int
compare_lengths l1 l2 compare the lengths of the two lists l1 and l2. Equivalent to compare (length l1) (length l2) but more efficient.
since
1.5, but only
since
2.2 with labels
val compare_length_with : 'a t -> int -> int
compare_length_with l x compares the length of the list l to an integer x. Equivalent to compare (length l) x but more efficient.
since
1.5, but only
since
2.2 with labels
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
equal p l1 l2 returns true if l1 and l2 are equal.
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
flat_map f l maps and flattens at the same time (safe). Evaluation order is not guaranteed.
val flat_map_i : (int -> 'a -> 'b t) -> 'a t -> 'b t
flat_map_i f l maps with index and flattens at the same time (safe). Evaluation order is not guaranteed.
since
2.8
val flatten : 'a t t -> 'a t
flatten [l1]; [l2]; … concatenates a list of lists. Safe version of List.flatten.
val product : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
product comb l1 l2 computes the cartesian product of the two lists, with the given combinator comb.
val fold_product : ('c -> 'a -> 'b -> 'c) -> 'c -> 'a t -> 'b t -> 'c
fold_product f init l1 l2 applies the function f with the accumulator init on all the pair of elements of l1 and l2. Fold on the cartesian product.
val cartesian_product : 'a t t -> 'a t t
cartesian_product [[l1]; [l2]; …; [ln]] produces the cartesian product of this list of lists, by returning all the ways of picking one element per sublist. NOTE the order of the returned list is unspecified. For example:
# cartesian_product [[1;2];[3];[4;5;6]] |> sort =
 [[1;3;4];[1;3;5];[1;3;6];[2;3;4];[2;3;5];[2;3;6]];;
 # cartesian_product [[1;2];[];[4;5;6]] = [];;
 # cartesian_product [[1;2];[3];[4];[5];[6]] |> sort =
-[[1;3;4;5;6];[2;3;4;5;6]];;
invariant: cartesian_product l = map_product id l.
since
1.2, but only
since
2.2 with labels
val map_product_l : ('a -> 'b list) -> 'a list -> 'b list list
map_product_l f l maps each element of l to a list of objects of type 'b using f. We obtain [l1; l2; …; ln] where length l=n and li : 'b list. Then, it returns all the ways of picking exactly one element per li.
since
1.2, but only
since
2.2 with labels
val diagonal : 'a t -> ('a * 'a) t
diagonal l returns all pairs of distinct positions of the list l, that is the list of List.nth i l, List.nth j l if i < j.
val partition_map_either : ('a -> ('b, 'c) CCEither.t) -> 'a list -> 'b list * 'c list
partition_map_either f l maps f on l and gather results in lists:
  • if f x = Left y, adds y to the first list.
  • if f x = Right z, adds z to the second list.
since
NEXT_RELEASE
val partition_filter_map : ('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_filter_map f l maps f on l and gather results in lists:
  • if f x = `Left y, adds y to the first list.
  • if f x = `Right z, adds z to the second list.
  • if f x = `Drop, ignores x.
since
0.11
val partition_map : ('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
deprecated
use partition_filter_map instead
val group_by : ?⁠hash:('a -> int) -> ?⁠eq:('a -> 'a -> bool) -> 'a t -> 'a list t
group_by ?hash ?eq l groups equal elements, regardless of their order of appearance. precondition: for any x and y, if eq x y then hash x=hash y must hold.
since
2.3
val join : join_row:('a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join ~join_row a b combines every element of a with every element of b using join_row. If join_row returns None, then the two elements do not combine. Assume that b allows for multiple iterations.
since
2.3
val join_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and combine values (x,y) from (a,b) with the same key using merge. If merge returns None, the combination of values is discarded. precondition: for any x and y, if eq x y then hash x=hash y must hold.
since
2.3
val join_all_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a list -> 'b list -> 'c option) -> 'a t -> 'b t -> 'c t
join_all_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and, for each key k occurring in at least one of them:
  • compute the list l1 of elements of a that map to k
  • compute the list l2 of elements of b that map to k
  • call merge k l1 l2. If merge returns None, the combination of values is discarded, otherwise it returns Some c and c is inserted in the result.
since
2.3
val group_join_by : ?⁠eq:('a -> 'a -> bool) -> ?⁠hash:('a -> int) -> ('b -> 'a) -> 'a t -> 'b t -> ('a * 'b list) t
group_join_by ?eq ?hash key la lb associates to every element x of the first sequence, all the elements y of the second sequence such that eq x (key y). Elements of the first sequences without corresponding values in the second one are mapped to [] precondition: for any x and y, if eq x y then hash x=hash y must hold.
since
2.3
val sublists_of_len : ?⁠last:('a list -> 'a list option) -> ?⁠offset:int -> int -> 'a list -> 'a list list
sublists_of_len ?last ?offset n l returns sub-lists of l that have length n. By default, these sub-lists are non overlapping: sublists_of_len 2 [1;2;3;4;5;6] returns [1;2]; [3;4]; [5;6].
Examples:
  • sublists_of_len 2 [1;2;3;4;5;6] = [[1;2]; [3;4]; [5;6]].
  • sublists_of_len 2 ~offset:3 [1;2;3;4;5;6] = [1;2];[4;5].
  • sublists_of_len 3 ~last:CCOpt.return [1;2;3;4] = [1;2;3];[4].
  • sublists_of_len 2 [1;2;3;4;5] = [[1;2]; [3;4]].
parameter offset
the number of elements skipped between two consecutive sub-lists. By default it is n. If offset < n, the sub-lists will overlap; if offset > n, some elements will not appear at all.
parameter last
if provided and the last group of elements g is such that length g < n, last g is called. If last g = Some g', g' is appended; otherwise g is dropped. If last = CCOpt.return, it will simply keep the last group. By default, last = fun _ -> None, i.e. the last group is dropped if shorter than n.
raises Invalid_argument
if offset <= 0 or n <= 0. See CCList.sublists_of_len for more details.
since
1.0, but only
since
1.5 with labels
val chunks : int -> 'a list -> 'a list list
chunks n l returns consecutives chunks of size at most n from l. Each item of l will occur in exactly one chunk. Only the last chunk might be of length smaller than n. Invariant: (chunks n l |> List.flatten) = l.
since
3.2
val intersperse : 'a -> 'a list -> 'a list
intersperse x l inserts the element x between adjacent elements of the list l.
since
2.1, but only
since
2.2 with labels
val interleave : 'a list -> 'a list -> 'a list
interleave [x1…xn] [y1…ym] is [x1;y1;x2;y2;…] and finishes with the suffix of the longest list.
since
2.1, but only
since
2.2 with labels
val pure : 'a -> 'a t
pure x is return x.
val mguard : bool -> unit t
mguard c is pure () if c is true, [] otherwise. This is useful to define a list by comprehension, e.g.:
# let square_even xs =
+[[1;3;4;5;6];[2;3;4;5;6]];;
invariant: cartesian_product l = map_product id l.
since
1.2, but only
since
2.2 with labels
val map_product_l : ('a -> 'b list) -> 'a list -> 'b list list
map_product_l f l maps each element of l to a list of objects of type 'b using f. We obtain [l1; l2; …; ln] where length l=n and li : 'b list. Then, it returns all the ways of picking exactly one element per li.
since
1.2, but only
since
2.2 with labels
val diagonal : 'a t -> ('a * 'a) t
diagonal l returns all pairs of distinct positions of the list l, that is the list of List.nth i l, List.nth j l if i < j.
val partition_map_either : ('a -> ('b, 'c) CCEither.t) -> 'a list -> 'b list * 'c list
partition_map_either f l maps f on l and gather results in lists:
  • if f x = Left y, adds y to the first list.
  • if f x = Right z, adds z to the second list.
since
3.3
val partition_filter_map : ('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_filter_map f l maps f on l and gather results in lists:
  • if f x = `Left y, adds y to the first list.
  • if f x = `Right z, adds z to the second list.
  • if f x = `Drop, ignores x.
since
0.11
val partition_map : ('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
deprecated
use partition_filter_map instead
val group_by : ?⁠hash:('a -> int) -> ?⁠eq:('a -> 'a -> bool) -> 'a t -> 'a list t
group_by ?hash ?eq l groups equal elements, regardless of their order of appearance. precondition: for any x and y, if eq x y then hash x=hash y must hold.
since
2.3
val join : join_row:('a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join ~join_row a b combines every element of a with every element of b using join_row. If join_row returns None, then the two elements do not combine. Assume that b allows for multiple iterations.
since
2.3
val join_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and combine values (x,y) from (a,b) with the same key using merge. If merge returns None, the combination of values is discarded. precondition: for any x and y, if eq x y then hash x=hash y must hold.
since
2.3
val join_all_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a list -> 'b list -> 'c option) -> 'a t -> 'b t -> 'c t
join_all_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and, for each key k occurring in at least one of them:
  • compute the list l1 of elements of a that map to k
  • compute the list l2 of elements of b that map to k
  • call merge k l1 l2. If merge returns None, the combination of values is discarded, otherwise it returns Some c and c is inserted in the result.
since
2.3
val group_join_by : ?⁠eq:('a -> 'a -> bool) -> ?⁠hash:('a -> int) -> ('b -> 'a) -> 'a t -> 'b t -> ('a * 'b list) t
group_join_by ?eq ?hash key la lb associates to every element x of the first sequence, all the elements y of the second sequence such that eq x (key y). Elements of the first sequences without corresponding values in the second one are mapped to [] precondition: for any x and y, if eq x y then hash x=hash y must hold.
since
2.3
val sublists_of_len : ?⁠last:('a list -> 'a list option) -> ?⁠offset:int -> int -> 'a list -> 'a list list
sublists_of_len ?last ?offset n l returns sub-lists of l that have length n. By default, these sub-lists are non overlapping: sublists_of_len 2 [1;2;3;4;5;6] returns [1;2]; [3;4]; [5;6].
Examples:
  • sublists_of_len 2 [1;2;3;4;5;6] = [[1;2]; [3;4]; [5;6]].
  • sublists_of_len 2 ~offset:3 [1;2;3;4;5;6] = [1;2];[4;5].
  • sublists_of_len 3 ~last:CCOpt.return [1;2;3;4] = [1;2;3];[4].
  • sublists_of_len 2 [1;2;3;4;5] = [[1;2]; [3;4]].
parameter offset
the number of elements skipped between two consecutive sub-lists. By default it is n. If offset < n, the sub-lists will overlap; if offset > n, some elements will not appear at all.
parameter last
if provided and the last group of elements g is such that length g < n, last g is called. If last g = Some g', g' is appended; otherwise g is dropped. If last = CCOpt.return, it will simply keep the last group. By default, last = fun _ -> None, i.e. the last group is dropped if shorter than n.
raises Invalid_argument
if offset <= 0 or n <= 0. See CCList.sublists_of_len for more details.
since
1.0, but only
since
1.5 with labels
val chunks : int -> 'a list -> 'a list list
chunks n l returns consecutives chunks of size at most n from l. Each item of l will occur in exactly one chunk. Only the last chunk might be of length smaller than n. Invariant: (chunks n l |> List.flatten) = l.
since
3.2
val intersperse : 'a -> 'a list -> 'a list
intersperse x l inserts the element x between adjacent elements of the list l.
since
2.1, but only
since
2.2 with labels
val interleave : 'a list -> 'a list -> 'a list
interleave [x1…xn] [y1…ym] is [x1;y1;x2;y2;…] and finishes with the suffix of the longest list.
since
2.1, but only
since
2.2 with labels
val pure : 'a -> 'a t
pure x is return x.
val mguard : bool -> unit t
mguard c is pure () if c is true, [] otherwise. This is useful to define a list by comprehension, e.g.:
# let square_even xs =
       let* x = xs in
       let* () = mguard (x mod 2 = 0) in
       return @@ x * x;;
diff --git a/dev/containers/CCListLabels/index.html b/dev/containers/CCListLabels/index.html
index 3039168b..7374ce3b 100644
--- a/dev/containers/CCListLabels/index.html
+++ b/dev/containers/CCListLabels/index.html
@@ -1,9 +1,9 @@
 
-CCListLabels (containers.CCListLabels)
Module CCListLabels
Complements to list
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
type 'a random_gen = Stdlib.Random.State.t -> 'a
Documentation for the standard ListLabels module
include module type of Stdlib.ListLabels
type !'a t = 'a list = 
| ([])
| (::) of 'a * 'a list
val length : 'a list -> int
val hd : 'a list -> 'a
val compare_lengths : 'a list -> 'b list -> int
val compare_length_with : 'a list -> len:int -> int
val cons : 'a -> 'a list -> 'a list
val tl : 'a list -> 'a list
val nth : 'a list -> int -> 'a
val nth_opt : 'a list -> int -> 'a option
val rev : 'a list -> 'a list
val init : len:int -> f:(int -> 'a) -> 'a list
val append : 'a list -> 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
val iter : f:('a -> unit) -> 'a list -> unit
val iteri : f:(int -> 'a -> unit) -> 'a list -> unit
val map : f:('a -> 'b) -> 'a list -> 'b list
val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list
val rev_map : f:('a -> 'b) -> 'a list -> 'b list
val filter_map : f:('a -> 'b option) -> 'a list -> 'b list
val concat_map : f:('a -> 'b list) -> 'a list -> 'b list
val fold_left_map : f:('a -> 'b -> 'a * 'c) -> init:'a -> 'b list -> 'a * 'c list
val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a
val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b
val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a
val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c
val for_all : f:('a -> bool) -> 'a list -> bool
val exists : f:('a -> bool) -> 'a list -> bool
val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val mem : 'a -> set:'a list -> bool
val memq : 'a -> set:'a list -> bool
val find : f:('a -> bool) -> 'a list -> 'a
val find_opt : f:('a -> bool) -> 'a list -> 'a option
val find_map : f:('a -> 'b option) -> 'a list -> 'b option
val filter : f:('a -> bool) -> 'a list -> 'a list
val find_all : f:('a -> bool) -> 'a list -> 'a list
val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list
val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
val assoc : 'a -> ('a * 'b) list -> 'b
val assoc_opt : 'a -> ('a * 'b) list -> 'b option
val assq : 'a -> ('a * 'b) list -> 'b
val assq_opt : 'a -> ('a * 'b) list -> 'b option
val mem_assoc : 'a -> map:('a * 'b) list -> bool
val mem_assq : 'a -> map:('a * 'b) list -> bool
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val combine : 'a list -> 'b list -> ('a * 'b) list
val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val to_seq : 'a list -> 'a Stdlib.Seq.t
val of_seq : 'a Stdlib.Seq.t -> 'a list
type 'a t = 'a list
val empty : 'a t
empty is [].
val is_empty : _ t -> bool
is_empty l returns true iff l = [].
since
0.11
val map : f:('a -> 'b) -> 'a t -> 'b t
map ~f [a0; a1; …; an] applies function f in turn to [a0; a1; …; an]. Safe version of List.map.
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
l >|= f is the infix version of map with reversed arguments.
since
0.5
val cons : 'a -> 'a t -> 'a t
cons x l is x::l.
since
0.12
val append : 'a t -> 'a t -> 'a t
append l1 l2 returns the list that is the concatenation of l1 and l2. Safe version of List.append.
val cons' : 'a t -> 'a -> 'a t
cons' l x is the same as x :: l. This is convenient for fold functions such as List.fold_left or Array.fold_left.
since
NEXT_RELEASE
val cons_maybe : 'a option -> 'a t -> 'a t
cons_maybe (Some x) l is x :: l. cons_maybe None l is l.
since
0.13
val (@) : 'a t -> 'a t -> 'a t
l1 @ l2 is like append l1 l2. Concatenate the two lists l1 and l2.
val filter : f:('a -> bool) -> 'a t -> 'a t
filter ~f l returns all the elements of the list l that satisfy the predicate f. The order of the elements in the input list l is preserved. Safe version of List.filter.
val fold_right : f:('a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
fold_right ~f [a1; …; an] ~init is f a1 (f a2 ( … (f an init) … )). Safe version of List.fold_right.
val fold_while : f:('a -> 'b -> 'a * [ `Stop | `Continue ]) -> init:'a -> 'b t -> 'a
fold_while ~f ~init l folds until a stop condition via ('a, `Stop) is indicated by the accumulator.
since
0.8
val fold_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list
fold_map ~f ~init l is a fold_left-like function, but it also maps the list to another list.
since
0.14
val fold_map_i : f:('acc -> int -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list
fold_map_i ~f ~init l is a foldi-like function, but it also maps the list to another list.
since
2.8
val fold_on_map : f:('a -> 'b) -> reduce:('acc -> 'b -> 'acc) -> init:'acc -> 'a list -> 'acc
fold_on_map ~f ~reduce ~init l combines map ~f and fold_left ~reduce ~init in one operation.
since
2.8
val scan_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc list
scan_left ~f ~init l returns the list [init; f init x0; f (f init x0) x1; …] where x0, x1, etc. are the elements of l.
since
1.2, but only
since
2.2 with labels
val reduce : f:('a -> 'a -> 'a) -> 'a list -> 'a option
reduce f (hd::tl) returns Some (fold_left f hd tl). If l is empty, then None is returned.
since
3.2
val reduce_exn : f:('a -> 'a -> 'a) -> 'a list -> 'a
reduce_exn is the unsafe version of reduce.
raises Invalid_argument
if the given list is empty.
since
3.2
val fold_map2 : f:('acc -> 'a -> 'b -> 'acc * 'c) -> init:'acc -> 'a list -> 'b list -> 'acc * 'c list
fold_map2 ~f ~init l1 l2 is to fold_map what List.map2 is to List.map.
raises Invalid_argument
if the lists do not have the same length.
since
0.16
val fold_filter_map : f:('acc -> 'a -> 'acc * 'b option) -> init:'acc -> 'a list -> 'acc * 'b list
fold_filter_map ~f ~init l is a fold_left-like function, but also generates a list of output in a way similar to filter_map.
since
0.17
val fold_filter_map_i : f:('acc -> int -> 'a -> 'acc * 'b option) -> init:'acc -> 'a list -> 'acc * 'b list
fold_filter_map_i ~f ~init l is a foldi-like function, but also generates a list of output in a way similar to filter_map.
since
2.8
val fold_flat_map : f:('acc -> 'a -> 'acc * 'b list) -> init:'acc -> 'a list -> 'acc * 'b list
fold_flat_map ~f ~init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
0.14
val fold_flat_map_i : f:('acc -> int -> 'a -> 'acc * 'b list) -> init:'acc -> 'a list -> 'acc * 'b list
fold_flat_map_i ~f ~init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
2.8
val count : f:('a -> bool) -> 'a list -> int
count ~f l counts how many elements of l satisfy predicate f.
since
1.5, but only
since
2.2 with labels
val count_true_false : f:('a -> bool) -> 'a list -> int * int
count_true_false ~f l returns a pair (int1,int2) where int1 is the number of elements in l that satisfy the predicate f, and int2 the number of elements that do not satisfy f.
since
2.4
val init : int -> f:(int -> 'a) -> 'a t
init len ~f is f 0; f 1; …; f (len-1).
raises Invalid_argument
if len < 0.
since
0.6
val combine : 'a list -> 'b list -> ('a * 'b) list
combine [a1; …; an] [b1; …; bn] is [(a1,b1); …; (an,bn)]. Transform two lists into a list of pairs. Like List.combine but tail-recursive.
raises Invalid_argument
if the lists have distinct lengths.
since
1.2, but only
since
2.2 with labels
val combine_gen : 'a list -> 'b list -> ('a * 'b) gen
combine_gen l1 l2 transforms two lists into a gen of pairs. Lazy version of combine. Unlike combine, it does not fail if the lists have different lengths; instead, the output has as many pairs as the smallest input list.
since
1.2, but only
since
2.2 with labels
val combine_shortest : 'a list -> 'b list -> ('a * 'b) list
combine_shortest [a1; …; am] [b1; …; bn] is [(a1,b1); …; (am,bm)] if m <= n. Like combine but stops at the shortest list rather than raising.
since
3.1
val split : ('a * 'b) t -> 'a t * 'b t
split [(a1,b1); …; (an,bn)] is ([a1; …; an], [b1; …; bn]). Transform a list of pairs into a pair of lists. A tail-recursive version of List.split.
since
1.2, but only
since
2.2 with labels
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
compare cmp l1 l2 compares the two lists l1 and l2 using the given comparison function cmp.
val compare_lengths : 'a t -> 'b t -> int
compare_lengths l1 l2 compare the lengths of the two lists l1 and l2. Equivalent to compare (length l1) (length l2) but more efficient.
since
1.5, but only
since
2.2 with labels
val compare_length_with : 'a t -> int -> int
compare_length_with l x compares the length of the list l to an integer x. Equivalent to compare (length l) x but more efficient.
since
1.5, but only
since
2.2 with labels
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
equal p l1 l2 returns true if l1 and l2 are equal.
val flat_map : f:('a -> 'b t) -> 'a t -> 'b t
flat_map ~f l maps and flattens at the same time (safe). Evaluation order is not guaranteed.
val flat_map_i : f:(int -> 'a -> 'b t) -> 'a t -> 'b t
flat_map_i ~f l maps with index and flattens at the same time (safe). Evaluation order is not guaranteed.
since
2.8
val flatten : 'a t t -> 'a t
flatten [l1]; [l2]; … concatenates a list of lists. Safe version of List.flatten.
val product : f:('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
product ~f l1 l2 computes the cartesian product of the two lists, with the given combinator f.
val fold_product : f:('c -> 'a -> 'b -> 'c) -> init:'c -> 'a t -> 'b t -> 'c
fold_product ~f ~init l1 l2 applies the function f with the accumulator init on all the pair of elements of l1 and l2. Fold on the cartesian product.
val cartesian_product : 'a t t -> 'a t t
cartesian_product [[l1];[l2]; …; [ln]] produces the cartesian product of this list of lists, by returning all the ways of picking one element per sublist. NOTE the order of the returned list is unspecified. For example:
# cartesian_product [[1;2];[3];[4;5;6]] |> sort =
+CCListLabels (containers.CCListLabels)
Module CCListLabels
Complements to list
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
type 'a random_gen = Stdlib.Random.State.t -> 'a
Documentation for the standard ListLabels module
include module type of Stdlib.ListLabels
type !'a t = 'a list = 
| ([])
| (::) of 'a * 'a list
val length : 'a list -> int
val hd : 'a list -> 'a
val compare_lengths : 'a list -> 'b list -> int
val compare_length_with : 'a list -> len:int -> int
val cons : 'a -> 'a list -> 'a list
val tl : 'a list -> 'a list
val nth : 'a list -> int -> 'a
val nth_opt : 'a list -> int -> 'a option
val rev : 'a list -> 'a list
val init : len:int -> f:(int -> 'a) -> 'a list
val append : 'a list -> 'a list -> 'a list
val rev_append : 'a list -> 'a list -> 'a list
val concat : 'a list list -> 'a list
val flatten : 'a list list -> 'a list
val iter : f:('a -> unit) -> 'a list -> unit
val iteri : f:(int -> 'a -> unit) -> 'a list -> unit
val map : f:('a -> 'b) -> 'a list -> 'b list
val mapi : f:(int -> 'a -> 'b) -> 'a list -> 'b list
val rev_map : f:('a -> 'b) -> 'a list -> 'b list
val filter_map : f:('a -> 'b option) -> 'a list -> 'b list
val concat_map : f:('a -> 'b list) -> 'a list -> 'b list
val fold_left_map : f:('a -> 'b -> 'a * 'c) -> init:'a -> 'b list -> 'a * 'c list
val fold_left : f:('a -> 'b -> 'a) -> init:'a -> 'b list -> 'a
val fold_right : f:('a -> 'b -> 'b) -> 'a list -> init:'b -> 'b
val iter2 : f:('a -> 'b -> unit) -> 'a list -> 'b list -> unit
val map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val rev_map2 : f:('a -> 'b -> 'c) -> 'a list -> 'b list -> 'c list
val fold_left2 : f:('a -> 'b -> 'c -> 'a) -> init:'a -> 'b list -> 'c list -> 'a
val fold_right2 : f:('a -> 'b -> 'c -> 'c) -> 'a list -> 'b list -> init:'c -> 'c
val for_all : f:('a -> bool) -> 'a list -> bool
val exists : f:('a -> bool) -> 'a list -> bool
val for_all2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val exists2 : f:('a -> 'b -> bool) -> 'a list -> 'b list -> bool
val mem : 'a -> set:'a list -> bool
val memq : 'a -> set:'a list -> bool
val find : f:('a -> bool) -> 'a list -> 'a
val find_opt : f:('a -> bool) -> 'a list -> 'a option
val find_map : f:('a -> 'b option) -> 'a list -> 'b option
val filter : f:('a -> bool) -> 'a list -> 'a list
val find_all : f:('a -> bool) -> 'a list -> 'a list
val filteri : f:(int -> 'a -> bool) -> 'a list -> 'a list
val partition : f:('a -> bool) -> 'a list -> 'a list * 'a list
val assoc : 'a -> ('a * 'b) list -> 'b
val assoc_opt : 'a -> ('a * 'b) list -> 'b option
val assq : 'a -> ('a * 'b) list -> 'b
val assq_opt : 'a -> ('a * 'b) list -> 'b option
val mem_assoc : 'a -> map:('a * 'b) list -> bool
val mem_assq : 'a -> map:('a * 'b) list -> bool
val remove_assoc : 'a -> ('a * 'b) list -> ('a * 'b) list
val remove_assq : 'a -> ('a * 'b) list -> ('a * 'b) list
val split : ('a * 'b) list -> 'a list * 'b list
val combine : 'a list -> 'b list -> ('a * 'b) list
val sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val stable_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val fast_sort : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val sort_uniq : cmp:('a -> 'a -> int) -> 'a list -> 'a list
val merge : cmp:('a -> 'a -> int) -> 'a list -> 'a list -> 'a list
val to_seq : 'a list -> 'a Stdlib.Seq.t
val of_seq : 'a Stdlib.Seq.t -> 'a list
type 'a t = 'a list
val empty : 'a t
empty is [].
val is_empty : _ t -> bool
is_empty l returns true iff l = [].
since
0.11
val map : f:('a -> 'b) -> 'a t -> 'b t
map ~f [a0; a1; …; an] applies function f in turn to [a0; a1; …; an]. Safe version of List.map.
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
l >|= f is the infix version of map with reversed arguments.
since
0.5
val cons : 'a -> 'a t -> 'a t
cons x l is x::l.
since
0.12
val append : 'a t -> 'a t -> 'a t
append l1 l2 returns the list that is the concatenation of l1 and l2. Safe version of List.append.
val cons' : 'a t -> 'a -> 'a t
cons' l x is the same as x :: l. This is convenient for fold functions such as List.fold_left or Array.fold_left.
since
3.3
val cons_maybe : 'a option -> 'a t -> 'a t
cons_maybe (Some x) l is x :: l. cons_maybe None l is l.
since
0.13
val (@) : 'a t -> 'a t -> 'a t
l1 @ l2 is like append l1 l2. Concatenate the two lists l1 and l2.
val filter : f:('a -> bool) -> 'a t -> 'a t
filter ~f l returns all the elements of the list l that satisfy the predicate f. The order of the elements in the input list l is preserved. Safe version of List.filter.
val fold_right : f:('a -> 'b -> 'b) -> 'a t -> init:'b -> 'b
fold_right ~f [a1; …; an] ~init is f a1 (f a2 ( … (f an init) … )). Safe version of List.fold_right.
val fold_while : f:('a -> 'b -> 'a * [ `Stop | `Continue ]) -> init:'a -> 'b t -> 'a
fold_while ~f ~init l folds until a stop condition via ('a, `Stop) is indicated by the accumulator.
since
0.8
val fold_map : f:('acc -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list
fold_map ~f ~init l is a fold_left-like function, but it also maps the list to another list.
since
0.14
val fold_map_i : f:('acc -> int -> 'a -> 'acc * 'b) -> init:'acc -> 'a list -> 'acc * 'b list
fold_map_i ~f ~init l is a foldi-like function, but it also maps the list to another list.
since
2.8
val fold_on_map : f:('a -> 'b) -> reduce:('acc -> 'b -> 'acc) -> init:'acc -> 'a list -> 'acc
fold_on_map ~f ~reduce ~init l combines map ~f and fold_left ~reduce ~init in one operation.
since
2.8
val scan_left : f:('acc -> 'a -> 'acc) -> init:'acc -> 'a list -> 'acc list
scan_left ~f ~init l returns the list [init; f init x0; f (f init x0) x1; …] where x0, x1, etc. are the elements of l.
since
1.2, but only
since
2.2 with labels
val reduce : f:('a -> 'a -> 'a) -> 'a list -> 'a option
reduce f (hd::tl) returns Some (fold_left f hd tl). If l is empty, then None is returned.
since
3.2
val reduce_exn : f:('a -> 'a -> 'a) -> 'a list -> 'a
reduce_exn is the unsafe version of reduce.
raises Invalid_argument
if the given list is empty.
since
3.2
val fold_map2 : f:('acc -> 'a -> 'b -> 'acc * 'c) -> init:'acc -> 'a list -> 'b list -> 'acc * 'c list
fold_map2 ~f ~init l1 l2 is to fold_map what List.map2 is to List.map.
raises Invalid_argument
if the lists do not have the same length.
since
0.16
val fold_filter_map : f:('acc -> 'a -> 'acc * 'b option) -> init:'acc -> 'a list -> 'acc * 'b list
fold_filter_map ~f ~init l is a fold_left-like function, but also generates a list of output in a way similar to filter_map.
since
0.17
val fold_filter_map_i : f:('acc -> int -> 'a -> 'acc * 'b option) -> init:'acc -> 'a list -> 'acc * 'b list
fold_filter_map_i ~f ~init l is a foldi-like function, but also generates a list of output in a way similar to filter_map.
since
2.8
val fold_flat_map : f:('acc -> 'a -> 'acc * 'b list) -> init:'acc -> 'a list -> 'acc * 'b list
fold_flat_map ~f ~init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
0.14
val fold_flat_map_i : f:('acc -> int -> 'a -> 'acc * 'b list) -> init:'acc -> 'a list -> 'acc * 'b list
fold_flat_map_i ~f ~init l is a fold_left-like function, but it also maps the list to a list of lists that is then flatten'd.
since
2.8
val count : f:('a -> bool) -> 'a list -> int
count ~f l counts how many elements of l satisfy predicate f.
since
1.5, but only
since
2.2 with labels
val count_true_false : f:('a -> bool) -> 'a list -> int * int
count_true_false ~f l returns a pair (int1,int2) where int1 is the number of elements in l that satisfy the predicate f, and int2 the number of elements that do not satisfy f.
since
2.4
val init : int -> f:(int -> 'a) -> 'a t
init len ~f is f 0; f 1; …; f (len-1).
raises Invalid_argument
if len < 0.
since
0.6
val combine : 'a list -> 'b list -> ('a * 'b) list
combine [a1; …; an] [b1; …; bn] is [(a1,b1); …; (an,bn)]. Transform two lists into a list of pairs. Like List.combine but tail-recursive.
raises Invalid_argument
if the lists have distinct lengths.
since
1.2, but only
since
2.2 with labels
val combine_gen : 'a list -> 'b list -> ('a * 'b) gen
combine_gen l1 l2 transforms two lists into a gen of pairs. Lazy version of combine. Unlike combine, it does not fail if the lists have different lengths; instead, the output has as many pairs as the smallest input list.
since
1.2, but only
since
2.2 with labels
val combine_shortest : 'a list -> 'b list -> ('a * 'b) list
combine_shortest [a1; …; am] [b1; …; bn] is [(a1,b1); …; (am,bm)] if m <= n. Like combine but stops at the shortest list rather than raising.
since
3.1
val split : ('a * 'b) t -> 'a t * 'b t
split [(a1,b1); …; (an,bn)] is ([a1; …; an], [b1; …; bn]). Transform a list of pairs into a pair of lists. A tail-recursive version of List.split.
since
1.2, but only
since
2.2 with labels
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
compare cmp l1 l2 compares the two lists l1 and l2 using the given comparison function cmp.
val compare_lengths : 'a t -> 'b t -> int
compare_lengths l1 l2 compare the lengths of the two lists l1 and l2. Equivalent to compare (length l1) (length l2) but more efficient.
since
1.5, but only
since
2.2 with labels
val compare_length_with : 'a t -> int -> int
compare_length_with l x compares the length of the list l to an integer x. Equivalent to compare (length l) x but more efficient.
since
1.5, but only
since
2.2 with labels
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
equal p l1 l2 returns true if l1 and l2 are equal.
val flat_map : f:('a -> 'b t) -> 'a t -> 'b t
flat_map ~f l maps and flattens at the same time (safe). Evaluation order is not guaranteed.
val flat_map_i : f:(int -> 'a -> 'b t) -> 'a t -> 'b t
flat_map_i ~f l maps with index and flattens at the same time (safe). Evaluation order is not guaranteed.
since
2.8
val flatten : 'a t t -> 'a t
flatten [l1]; [l2]; … concatenates a list of lists. Safe version of List.flatten.
val product : f:('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
product ~f l1 l2 computes the cartesian product of the two lists, with the given combinator f.
val fold_product : f:('c -> 'a -> 'b -> 'c) -> init:'c -> 'a t -> 'b t -> 'c
fold_product ~f ~init l1 l2 applies the function f with the accumulator init on all the pair of elements of l1 and l2. Fold on the cartesian product.
val cartesian_product : 'a t t -> 'a t t
cartesian_product [[l1];[l2]; …; [ln]] produces the cartesian product of this list of lists, by returning all the ways of picking one element per sublist. NOTE the order of the returned list is unspecified. For example:
# cartesian_product [[1;2];[3];[4;5;6]] |> sort =
 [[1;3;4];[1;3;5];[1;3;6];[2;3;4];[2;3;5];[2;3;6]];;
 # cartesian_product [[1;2];[];[4;5;6]] = [];;
 # cartesian_product [[1;2];[3];[4];[5];[6]] |> sort =
-[[1;3;4;5;6];[2;3;4;5;6]];;
invariant: cartesian_product l = map_product id l.
since
1.2, but only
since
2.2 with labels
val map_product_l : f:('a -> 'b list) -> 'a list -> 'b list list
map_product_l ~f l maps each element of l to a list of objects of type 'b using f. We obtain [l1; l2; …; ln] where length l=n and li : 'b list. Then, it returns all the ways of picking exactly one element per li.
since
1.2, but only
since
2.2 with labels
val diagonal : 'a t -> ('a * 'a) t
diagonal l returns all pairs of distinct positions of the list l, that is the list of List.nth i l, List.nth j l if i < j.
val partition_map_either : f:('a -> ('b, 'c) CCEither.t) -> 'a list -> 'b list * 'c list
partition_map_either ~f l maps f on l and gather results in lists:
  • if f x = Left y, adds y to the first list.
  • if f x = Right z, adds z to the second list.
since
NEXT_RELEASE
val partition_filter_map : f:('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_filter_map ~f l maps f on l and gather results in lists:
  • if f x = `Left y, adds y to the first list.
  • if f x = `Right z, adds z to the second list.
  • if f x = `Drop, ignores x.
since
0.11
val partition_map : f:('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
deprecated
use partition_filter_map instead
val group_by : ?⁠hash:('a -> int) -> ?⁠eq:('a -> 'a -> bool) -> 'a t -> 'a list t
group_by ?hash ?eq l groups equal elements, regardless of their order of appearance. precondition: for any x and y, if eq x y then hash x = hash y must hold.
since
2.3
val join : join_row:('a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join ~join_row a b combines every element of a with every element of b using join_row. If join_row returns None, then the two elements do not combine. Assume that b allows for multiple iterations.
since
2.3
val join_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and combine values (x,y) from (a,b) with the same key using merge. If merge returns None, the combination of values is discarded. precondition: for any x and y, if eq x y then hash x = hash y must hold.
since
2.3
val join_all_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a list -> 'b list -> 'c option) -> 'a t -> 'b t -> 'c t
join_all_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and, for each key k occurring in at least one of them:
  • compute the list l1 of elements of a that map to k
  • compute the list l2 of elements of b that map to k
  • call merge k l1 l2. If merge returns None, the combination of values is discarded, otherwise it returns Some c and c is inserted in the result.
since
2.3
val group_join_by : ?⁠eq:('a -> 'a -> bool) -> ?⁠hash:('a -> int) -> ('b -> 'a) -> 'a t -> 'b t -> ('a * 'b list) t
group_join_by ?eq ?hash key la lb associates to every element x of the first sequence, all the elements y of the second sequence such that eq x (key y). Elements of the first sequences without corresponding values in the second one are mapped to [] precondition: for any x and y, if eq x y then hash x = hash y must hold.
since
2.3
val sublists_of_len : ?⁠last:('a list -> 'a list option) -> ?⁠offset:int -> len:int -> 'a list -> 'a list list
sublists_of_len ?last ?offset n l returns sub-lists of l that have length n. By default, these sub-lists are non overlapping: sublists_of_len 2 [1;2;3;4;5;6] returns [1;2]; [3;4]; [5;6].
Examples:
  • sublists_of_len 2 [1;2;3;4;5;6] = [[1;2]; [3;4]; [5;6]].
  • sublists_of_len 2 ~offset:3 [1;2;3;4;5;6] = [1;2];[4;5].
  • sublists_of_len 3 ~last:CCOpt.return [1;2;3;4] = [1;2;3];[4].
  • sublists_of_len 2 [1;2;3;4;5] = [[1;2]; [3;4]].
parameter offset
the number of elements skipped between two consecutive sub-lists. By default it is n. If offset < n, the sub-lists will overlap; if offset > n, some elements will not appear at all.
parameter last
if provided and the last group of elements g is such that length g < n, last g is called. If last g = Some g', g' is appended; otherwise g is dropped. If last = CCOpt.return, it will simply keep the last group. By default, last = fun _ -> None, i.e. the last group is dropped if shorter than n.
raises Invalid_argument
if offset <= 0 or n <= 0. See CCList.sublists_of_len for more details.
since
1.0, but only
since
1.5 with labels
val chunks : int -> 'a list -> 'a list list
chunks n l returns consecutives chunks of size at most n from l. Each item of l will occur in exactly one chunk. Only the last chunk might be of length smaller than n. Invariant: (chunks n l |> List.flatten) = l.
since
3.2
val intersperse : x:'a -> 'a list -> 'a list
intersperse ~x l inserts the element x between adjacent elements of the list l.
since
2.1, but only
since
2.2 with labels
val interleave : 'a list -> 'a list -> 'a list
interleave [x1…xn] [y1…ym] is [x1,y1,x2,y2,…] and finishes with the suffix of the longest list.
since
2.1, but only
since
2.2 with labels
val pure : 'a -> 'a t
pure x is return x.
val mguard : bool -> unit t
mguard c is pure () if c is true, [] otherwise. This is useful to define a list by comprehension, e.g.:
# let square_even xs =
+[[1;3;4;5;6];[2;3;4;5;6]];;
invariant: cartesian_product l = map_product id l.
since
1.2, but only
since
2.2 with labels
val map_product_l : f:('a -> 'b list) -> 'a list -> 'b list list
map_product_l ~f l maps each element of l to a list of objects of type 'b using f. We obtain [l1; l2; …; ln] where length l=n and li : 'b list. Then, it returns all the ways of picking exactly one element per li.
since
1.2, but only
since
2.2 with labels
val diagonal : 'a t -> ('a * 'a) t
diagonal l returns all pairs of distinct positions of the list l, that is the list of List.nth i l, List.nth j l if i < j.
val partition_map_either : f:('a -> ('b, 'c) CCEither.t) -> 'a list -> 'b list * 'c list
partition_map_either ~f l maps f on l and gather results in lists:
  • if f x = Left y, adds y to the first list.
  • if f x = Right z, adds z to the second list.
since
3.3
val partition_filter_map : f:('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_filter_map ~f l maps f on l and gather results in lists:
  • if f x = `Left y, adds y to the first list.
  • if f x = `Right z, adds z to the second list.
  • if f x = `Drop, ignores x.
since
0.11
val partition_map : f:('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
deprecated
use partition_filter_map instead
val group_by : ?⁠hash:('a -> int) -> ?⁠eq:('a -> 'a -> bool) -> 'a t -> 'a list t
group_by ?hash ?eq l groups equal elements, regardless of their order of appearance. precondition: for any x and y, if eq x y then hash x = hash y must hold.
since
2.3
val join : join_row:('a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join ~join_row a b combines every element of a with every element of b using join_row. If join_row returns None, then the two elements do not combine. Assume that b allows for multiple iterations.
since
2.3
val join_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a -> 'b -> 'c option) -> 'a t -> 'b t -> 'c t
join_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and combine values (x,y) from (a,b) with the same key using merge. If merge returns None, the combination of values is discarded. precondition: for any x and y, if eq x y then hash x = hash y must hold.
since
2.3
val join_all_by : ?⁠eq:('key -> 'key -> bool) -> ?⁠hash:('key -> int) -> ('a -> 'key) -> ('b -> 'key) -> merge:('key -> 'a list -> 'b list -> 'c option) -> 'a t -> 'b t -> 'c t
join_all_by ?eq ?hash key1 key2 ~merge la lb is a binary operation that takes two sequences a and b, projects their elements resp. with key1 and key2, and, for each key k occurring in at least one of them:
  • compute the list l1 of elements of a that map to k
  • compute the list l2 of elements of b that map to k
  • call merge k l1 l2. If merge returns None, the combination of values is discarded, otherwise it returns Some c and c is inserted in the result.
since
2.3
val group_join_by : ?⁠eq:('a -> 'a -> bool) -> ?⁠hash:('a -> int) -> ('b -> 'a) -> 'a t -> 'b t -> ('a * 'b list) t
group_join_by ?eq ?hash key la lb associates to every element x of the first sequence, all the elements y of the second sequence such that eq x (key y). Elements of the first sequences without corresponding values in the second one are mapped to [] precondition: for any x and y, if eq x y then hash x = hash y must hold.
since
2.3
val sublists_of_len : ?⁠last:('a list -> 'a list option) -> ?⁠offset:int -> len:int -> 'a list -> 'a list list
sublists_of_len ?last ?offset n l returns sub-lists of l that have length n. By default, these sub-lists are non overlapping: sublists_of_len 2 [1;2;3;4;5;6] returns [1;2]; [3;4]; [5;6].
Examples:
  • sublists_of_len 2 [1;2;3;4;5;6] = [[1;2]; [3;4]; [5;6]].
  • sublists_of_len 2 ~offset:3 [1;2;3;4;5;6] = [1;2];[4;5].
  • sublists_of_len 3 ~last:CCOpt.return [1;2;3;4] = [1;2;3];[4].
  • sublists_of_len 2 [1;2;3;4;5] = [[1;2]; [3;4]].
parameter offset
the number of elements skipped between two consecutive sub-lists. By default it is n. If offset < n, the sub-lists will overlap; if offset > n, some elements will not appear at all.
parameter last
if provided and the last group of elements g is such that length g < n, last g is called. If last g = Some g', g' is appended; otherwise g is dropped. If last = CCOpt.return, it will simply keep the last group. By default, last = fun _ -> None, i.e. the last group is dropped if shorter than n.
raises Invalid_argument
if offset <= 0 or n <= 0. See CCList.sublists_of_len for more details.
since
1.0, but only
since
1.5 with labels
val chunks : int -> 'a list -> 'a list list
chunks n l returns consecutives chunks of size at most n from l. Each item of l will occur in exactly one chunk. Only the last chunk might be of length smaller than n. Invariant: (chunks n l |> List.flatten) = l.
since
3.2
val intersperse : x:'a -> 'a list -> 'a list
intersperse ~x l inserts the element x between adjacent elements of the list l.
since
2.1, but only
since
2.2 with labels
val interleave : 'a list -> 'a list -> 'a list
interleave [x1…xn] [y1…ym] is [x1,y1,x2,y2,…] and finishes with the suffix of the longest list.
since
2.1, but only
since
2.2 with labels
val pure : 'a -> 'a t
pure x is return x.
val mguard : bool -> unit t
mguard c is pure () if c is true, [] otherwise. This is useful to define a list by comprehension, e.g.:
# let square_even xs =
       let* x = xs in
       let* () = mguard (x mod 2 = 0) in
       return @@ x * x;;
diff --git a/dev/containers/CCMap/module-type-S/index.html b/dev/containers/CCMap/module-type-S/index.html
index f75cec5a..bdddec8b 100644
--- a/dev/containers/CCMap/module-type-S/index.html
+++ b/dev/containers/CCMap/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (containers.CCMap.S)
Module type CCMap.S
include Stdlib.Map.S
type key
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge : (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : key -> 'a t -> 'a option
get k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.
val get_or : key -> 'a t -> default:'a -> 'a
get_or k m ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in m).
since
0.16
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
update k f m calls f (Some v) if find k m = v, otherwise it calls f None. In any case, if the result is None k is removed from m, and if the result is Some v' then add k v' m is returned.
val choose_opt : 'a t -> (key * 'a) option
choose_opt m returns one binding of the given map m, or None if m is empty. Safe version of choose.
since
1.5
val min_binding_opt : 'a t -> (key * 'a) option
min_binding_opt m returns the smallest binding of the given map m, or None if m is empty. Safe version of min_binding.
since
1.5
val max_binding_opt : 'a t -> (key * 'a) option
max_binding_opt m returns the largest binding of the given map m, or None if m is empty. Safe version of max_binding.
since
1.5
val find_opt : key -> 'a t -> 'a option
find_opt k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.
since
1.5
val find_first : (key -> bool) -> 'a t -> key * 'a
find_first f m where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists. See Map.S.find_first.
since
1.5
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
find_first_opt f m where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists. Safe version of find_first.
since
1.5
val merge_safe : f:(key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option) -> 'a t -> 'b t -> 'c t
merge_safe ~f a b merges the maps a and b together.
since
0.17
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t
add_seq m seq adds the given Seq.t of bindings to the map m. Like add_list. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t
add_seq ~f m l adds the given seq l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
NEXT_RELEASE
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
of_seq seq builds a map from the given Seq.t of bindings. Like of_list. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
of_seq_with ~f l builds a map from the given seq l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
NEXT_RELEASE
val add_iter : 'a t -> (key * 'a) iter -> 'a t
add_iter m iter adds the given iter of bindings to the map m. Like add_list.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) iter -> 'a t
add_iter ~f m l adds the given iter l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
NEXT_RELEASE
val of_iter : (key * 'a) iter -> 'a t
of_iter iter builds a map from the given iter of bindings. Like of_list.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) iter -> 'a t
of_iter_with ~f l builds a map from the given iter l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the iter than v2.
since
NEXT_RELEASE
val to_iter : 'a t -> (key * 'a) iter
to_iter m iterates on the whole map m, creating an iter of bindings. Like to_list.
since
2.8
val of_list : (key * 'a) list -> 'a t
of_list l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, only its last binding will be present in the result.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list_with ~f l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the list than v2.
since
NEXT_RELEASE
val add_list : 'a t -> (key * 'a) list -> 'a t
add_list m l adds the given list l of bindings to the map m.
since
0.14
val add_list_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) list -> 'a t
add_list ~f m l adds the given list l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
NEXT_RELEASE
val keys : _ t -> key iter
keys m iterates on the keys of m only, creating an iter of keys.
since
0.15
val values : 'a t -> 'a iter
values m iterates on the values of m only, creating an iter of values.
since
0.15
val to_list : 'a t -> (key * 'a) list
to_list m builds a list of the bindings of the given map m. The order is unspecified.
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_arrow:unit printer -> ?⁠pp_sep:unit printer -> key printer -> 'a printer -> 'a t printer
pp ?pp_start ?pp_stop ?pp_arrow ?pp_sep pp_key pp_v m pretty-prints the contents of the map.

\ No newline at end of file
+S (containers.CCMap.S)
Module type CCMap.S
include Stdlib.Map.S
type key
type +'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge : (key -> 'a option -> 'b option -> 'c option) -> 'a t -> 'b t -> 'c t
val union : (key -> 'a -> 'a -> 'a option) -> 'a t -> 'a t -> 'a t
val compare : ('a -> 'a -> int) -> 'a t -> 'a t -> int
val equal : ('a -> 'a -> bool) -> 'a t -> 'a t -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val for_all : (key -> 'a -> bool) -> 'a t -> bool
val exists : (key -> 'a -> bool) -> 'a t -> bool
val filter : (key -> 'a -> bool) -> 'a t -> 'a t
val filter_map : (key -> 'a -> 'b option) -> 'a t -> 'b t
val partition : (key -> 'a -> bool) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : (key -> bool) -> 'a t -> key * 'a
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
val find_last : (key -> bool) -> 'a t -> key * 'a
val find_last_opt : (key -> bool) -> 'a t -> (key * 'a) option
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (key -> 'a -> 'b) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : key -> 'a t -> 'a option
get k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.
val get_or : key -> 'a t -> default:'a -> 'a
get_or k m ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in m).
since
0.16
val update : key -> ('a option -> 'a option) -> 'a t -> 'a t
update k f m calls f (Some v) if find k m = v, otherwise it calls f None. In any case, if the result is None k is removed from m, and if the result is Some v' then add k v' m is returned.
val choose_opt : 'a t -> (key * 'a) option
choose_opt m returns one binding of the given map m, or None if m is empty. Safe version of choose.
since
1.5
val min_binding_opt : 'a t -> (key * 'a) option
min_binding_opt m returns the smallest binding of the given map m, or None if m is empty. Safe version of min_binding.
since
1.5
val max_binding_opt : 'a t -> (key * 'a) option
max_binding_opt m returns the largest binding of the given map m, or None if m is empty. Safe version of max_binding.
since
1.5
val find_opt : key -> 'a t -> 'a option
find_opt k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.
since
1.5
val find_first : (key -> bool) -> 'a t -> key * 'a
find_first f m where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists. See Map.S.find_first.
since
1.5
val find_first_opt : (key -> bool) -> 'a t -> (key * 'a) option
find_first_opt f m where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists. Safe version of find_first.
since
1.5
val merge_safe : f:(key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option) -> 'a t -> 'b t -> 'c t
merge_safe ~f a b merges the maps a and b together.
since
0.17
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t
add_seq m seq adds the given Seq.t of bindings to the map m. Like add_list. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t
add_seq ~f m l adds the given seq l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
of_seq seq builds a map from the given Seq.t of bindings. Like of_list. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
of_seq_with ~f l builds a map from the given seq l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
3.3
val add_iter : 'a t -> (key * 'a) iter -> 'a t
add_iter m iter adds the given iter of bindings to the map m. Like add_list.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) iter -> 'a t
add_iter ~f m l adds the given iter l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
3.3
val of_iter : (key * 'a) iter -> 'a t
of_iter iter builds a map from the given iter of bindings. Like of_list.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) iter -> 'a t
of_iter_with ~f l builds a map from the given iter l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the iter than v2.
since
3.3
val to_iter : 'a t -> (key * 'a) iter
to_iter m iterates on the whole map m, creating an iter of bindings. Like to_list.
since
2.8
val of_list : (key * 'a) list -> 'a t
of_list l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, only its last binding will be present in the result.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list_with ~f l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the list than v2.
since
3.3
val add_list : 'a t -> (key * 'a) list -> 'a t
add_list m l adds the given list l of bindings to the map m.
since
0.14
val add_list_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) list -> 'a t
add_list ~f m l adds the given list l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.
since
3.3
val keys : _ t -> key iter
keys m iterates on the keys of m only, creating an iter of keys.
since
0.15
val values : 'a t -> 'a iter
values m iterates on the values of m only, creating an iter of values.
since
0.15
val to_list : 'a t -> (key * 'a) list
to_list m builds a list of the bindings of the given map m. The order is unspecified.
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_arrow:unit printer -> ?⁠pp_sep:unit printer -> key printer -> 'a printer -> 'a t printer
pp ?pp_start ?pp_stop ?pp_arrow ?pp_sep pp_key pp_v m pretty-prints the contents of the map.

\ No newline at end of file
diff --git a/dev/containers/CCSeq/index.html b/dev/containers/CCSeq/index.html
index 9e33bb0b..2beb4fd7 100644
--- a/dev/containers/CCSeq/index.html
+++ b/dev/containers/CCSeq/index.html
@@ -1,2 +1,2 @@
 
-CCSeq (containers.CCSeq)
Module CCSeq
Helpers for the standard Seq type
See oseq for a richer API.
type 'a iter = ('a -> unit) -> unit
type 'a gen = unit -> 'a option
type 'a equal = 'a -> 'a -> bool
type 'a ord = 'a -> 'a -> int
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
Basics
type +'a t = unit -> 'a node
and +'a node = 'a Stdlib.Seq.node = 
| Nil
| Cons of 'a * 'a t
val nil : 'a t
val empty : 'a t
val cons : 'a -> 'a t -> 'a t
val singleton : 'a -> 'a t
val repeat : ?⁠n:int -> 'a -> 'a t
repeat ~n x repeats x n times then stops. If n is omitted, then x is repeated forever.
since
0.3.3
val cycle : 'a t -> 'a t
Cycle through the iterator infinitely. The iterator shouldn't be empty.
since
0.3.3
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
unfold f acc calls f acc and:
  • if f acc = Some (x, acc'), yield x, continue with unfold f acc'.
  • if f acc = None, stops.
since
0.13
val is_empty : 'a t -> bool
val head : 'a t -> 'a option
Head of the list.
since
0.13
val head_exn : 'a t -> 'a
Unsafe version of head.
raises Not_found
if the list is empty.
since
0.13
val tail : 'a t -> 'a t option
Tail of the list.
since
0.13
val tail_exn : 'a t -> 'a t
Unsafe version of tail.
raises Not_found
if the list is empty.
since
0.13
val equal : 'a equal -> 'a t equal
Equality step by step. Eager.
val compare : 'a ord -> 'a t ord
Lexicographic comparison. Eager.
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
Fold on values.
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
Alias for fold
val iter : ('a -> unit) -> 'a t -> unit
val iteri : (int -> 'a -> unit) -> 'a t -> unit
Iterate with index (starts at 0).
since
0.13
val length : _ t -> int
Number of elements in the list. Will not terminate if the list if infinite: use (for instance) take to make the list finite if necessary.
val take : int -> 'a t -> 'a t
val take_while : ('a -> bool) -> 'a t -> 'a t
val drop : int -> 'a t -> 'a t
val drop_while : ('a -> bool) -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
Map with index (starts at 0).
since
0.13
val fmap : ('a -> 'b option) -> 'a t -> 'b t
val filter : ('a -> bool) -> 'a t -> 'a t
val append : 'a t -> 'a t -> 'a t
val product_with : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
Fair product of two (possibly infinite) lists into a new list. Lazy. The first parameter is used to combine each pair of elements.
since
0.3.3
val product : 'a t -> 'b t -> ('a * 'b) t
Specialization of product_with producing tuples.
since
0.3.3
val group : 'a equal -> 'a t -> 'a t t
group eq l groups together consecutive elements that satisfy eq. Lazy. For instance group (=) [1;1;1;2;2;3;3;1] yields [1;1;1]; [2;2]; [3;3]; [1].
since
0.3.3
val uniq : 'a equal -> 'a t -> 'a t
uniq eq l returns l but removes consecutive duplicates. Lazy. In other words, if several values that are equal follow one another, only the first of them is kept.
since
0.3.3
val for_all : ('a -> bool) -> 'a t -> bool
for_all p [a1; ...; an] checks if all elements of the sequence satisfy the predicate p. That is, it returns (p a1) && ... && (p an) for a non-empty list and true if the sequence is empty. It consumes the sequence until it finds an element not satisfying the predicate.
since
NEXT_RELEASE
val exists : ('a -> bool) -> 'a t -> bool
exists p [a1; ...; an] checks if at least one element of the sequence satisfies the predicate p. That is, it returns (p a1) || ... || (p an) for a non-empty sequence and false if the list is empty. It consumes the sequence until it finds an element satisfying the predicate.
since
NEXT_RELEASE
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
val flatten : 'a t t -> 'a t
val range : int -> int -> int t
val (--) : int -> int -> int t
a -- b is the range of integers containing a and b (therefore, never empty).
val (--^) : int -> int -> int t
a -- b is the integer range from a to b, where b is excluded.
since
0.17
Operations on two Collections
val fold2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a t -> 'b t -> 'acc
Fold on two collections at once. Stop at soon as one of them ends.
val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
Map on two collections at once. Stop as soon as one of the arguments is exhausted.
val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit
Iterate on two collections at once. Stop as soon as one of them ends.
val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val merge : 'a ord -> 'a t -> 'a t -> 'a t
Merge two sorted iterators into a sorted iterator.
val zip : 'a t -> 'b t -> ('a * 'b) t
Combine elements pairwise. Stop as soon as one of the lists stops.
since
0.13
val unzip : ('a * 'b) t -> 'a t * 'b t
Split each tuple in the list.
since
0.13
Misc
val sort : cmp:'a ord -> 'a t -> 'a t
Eager sort. Require the iterator to be finite. O(n ln(n)) time and space.
since
0.3.3
val sort_uniq : cmp:'a ord -> 'a t -> 'a t
Eager sort that removes duplicate values. Require the iterator to be finite. O(n ln(n)) time and space.
since
0.3.3
val memoize : 'a t -> 'a t
Avoid recomputations by caching intermediate results.
since
0.14
Fair Combinations
val interleave : 'a t -> 'a t -> 'a t
Fair interleaving of both streams.
since
0.13
val fair_flat_map : ('a -> 'b t) -> 'a t -> 'b t
Fair version of flat_map.
since
0.13
val fair_app : ('a -> 'b) t -> 'a t -> 'b t
Fair version of (<*>).
since
0.13
Implementations
since
0.3.3
val return : 'a -> 'a t
val pure : 'a -> 'a t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
val (>>-) : 'a t -> ('a -> 'b t) -> 'b t
Infix version of fair_flat_map.
since
0.13
val (<.>) : ('a -> 'b) t -> 'a t -> 'b t
Infix version of fair_app.
since
0.13
Infix operators
since
0.17
module Infix : sig ... end
module type MONAD = sig ... end
module Traverse : functor (M : MONAD) -> sig ... end
Conversions
val of_list : 'a list -> 'a t
val to_list : 'a t -> 'a list
Gather all values into a list.
val of_array : 'a array -> 'a t
Iterate on the array.
since
0.13
val to_array : 'a t -> 'a array
Convert into array. Iterate twice.
since
0.13
val to_rev_list : 'a t -> 'a list
Convert to a list, in reverse order. More efficient than to_list.
val to_iter : 'a t -> 'a iter
val to_gen : 'a t -> 'a gen
val of_gen : 'a gen -> 'a t
of_gen g consumes the generator and caches intermediate results.
since
0.13
IO
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> 'a printer -> 'a t printer
pp ~pp_start ~pp_stop ~pp_sep pp_item ppf s formats the sequence s on ppf. Each element is formatted with pp_item, pp_start is called at the beginning, pp_stop is called at the end, pp_sep is called between each elements. By defaults pp_start and pp_stop does nothing and pp_sep defaults to (fun out -> Format.fprintf out ",@ ").

\ No newline at end of file
+CCSeq (containers.CCSeq)
Module CCSeq
Helpers for the standard Seq type
See oseq for a richer API.
type 'a iter = ('a -> unit) -> unit
type 'a gen = unit -> 'a option
type 'a equal = 'a -> 'a -> bool
type 'a ord = 'a -> 'a -> int
type 'a printer = Stdlib.Format.formatter -> 'a -> unit
Basics
type +'a t = unit -> 'a node
and +'a node = 'a Stdlib.Seq.node = 
| Nil
| Cons of 'a * 'a t
val nil : 'a t
val empty : 'a t
val cons : 'a -> 'a t -> 'a t
val singleton : 'a -> 'a t
val repeat : ?⁠n:int -> 'a -> 'a t
repeat ~n x repeats x n times then stops. If n is omitted, then x is repeated forever.
since
0.3.3
val cycle : 'a t -> 'a t
Cycle through the iterator infinitely. The iterator shouldn't be empty.
since
0.3.3
val unfold : ('b -> ('a * 'b) option) -> 'b -> 'a t
unfold f acc calls f acc and:
  • if f acc = Some (x, acc'), yield x, continue with unfold f acc'.
  • if f acc = None, stops.
since
0.13
val is_empty : 'a t -> bool
val head : 'a t -> 'a option
Head of the list.
since
0.13
val head_exn : 'a t -> 'a
Unsafe version of head.
raises Not_found
if the list is empty.
since
0.13
val tail : 'a t -> 'a t option
Tail of the list.
since
0.13
val tail_exn : 'a t -> 'a t
Unsafe version of tail.
raises Not_found
if the list is empty.
since
0.13
val equal : 'a equal -> 'a t equal
Equality step by step. Eager.
val compare : 'a ord -> 'a t ord
Lexicographic comparison. Eager.
val fold : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
Fold on values.
val fold_left : ('a -> 'b -> 'a) -> 'a -> 'b t -> 'a
Alias for fold
val iter : ('a -> unit) -> 'a t -> unit
val iteri : (int -> 'a -> unit) -> 'a t -> unit
Iterate with index (starts at 0).
since
0.13
val length : _ t -> int
Number of elements in the list. Will not terminate if the list if infinite: use (for instance) take to make the list finite if necessary.
val take : int -> 'a t -> 'a t
val take_while : ('a -> bool) -> 'a t -> 'a t
val drop : int -> 'a t -> 'a t
val drop_while : ('a -> bool) -> 'a t -> 'a t
val map : ('a -> 'b) -> 'a t -> 'b t
val mapi : (int -> 'a -> 'b) -> 'a t -> 'b t
Map with index (starts at 0).
since
0.13
val fmap : ('a -> 'b option) -> 'a t -> 'b t
val filter : ('a -> bool) -> 'a t -> 'a t
val append : 'a t -> 'a t -> 'a t
val product_with : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
Fair product of two (possibly infinite) lists into a new list. Lazy. The first parameter is used to combine each pair of elements.
since
0.3.3
val product : 'a t -> 'b t -> ('a * 'b) t
Specialization of product_with producing tuples.
since
0.3.3
val group : 'a equal -> 'a t -> 'a t t
group eq l groups together consecutive elements that satisfy eq. Lazy. For instance group (=) [1;1;1;2;2;3;3;1] yields [1;1;1]; [2;2]; [3;3]; [1].
since
0.3.3
val uniq : 'a equal -> 'a t -> 'a t
uniq eq l returns l but removes consecutive duplicates. Lazy. In other words, if several values that are equal follow one another, only the first of them is kept.
since
0.3.3
val for_all : ('a -> bool) -> 'a t -> bool
for_all p [a1; ...; an] checks if all elements of the sequence satisfy the predicate p. That is, it returns (p a1) && ... && (p an) for a non-empty list and true if the sequence is empty. It consumes the sequence until it finds an element not satisfying the predicate.
since
3.3
val exists : ('a -> bool) -> 'a t -> bool
exists p [a1; ...; an] checks if at least one element of the sequence satisfies the predicate p. That is, it returns (p a1) || ... || (p an) for a non-empty sequence and false if the list is empty. It consumes the sequence until it finds an element satisfying the predicate.
since
3.3
val flat_map : ('a -> 'b t) -> 'a t -> 'b t
val filter_map : ('a -> 'b option) -> 'a t -> 'b t
val flatten : 'a t t -> 'a t
val range : int -> int -> int t
val (--) : int -> int -> int t
a -- b is the range of integers containing a and b (therefore, never empty).
val (--^) : int -> int -> int t
a -- b is the integer range from a to b, where b is excluded.
since
0.17
Operations on two Collections
val fold2 : ('acc -> 'a -> 'b -> 'acc) -> 'acc -> 'a t -> 'b t -> 'acc
Fold on two collections at once. Stop at soon as one of them ends.
val map2 : ('a -> 'b -> 'c) -> 'a t -> 'b t -> 'c t
Map on two collections at once. Stop as soon as one of the arguments is exhausted.
val iter2 : ('a -> 'b -> unit) -> 'a t -> 'b t -> unit
Iterate on two collections at once. Stop as soon as one of them ends.
val for_all2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val exists2 : ('a -> 'b -> bool) -> 'a t -> 'b t -> bool
val merge : 'a ord -> 'a t -> 'a t -> 'a t
Merge two sorted iterators into a sorted iterator.
val zip : 'a t -> 'b t -> ('a * 'b) t
Combine elements pairwise. Stop as soon as one of the lists stops.
since
0.13
val unzip : ('a * 'b) t -> 'a t * 'b t
Split each tuple in the list.
since
0.13
Misc
val sort : cmp:'a ord -> 'a t -> 'a t
Eager sort. Require the iterator to be finite. O(n ln(n)) time and space.
since
0.3.3
val sort_uniq : cmp:'a ord -> 'a t -> 'a t
Eager sort that removes duplicate values. Require the iterator to be finite. O(n ln(n)) time and space.
since
0.3.3
val memoize : 'a t -> 'a t
Avoid recomputations by caching intermediate results.
since
0.14
Fair Combinations
val interleave : 'a t -> 'a t -> 'a t
Fair interleaving of both streams.
since
0.13
val fair_flat_map : ('a -> 'b t) -> 'a t -> 'b t
Fair version of flat_map.
since
0.13
val fair_app : ('a -> 'b) t -> 'a t -> 'b t
Fair version of (<*>).
since
0.13
Implementations
since
0.3.3
val return : 'a -> 'a t
val pure : 'a -> 'a t
val (>>=) : 'a t -> ('a -> 'b t) -> 'b t
val (>|=) : 'a t -> ('a -> 'b) -> 'b t
val (<*>) : ('a -> 'b) t -> 'a t -> 'b t
val (>>-) : 'a t -> ('a -> 'b t) -> 'b t
Infix version of fair_flat_map.
since
0.13
val (<.>) : ('a -> 'b) t -> 'a t -> 'b t
Infix version of fair_app.
since
0.13
Infix operators
since
0.17
module Infix : sig ... end
module type MONAD = sig ... end
module Traverse : functor (M : MONAD) -> sig ... end
Conversions
val of_list : 'a list -> 'a t
val to_list : 'a t -> 'a list
Gather all values into a list.
val of_array : 'a array -> 'a t
Iterate on the array.
since
0.13
val to_array : 'a t -> 'a array
Convert into array. Iterate twice.
since
0.13
val to_rev_list : 'a t -> 'a list
Convert to a list, in reverse order. More efficient than to_list.
val to_iter : 'a t -> 'a iter
val to_gen : 'a t -> 'a gen
val of_gen : 'a gen -> 'a t
of_gen g consumes the generator and caches intermediate results.
since
0.13
IO
val pp : ?⁠pp_start:unit printer -> ?⁠pp_stop:unit printer -> ?⁠pp_sep:unit printer -> 'a printer -> 'a t printer
pp ~pp_start ~pp_stop ~pp_sep pp_item ppf s formats the sequence s on ppf. Each element is formatted with pp_item, pp_start is called at the beginning, pp_stop is called at the end, pp_sep is called between each elements. By defaults pp_start and pp_stop does nothing and pp_sep defaults to (fun out -> Format.fprintf out ",@ ").

\ No newline at end of file
diff --git a/dev/containers/CCSexp/Decoder/index.html b/dev/containers/CCSexp/Decoder/index.html
index 7cd15c09..3bdef56e 100644
--- a/dev/containers/CCSexp/Decoder/index.html
+++ b/dev/containers/CCSexp/Decoder/index.html
@@ -1,2 +1,2 @@
 
-Decoder (containers.CCSexp.Decoder)
Module CCSexp.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list CCSexp_intf.or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
NEXT_RELEASE

\ No newline at end of file
+Decoder (containers.CCSexp.Decoder)
Module CCSexp.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list CCSexp_intf.or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
3.3

\ No newline at end of file
diff --git a/dev/containers/CCSexp/Make/Decoder/index.html b/dev/containers/CCSexp/Make/Decoder/index.html
index 39b3d921..29c30f22 100644
--- a/dev/containers/CCSexp/Make/Decoder/index.html
+++ b/dev/containers/CCSexp/Make/Decoder/index.html
@@ -1,2 +1,2 @@
 
-Decoder (containers.CCSexp.Make.Decoder)
Module Make.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list CCSexp_intf.or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
NEXT_RELEASE

\ No newline at end of file
+Decoder (containers.CCSexp.Make.Decoder)
Module Make.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list CCSexp_intf.or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
3.3

\ No newline at end of file
diff --git a/dev/containers/CCSexp/Make/index.html b/dev/containers/CCSexp/Make/index.html
index 6deec805..34f4f67e 100644
--- a/dev/containers/CCSexp/Make/index.html
+++ b/dev/containers/CCSexp/Make/index.html
@@ -1,2 +1,2 @@
 
-Make (containers.CCSexp.Make)
Module CCSexp.Make
Functorized operations
This builds a parser and printer for S-expressions represented as in the Sexp argument.
since
2.7
Parameters
Signature
include CCSexp_intf.S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t CCSexp_intf.or_error
Parse a string.
val parse_string_list : string -> t list CCSexp_intf.or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list CCSexp_intf.or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
NEXT_RELEASE
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end

\ No newline at end of file
+Make (containers.CCSexp.Make)
Module CCSexp.Make
Functorized operations
This builds a parser and printer for S-expressions represented as in the Sexp argument.
since
2.7
Parameters
Signature
include CCSexp_intf.S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t CCSexp_intf.or_error
Parse a string.
val parse_string_list : string -> t list CCSexp_intf.or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list CCSexp_intf.or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
3.3
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end

\ No newline at end of file
diff --git a/dev/containers/CCSexp/index.html b/dev/containers/CCSexp/index.html
index 8ab61aa8..8c5e0966 100644
--- a/dev/containers/CCSexp/index.html
+++ b/dev/containers/CCSexp/index.html
@@ -1,2 +1,2 @@
 
-CCSexp (containers.CCSexp)
Module CCSexp
Handling S-expressions
since
3.0 moved into containers-core, previously in [containers.sexp]
type 'a or_error = ('a, string) Stdlib.result
type 'a gen = unit -> 'a option
module type SEXP = CCSexp_intf.SEXP
module type S = CCSexp_intf.S
module Make : functor (Sexp : SEXP) -> S with type t = Sexp.t
Basics
type t = [ 
| `Atom of string
| `List of t list
 ]
A simple, structural representation of S-expressions.
include S with type S.t := t
include CCSexp_intf.S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t CCSexp_intf.or_error
Parse a string.
val parse_string_list : string -> t list CCSexp_intf.or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list CCSexp_intf.or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
NEXT_RELEASE
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end
val equal : t -> t -> bool
since
3.0
val compare : t -> t -> int
since
3.0
val atom : string -> t
Build an atom directly from a string.

\ No newline at end of file
+CCSexp (containers.CCSexp)
Module CCSexp
Handling S-expressions
since
3.0 moved into containers-core, previously in [containers.sexp]
type 'a or_error = ('a, string) Stdlib.result
type 'a gen = unit -> 'a option
module type SEXP = CCSexp_intf.SEXP
module type S = CCSexp_intf.S
module Make : functor (Sexp : SEXP) -> S with type t = Sexp.t
Basics
type t = [ 
| `Atom of string
| `List of t list
 ]
A simple, structural representation of S-expressions.
include S with type S.t := t
include CCSexp_intf.S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t CCSexp_intf.or_error
Parse a string.
val parse_string_list : string -> t list CCSexp_intf.or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list CCSexp_intf.or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
3.3
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end
val equal : t -> t -> bool
since
3.0
val compare : t -> t -> int
since
3.0
val atom : string -> t
Build an atom directly from a string.

\ No newline at end of file
diff --git a/dev/containers/CCSexp/module-type-S/Decoder/index.html b/dev/containers/CCSexp/module-type-S/Decoder/index.html
index f7ad3975..8305f1ee 100644
--- a/dev/containers/CCSexp/module-type-S/Decoder/index.html
+++ b/dev/containers/CCSexp/module-type-S/Decoder/index.html
@@ -1,2 +1,2 @@
 
-Decoder (containers.CCSexp.S.Decoder)
Module S.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list CCSexp_intf.or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
NEXT_RELEASE

\ No newline at end of file
+Decoder (containers.CCSexp.S.Decoder)
Module S.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list CCSexp_intf.or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
3.3

\ No newline at end of file
diff --git a/dev/containers/CCSexp/module-type-S/index.html b/dev/containers/CCSexp/module-type-S/index.html
index 2b363e8d..bbe51ab2 100644
--- a/dev/containers/CCSexp/module-type-S/index.html
+++ b/dev/containers/CCSexp/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (containers.CCSexp.S)
Module type CCSexp.S
Operations over S-expressions
since
2.7
include CCSexp_intf.S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t CCSexp_intf.or_error
Parse a string.
val parse_string_list : string -> t list CCSexp_intf.or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list CCSexp_intf.or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
NEXT_RELEASE
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end

\ No newline at end of file
+S (containers.CCSexp.S)
Module type CCSexp.S
Operations over S-expressions
since
2.7
include CCSexp_intf.S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t CCSexp_intf.iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t CCSexp_intf.or_error
Parse a string.
val parse_string_list : string -> t list CCSexp_intf.or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t CCSexp_intf.or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t CCSexp_intf.or_error CCSexp_intf.gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list CCSexp_intf.or_error
val parse_file : string -> t CCSexp_intf.or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list CCSexp_intf.or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
3.3
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end

\ No newline at end of file
diff --git a/dev/containers/CCSexp_intf/module-type-BASIC_SEXP/index.html b/dev/containers/CCSexp_intf/module-type-BASIC_SEXP/index.html
index 53d8d4b3..d4f9e4bc 100644
--- a/dev/containers/CCSexp_intf/module-type-BASIC_SEXP/index.html
+++ b/dev/containers/CCSexp_intf/module-type-BASIC_SEXP/index.html
@@ -1,2 +1,2 @@
 
-BASIC_SEXP (containers.CCSexp_intf.BASIC_SEXP)
Module type CCSexp_intf.BASIC_SEXP
Abstract representation of S-expressions
since
NEXT_RELEASE
type t
val atom : string -> t
val list : t list -> t
val match_ : t -> atom:(string -> 'a) -> list:(t list -> 'a) -> 'a

\ No newline at end of file
+BASIC_SEXP (containers.CCSexp_intf.BASIC_SEXP)
Module type CCSexp_intf.BASIC_SEXP
Abstract representation of S-expressions
since
3.3
type t
val atom : string -> t
val list : t list -> t
val match_ : t -> atom:(string -> 'a) -> list:(t list -> 'a) -> 'a

\ No newline at end of file
diff --git a/dev/containers/CCSexp_intf/module-type-S/Decoder/index.html b/dev/containers/CCSexp_intf/module-type-S/Decoder/index.html
index 9fce6232..d03b7d22 100644
--- a/dev/containers/CCSexp_intf/module-type-S/Decoder/index.html
+++ b/dev/containers/CCSexp_intf/module-type-S/Decoder/index.html
@@ -1,2 +1,2 @@
 
-Decoder (containers.CCSexp_intf.S.Decoder)
Module S.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
NEXT_RELEASE

\ No newline at end of file
+Decoder (containers.CCSexp_intf.S.Decoder)
Module S.Decoder
type t
Decoder
val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result
Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.
val to_list : t -> sexp list or_error
Read all the values from this decoder.
since
2.8
val last_loc : t -> loc option
Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.
since
3.3

\ No newline at end of file
diff --git a/dev/containers/CCSexp_intf/module-type-S/index.html b/dev/containers/CCSexp_intf/module-type-S/index.html
index d7447e76..fc2b6139 100644
--- a/dev/containers/CCSexp_intf/module-type-S/index.html
+++ b/dev/containers/CCSexp_intf/module-type-S/index.html
@@ -1,2 +1,2 @@
 
-S (containers.CCSexp_intf.S)
Module type CCSexp_intf.S
Operations over S-expressions (extended)
since
2.7
include S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t or_error
Parse a string.
val parse_string_list : string -> t list or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t or_error gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list or_error
val parse_file : string -> t or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
NEXT_RELEASE
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end

\ No newline at end of file
+S (containers.CCSexp_intf.S)
Module type CCSexp_intf.S
Operations over S-expressions (extended)
since
2.7
include S0
type t
type sexp = t
Re-exports
val atom : string -> t
Make an atom out of this string.
since
2.8
val list : t list -> t
Make a Sexpr of this list.
since
2.8
Constructors
val of_int : int -> t
val of_bool : bool -> t
val of_list : t list -> t
val of_rev_list : t list -> t
Reverse the list.
val of_float : float -> t
val of_unit : t
val of_pair : (t * t) -> t
val of_triple : (t * t * t) -> t
val of_quad : (t * t * t * t) -> t
val of_variant : string -> t list -> t
of_variant name args is used to encode algebraic variants into a S-expr. For instance of_variant "some" [of_int 1] represents the value Some 1.
val of_field : string -> t -> t
Used to represent one record field.
val of_record : (string * t) list -> t
Represent a record by its named fields.
Printing
val to_buf : Stdlib.Buffer.t -> t -> unit
val to_string : t -> string
val to_file : string -> t -> unit
val to_file_iter : string -> t iter -> unit
Print the given iter of expressions to a file.
val to_chan : Stdlib.out_channel -> t -> unit
val pp : Stdlib.Format.formatter -> t -> unit
Pretty-printer nice on human eyes (including indentation).
val pp_noindent : Stdlib.Format.formatter -> t -> unit
Raw, direct printing as compact as possible.
Parsing
val parse_string : string -> t or_error
Parse a string.
val parse_string_list : string -> t list or_error
Parse a string into a list of S-exprs.
since
2.8
val parse_chan : Stdlib.in_channel -> t or_error
Parse a S-expression from the given channel. Can read more data than necessary, so don't use this if you need finer-grained control (e.g. to read something else after the S-exp).
val parse_chan_gen : Stdlib.in_channel -> t or_error gen
Parse a channel into a generator of S-expressions.
val parse_chan_list : Stdlib.in_channel -> t list or_error
val parse_file : string -> t or_error
Open the file and read a S-exp from it.
val parse_file_list : string -> t list or_error
Open the file and read a S-exp from it.
type loc
Locations for the S-expressions.
since
3.3
Parsing
type 'a parse_result = 
| Yield of 'a
| Fail of string
| End
A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.
module Decoder : sig ... end

\ No newline at end of file
diff --git a/dev/containers/CCString/index.html b/dev/containers/CCString/index.html
index e143ed1b..338c745f 100644
--- a/dev/containers/CCString/index.html
+++ b/dev/containers/CCString/index.html
@@ -1,2 +1,2 @@
 
-CCString (containers.CCString)
Module CCString
Basic String Utils
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
Documentation for the standard String module
include module type of sig ... end
val length : string -> int
val get : string -> int -> char
val set : bytes -> int -> char -> unit
val create : int -> bytes
val make : int -> char -> string
val init : int -> (int -> char) -> string
val copy : string -> string
val sub : string -> int -> int -> string
val fill : bytes -> int -> int -> char -> unit
val blit : string -> int -> bytes -> int -> int -> unit
val concat : string -> string list -> string
val iter : (char -> unit) -> string -> unit
val iteri : (int -> char -> unit) -> string -> unit
val map : (char -> char) -> string -> string
val mapi : (int -> char -> char) -> string -> string
val trim : string -> string
val escaped : string -> string
val index : string -> char -> int
val index_opt : string -> char -> int option
val rindex : string -> char -> int
val rindex_opt : string -> char -> int option
val index_from : string -> int -> char -> int
val index_from_opt : string -> int -> char -> int option
val rindex_from : string -> int -> char -> int
val rindex_from_opt : string -> int -> char -> int option
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val uppercase_ascii : string -> string
val lowercase_ascii : string -> string
val capitalize_ascii : string -> string
val uncapitalize_ascii : string -> string
type t = string
val compare : t -> t -> int
val equal : t -> t -> bool
val split_on_char : char -> string -> string list
val to_seq : t -> char Stdlib.Seq.t
val to_seqi : t -> (int * char) Stdlib.Seq.t
val of_seq : char Stdlib.Seq.t -> t
val unsafe_get : string -> int -> char
val unsafe_set : bytes -> int -> char -> unit
val unsafe_blit : string -> int -> bytes -> int -> int -> unit
val unsafe_fill : bytes -> int -> int -> char -> unit
val length : t -> int
length s returns the length (number of characters) of the given string s.
val blit : t -> int -> Stdlib.Bytes.t -> int -> int -> unit
blit src src_pos dst dst_pos len copies len characters from string src starting at character indice src_pos, to the Bytes sequence dst starting at character indice dst_pos. Like String.blit. Compatible with the -safe-string option.
raises Invalid_argument
if indices are not valid.
val fold : ('a -> char -> 'a) -> 'a -> t -> 'a
fold f init s folds on chars by increasing index. Computes f(… (f (f init s.[0]) s.[1]) …) s.[n-1].
since
0.7
val foldi : ('a -> int -> char -> 'a) -> 'a -> t -> 'a
foldi f init s is just like fold, but it also passes in the index of each chars as second argument to the folded function f.
since
NEXT_RELEASE
Conversions
val to_gen : t -> char gen
to_gen s returns the gen of characters contained in the string s.
val to_iter : t -> char iter
to_iter s returns the iter of characters contained in the string s.
since
2.8
val to_seq : t -> char Stdlib.Seq.t
to_seq s returns the Seq.t of characters contained in the string s. Renamed from to std_seq since 3.0.
since
3.0
val to_list : t -> char list
to_list s returns the list of characters contained in the string s.
val pp_buf : Stdlib.Buffer.t -> t -> unit
pp_buf buf s prints s to the buffer buf. Renamed from pp since 2.0.
val pp : Stdlib.Format.formatter -> t -> unit
pp f s prints the string s within quotes to the formatter f. Renamed from print since 2.0.
val compare : string -> string -> int
compare s1 s2 compares the strings s1 and s2 and returns an integer that indicates their relative position in the sort order.
val is_empty : string -> bool
is_empty s returns true iff s is empty (i.e. its length is 0).
since
1.5
val hash : string -> int
hash s returns the hash value of s.
val rev : string -> string
rev s returns the reverse of s.
since
0.17
val pad : ?⁠side:[ `Left | `Right ] -> ?⁠c:char -> int -> string -> string
pad ~side ~c n s ensures that the string s is at least n bytes long, and pads it on the side with c if it's not the case.
parameter side
determines where padding occurs (default: `Left).
parameter c
the char used to pad (default: ' ').
since
0.17
val of_char : char -> string
of_char 'a' is "a".
since
0.19
val of_gen : char gen -> string
of_gen gen converts a gen of characters to a string.
val of_iter : char iter -> string
of_iter iter converts an iter of characters to a string.
since
2.8
val of_seq : char Stdlib.Seq.t -> string
of_seq seq converts a seq of characters to a string. Renamed from of_std_seq since 3.0.
since
3.0
val of_list : char list -> string
of_list lc converts a list of characters lc to a string.
val of_array : char array -> string
of_array ac converts an array of characters ac to a string.
val to_array : string -> char array
to_array s returns the array of characters contained in the string s.
val find : ?⁠start:int -> sub:string -> string -> int
find ~start ~sub s returns the starting index of the first occurrence of sub within s or -1.
parameter start
starting position in s.
val find_all : ?⁠start:int -> sub:string -> string -> int gen
find_all ~start ~sub s finds all occurrences of sub in s, even overlapping instances and returns them in a generator gen.
parameter start
starting position in s.
since
0.17
val find_all_l : ?⁠start:int -> sub:string -> string -> int list
find_all_l ~sub s finds all occurrences of sub in s and returns them in a list.
parameter start
starting position in s.
since
0.17
val mem : ?⁠start:int -> sub:string -> string -> bool
mem ~start ~sub s is true iff sub is a substring of s.
since
0.12
val rfind : sub:string -> string -> int
rfind ~sub s finds sub in string s from the right, returns its first index or -1. Should only be used with very small sub.
since
0.12
val replace : ?⁠which:[ `Left | `Right | `All ] -> sub:string -> by:string -> string -> string
replace ~which ~sub ~by s replaces some occurrences of sub by by in s.
parameter which
decides whether the occurrences to replace are:
  • `Left first occurrence from the left (beginning).
  • `Right first occurrence from the right (end).
  • `All all occurrences (default).
raises Invalid_argument
if sub = "".
since
0.14
val is_sub : sub:string -> int -> string -> int -> sub_len:int -> bool
is_sub ~sub ~sub_pos s ~pos ~sub_len returns true iff the substring of sub starting at position sub_pos and of length sub_len is a substring of s starting at position pos.
val repeat : string -> int -> string
repeat s n creates a string by repeating the string s n times.
val prefix : pre:string -> string -> bool
prefix ~pre s returns true iff pre is a prefix of s.
val suffix : suf:string -> string -> bool
suffix ~suf s returns true iff suf is a suffix of s.
since
0.7
val chop_prefix : pre:string -> string -> string option
chop_prefix ~pre s removes pre from s if pre really is a prefix of s, returns None otherwise.
since
0.17
val chop_suffix : suf:string -> string -> string option
chop_suffix ~suf s removes suf from s if suf really is a suffix of s, returns None otherwise.
since
0.17
val take : int -> string -> string
take n s keeps only the n first chars of s.
since
0.17
val drop : int -> string -> string
drop n s removes the n first chars of s.
since
0.17
val take_drop : int -> string -> string * string
take_drop n s is take n s, drop n s.
since
0.17
val lines : string -> string list
lines s returns a list of the lines of s (splits along '\n').
since
0.10
val lines_gen : string -> string gen
lines_gen s returns the gen of the lines of s (splits along '\n').
since
0.10
val lines_iter : string -> string iter
lines_iter s returns the iter of the lines of s (splits along '\n').
since
3.2
val lines_seq : string -> string Stdlib.Seq.t
lines_seq s returns the Seq.t of the lines of s (splits along '\n').
since
3.2
val concat_gen : sep:string -> string gen -> string
concat_gen ~sep gen concatenates all strings of gen, separated with sep.
since
0.10
val concat_seq : sep:string -> string Stdlib.Seq.t -> string
concat_seq ~sep seq concatenates all strings of seq, separated with sep.
since
3.2
val concat_iter : sep:string -> string iter -> string
concat_iter ~sep iter concatenates all strings of iter, separated with sep.
since
3.2
val unlines : string list -> string
unlines ls concatenates all strings of ls, separated with '\n'.
since
0.10
val unlines_gen : string gen -> string
unlines_gen gen concatenates all strings of gen, separated with '\n'.
since
0.10
val unlines_iter : string iter -> string
unlines_iter iter concatenates all strings of iter, separated with '\n'.
since
3.2
val unlines_seq : string Stdlib.Seq.t -> string
unlines_seq seq concatenates all strings of seq, separated with '\n'.
since
3.2
val set : string -> int -> char -> string
set s i c creates a new string which is a copy of s, except for index i, which becomes c.
raises Invalid_argument
if i is an invalid index.
since
0.12
val iter : (char -> unit) -> string -> unit
iter f s applies function f on each character of s. Alias to String.iter.
since
0.12
val filter_map : (char -> char option) -> string -> string
filter_map f s calls (f a0) (f a1) … (f an) where a0 … an are the characters of s. It returns the string of characters ci such as f ai = Some ci (when f returns None, the corresponding element of s is discarded).
since
0.17
val filter : (char -> bool) -> string -> string
filter f s discards characters of s not satisfying f.
since
0.17
val flat_map : ?⁠sep:string -> (char -> string) -> string -> string
flat_map ~sep f s maps each chars of s to a string, then concatenates them all.
parameter sep
optional separator between each generated string.
since
0.12
val for_all : (char -> bool) -> string -> bool
for_all f s is true iff all characters of s satisfy the predicate f.
since
0.12
val exists : (char -> bool) -> string -> bool
exists f s is true iff some character of s satisfy the predicate f.
since
0.12
val drop_while : (char -> bool) -> t -> t
drop_while f s discards any characters of s starting from the left, up to the first character c not satisfying f c.
since
2.2
val rdrop_while : (char -> bool) -> t -> t
rdrop_while f s discards any characters of s starting from the right, up to the first character c not satisfying f c.
since
2.2
val ltrim : t -> t
ltrim s trims space on the left (see String.trim for more details).
since
1.2
val rtrim : t -> t
rtrim s trims space on the right (see String.trim for more details).
since
1.2
Operations on 2 strings
val map2 : (char -> char -> char) -> string -> string -> string
map2 f s1 s2 maps pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iter2 : (char -> char -> unit) -> string -> string -> unit
iter2 f s1 s2 iterates on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iteri2 : (int -> char -> char -> unit) -> string -> string -> unit
iteri2 f s1 s2 iterates on pairs of chars with their index.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val fold2 : ('a -> char -> char -> 'a) -> 'a -> string -> string -> 'a
fold2 f init s1 s2 folds on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val for_all2 : (char -> char -> bool) -> string -> string -> bool
for_all2 f s1 s2 returns true iff all pairs of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val exists2 : (char -> char -> bool) -> string -> string -> bool
exists2 f s1 s2 returns true iff a pair of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
Ascii functions
Those functions are deprecated in String since 4.03, so we provide a stable alias for them even in older versions.
val equal_caseless : string -> string -> bool
equal_caseless s1 s2 compares s1 and s2 without respect to ascii lowercase.
since
1.2
Finding
A relatively efficient algorithm for finding sub-strings.
since
1.0
module Find : sig ... end
Splitting
module Split : sig ... end
val split_on_char : char -> string -> string list
split_on_char by s splits the string s along the given char by.
since
1.2
val split : by:string -> string -> string list
split ~by s splits the string s along the given string by. Alias to Split.list_cpy.
since
1.2
Utils
val compare_versions : string -> string -> int
compare_versions s1 s2 compares version strings s1 and s2, considering that numbers are above text.
since
0.13
val compare_natural : string -> string -> int
compare_natural s1 s2 is the Natural Sort Order, comparing chunks of digits as natural numbers. https://en.wikipedia.org/wiki/Natural_sort_order
since
1.3
val edit_distance : ?⁠cutoff:int -> string -> string -> int
edit_distance ~cutoff s1 s2 is the edition distance between the two strings s1 and s2. This satisfies the classical distance axioms: it is always positive, symmetric, and satisfies the formula distance s1 s2 + distance s2 s3 >= distance s1 s3.
parameter cutoff
if provided, it's a cap on both the number of iterations, and on the result. (since 3.0). This is useful if you just want to check whether the edit distance is less or equal than 2 (use cutoff of 3).
Infix operators
since
3.0
module Infix : sig ... end
include module type of Infix
val (=) : t -> t -> bool
since
3.0
val (<>) : t -> t -> bool
since
3.0
val (<) : t -> t -> bool
since
3.0
val (<=) : t -> t -> bool
since
3.0
val (>=) : t -> t -> bool
since
3.0
val (>) : t -> t -> bool
since
3.0

\ No newline at end of file
+CCString (containers.CCString)
Module CCString
Basic String Utils
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
Documentation for the standard String module
include module type of sig ... end
val length : string -> int
val get : string -> int -> char
val set : bytes -> int -> char -> unit
val create : int -> bytes
val make : int -> char -> string
val init : int -> (int -> char) -> string
val copy : string -> string
val sub : string -> int -> int -> string
val fill : bytes -> int -> int -> char -> unit
val blit : string -> int -> bytes -> int -> int -> unit
val concat : string -> string list -> string
val iter : (char -> unit) -> string -> unit
val iteri : (int -> char -> unit) -> string -> unit
val map : (char -> char) -> string -> string
val mapi : (int -> char -> char) -> string -> string
val trim : string -> string
val escaped : string -> string
val index : string -> char -> int
val index_opt : string -> char -> int option
val rindex : string -> char -> int
val rindex_opt : string -> char -> int option
val index_from : string -> int -> char -> int
val index_from_opt : string -> int -> char -> int option
val rindex_from : string -> int -> char -> int
val rindex_from_opt : string -> int -> char -> int option
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val uppercase_ascii : string -> string
val lowercase_ascii : string -> string
val capitalize_ascii : string -> string
val uncapitalize_ascii : string -> string
type t = string
val compare : t -> t -> int
val equal : t -> t -> bool
val split_on_char : char -> string -> string list
val to_seq : t -> char Stdlib.Seq.t
val to_seqi : t -> (int * char) Stdlib.Seq.t
val of_seq : char Stdlib.Seq.t -> t
val unsafe_get : string -> int -> char
val unsafe_set : bytes -> int -> char -> unit
val unsafe_blit : string -> int -> bytes -> int -> int -> unit
val unsafe_fill : bytes -> int -> int -> char -> unit
val length : t -> int
length s returns the length (number of characters) of the given string s.
val blit : t -> int -> Stdlib.Bytes.t -> int -> int -> unit
blit src src_pos dst dst_pos len copies len characters from string src starting at character indice src_pos, to the Bytes sequence dst starting at character indice dst_pos. Like String.blit. Compatible with the -safe-string option.
raises Invalid_argument
if indices are not valid.
val fold : ('a -> char -> 'a) -> 'a -> t -> 'a
fold f init s folds on chars by increasing index. Computes f(… (f (f init s.[0]) s.[1]) …) s.[n-1].
since
0.7
val foldi : ('a -> int -> char -> 'a) -> 'a -> t -> 'a
foldi f init s is just like fold, but it also passes in the index of each chars as second argument to the folded function f.
since
3.3
Conversions
val to_gen : t -> char gen
to_gen s returns the gen of characters contained in the string s.
val to_iter : t -> char iter
to_iter s returns the iter of characters contained in the string s.
since
2.8
val to_seq : t -> char Stdlib.Seq.t
to_seq s returns the Seq.t of characters contained in the string s. Renamed from to std_seq since 3.0.
since
3.0
val to_list : t -> char list
to_list s returns the list of characters contained in the string s.
val pp_buf : Stdlib.Buffer.t -> t -> unit
pp_buf buf s prints s to the buffer buf. Renamed from pp since 2.0.
val pp : Stdlib.Format.formatter -> t -> unit
pp f s prints the string s within quotes to the formatter f. Renamed from print since 2.0.
val compare : string -> string -> int
compare s1 s2 compares the strings s1 and s2 and returns an integer that indicates their relative position in the sort order.
val is_empty : string -> bool
is_empty s returns true iff s is empty (i.e. its length is 0).
since
1.5
val hash : string -> int
hash s returns the hash value of s.
val rev : string -> string
rev s returns the reverse of s.
since
0.17
val pad : ?⁠side:[ `Left | `Right ] -> ?⁠c:char -> int -> string -> string
pad ~side ~c n s ensures that the string s is at least n bytes long, and pads it on the side with c if it's not the case.
parameter side
determines where padding occurs (default: `Left).
parameter c
the char used to pad (default: ' ').
since
0.17
val of_char : char -> string
of_char 'a' is "a".
since
0.19
val of_gen : char gen -> string
of_gen gen converts a gen of characters to a string.
val of_iter : char iter -> string
of_iter iter converts an iter of characters to a string.
since
2.8
val of_seq : char Stdlib.Seq.t -> string
of_seq seq converts a seq of characters to a string. Renamed from of_std_seq since 3.0.
since
3.0
val of_list : char list -> string
of_list lc converts a list of characters lc to a string.
val of_array : char array -> string
of_array ac converts an array of characters ac to a string.
val to_array : string -> char array
to_array s returns the array of characters contained in the string s.
val find : ?⁠start:int -> sub:string -> string -> int
find ~start ~sub s returns the starting index of the first occurrence of sub within s or -1.
parameter start
starting position in s.
val find_all : ?⁠start:int -> sub:string -> string -> int gen
find_all ~start ~sub s finds all occurrences of sub in s, even overlapping instances and returns them in a generator gen.
parameter start
starting position in s.
since
0.17
val find_all_l : ?⁠start:int -> sub:string -> string -> int list
find_all_l ~sub s finds all occurrences of sub in s and returns them in a list.
parameter start
starting position in s.
since
0.17
val mem : ?⁠start:int -> sub:string -> string -> bool
mem ~start ~sub s is true iff sub is a substring of s.
since
0.12
val rfind : sub:string -> string -> int
rfind ~sub s finds sub in string s from the right, returns its first index or -1. Should only be used with very small sub.
since
0.12
val replace : ?⁠which:[ `Left | `Right | `All ] -> sub:string -> by:string -> string -> string
replace ~which ~sub ~by s replaces some occurrences of sub by by in s.
parameter which
decides whether the occurrences to replace are:
  • `Left first occurrence from the left (beginning).
  • `Right first occurrence from the right (end).
  • `All all occurrences (default).
raises Invalid_argument
if sub = "".
since
0.14
val is_sub : sub:string -> int -> string -> int -> sub_len:int -> bool
is_sub ~sub ~sub_pos s ~pos ~sub_len returns true iff the substring of sub starting at position sub_pos and of length sub_len is a substring of s starting at position pos.
val repeat : string -> int -> string
repeat s n creates a string by repeating the string s n times.
val prefix : pre:string -> string -> bool
prefix ~pre s returns true iff pre is a prefix of s.
val suffix : suf:string -> string -> bool
suffix ~suf s returns true iff suf is a suffix of s.
since
0.7
val chop_prefix : pre:string -> string -> string option
chop_prefix ~pre s removes pre from s if pre really is a prefix of s, returns None otherwise.
since
0.17
val chop_suffix : suf:string -> string -> string option
chop_suffix ~suf s removes suf from s if suf really is a suffix of s, returns None otherwise.
since
0.17
val take : int -> string -> string
take n s keeps only the n first chars of s.
since
0.17
val drop : int -> string -> string
drop n s removes the n first chars of s.
since
0.17
val take_drop : int -> string -> string * string
take_drop n s is take n s, drop n s.
since
0.17
val lines : string -> string list
lines s returns a list of the lines of s (splits along '\n').
since
0.10
val lines_gen : string -> string gen
lines_gen s returns the gen of the lines of s (splits along '\n').
since
0.10
val lines_iter : string -> string iter
lines_iter s returns the iter of the lines of s (splits along '\n').
since
3.2
val lines_seq : string -> string Stdlib.Seq.t
lines_seq s returns the Seq.t of the lines of s (splits along '\n').
since
3.2
val concat_gen : sep:string -> string gen -> string
concat_gen ~sep gen concatenates all strings of gen, separated with sep.
since
0.10
val concat_seq : sep:string -> string Stdlib.Seq.t -> string
concat_seq ~sep seq concatenates all strings of seq, separated with sep.
since
3.2
val concat_iter : sep:string -> string iter -> string
concat_iter ~sep iter concatenates all strings of iter, separated with sep.
since
3.2
val unlines : string list -> string
unlines ls concatenates all strings of ls, separated with '\n'.
since
0.10
val unlines_gen : string gen -> string
unlines_gen gen concatenates all strings of gen, separated with '\n'.
since
0.10
val unlines_iter : string iter -> string
unlines_iter iter concatenates all strings of iter, separated with '\n'.
since
3.2
val unlines_seq : string Stdlib.Seq.t -> string
unlines_seq seq concatenates all strings of seq, separated with '\n'.
since
3.2
val set : string -> int -> char -> string
set s i c creates a new string which is a copy of s, except for index i, which becomes c.
raises Invalid_argument
if i is an invalid index.
since
0.12
val iter : (char -> unit) -> string -> unit
iter f s applies function f on each character of s. Alias to String.iter.
since
0.12
val filter_map : (char -> char option) -> string -> string
filter_map f s calls (f a0) (f a1) … (f an) where a0 … an are the characters of s. It returns the string of characters ci such as f ai = Some ci (when f returns None, the corresponding element of s is discarded).
since
0.17
val filter : (char -> bool) -> string -> string
filter f s discards characters of s not satisfying f.
since
0.17
val flat_map : ?⁠sep:string -> (char -> string) -> string -> string
flat_map ~sep f s maps each chars of s to a string, then concatenates them all.
parameter sep
optional separator between each generated string.
since
0.12
val for_all : (char -> bool) -> string -> bool
for_all f s is true iff all characters of s satisfy the predicate f.
since
0.12
val exists : (char -> bool) -> string -> bool
exists f s is true iff some character of s satisfy the predicate f.
since
0.12
val drop_while : (char -> bool) -> t -> t
drop_while f s discards any characters of s starting from the left, up to the first character c not satisfying f c.
since
2.2
val rdrop_while : (char -> bool) -> t -> t
rdrop_while f s discards any characters of s starting from the right, up to the first character c not satisfying f c.
since
2.2
val ltrim : t -> t
ltrim s trims space on the left (see String.trim for more details).
since
1.2
val rtrim : t -> t
rtrim s trims space on the right (see String.trim for more details).
since
1.2
Operations on 2 strings
val map2 : (char -> char -> char) -> string -> string -> string
map2 f s1 s2 maps pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iter2 : (char -> char -> unit) -> string -> string -> unit
iter2 f s1 s2 iterates on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iteri2 : (int -> char -> char -> unit) -> string -> string -> unit
iteri2 f s1 s2 iterates on pairs of chars with their index.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val fold2 : ('a -> char -> char -> 'a) -> 'a -> string -> string -> 'a
fold2 f init s1 s2 folds on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val for_all2 : (char -> char -> bool) -> string -> string -> bool
for_all2 f s1 s2 returns true iff all pairs of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val exists2 : (char -> char -> bool) -> string -> string -> bool
exists2 f s1 s2 returns true iff a pair of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
Ascii functions
Those functions are deprecated in String since 4.03, so we provide a stable alias for them even in older versions.
val equal_caseless : string -> string -> bool
equal_caseless s1 s2 compares s1 and s2 without respect to ascii lowercase.
since
1.2
Finding
A relatively efficient algorithm for finding sub-strings.
since
1.0
module Find : sig ... end
Splitting
module Split : sig ... end
val split_on_char : char -> string -> string list
split_on_char by s splits the string s along the given char by.
since
1.2
val split : by:string -> string -> string list
split ~by s splits the string s along the given string by. Alias to Split.list_cpy.
since
1.2
Utils
val compare_versions : string -> string -> int
compare_versions s1 s2 compares version strings s1 and s2, considering that numbers are above text.
since
0.13
val compare_natural : string -> string -> int
compare_natural s1 s2 is the Natural Sort Order, comparing chunks of digits as natural numbers. https://en.wikipedia.org/wiki/Natural_sort_order
since
1.3
val edit_distance : ?⁠cutoff:int -> string -> string -> int
edit_distance ~cutoff s1 s2 is the edition distance between the two strings s1 and s2. This satisfies the classical distance axioms: it is always positive, symmetric, and satisfies the formula distance s1 s2 + distance s2 s3 >= distance s1 s3.
parameter cutoff
if provided, it's a cap on both the number of iterations, and on the result. (since 3.0). This is useful if you just want to check whether the edit distance is less or equal than 2 (use cutoff of 3).
Infix operators
since
3.0
module Infix : sig ... end
include module type of Infix
val (=) : t -> t -> bool
since
3.0
val (<>) : t -> t -> bool
since
3.0
val (<) : t -> t -> bool
since
3.0
val (<=) : t -> t -> bool
since
3.0
val (>=) : t -> t -> bool
since
3.0
val (>) : t -> t -> bool
since
3.0

\ No newline at end of file
diff --git a/dev/containers/CCStringLabels/index.html b/dev/containers/CCStringLabels/index.html
index 37ed8fde..08badb57 100644
--- a/dev/containers/CCStringLabels/index.html
+++ b/dev/containers/CCStringLabels/index.html
@@ -1,2 +1,2 @@
 
-CCStringLabels (containers.CCStringLabels)
Module CCStringLabels
Basic String Utils
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
Documentation for the standard StringLabels module
include module type of sig ... end
val length : string -> int
val get : string -> int -> char
val set : bytes -> int -> char -> unit
val create : int -> bytes
val make : int -> char -> string
val init : int -> f:(int -> char) -> string
val copy : string -> string
val sub : string -> pos:int -> len:int -> string
val fill : bytes -> pos:int -> len:int -> char -> unit
val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit
val concat : sep:string -> string list -> string
val iter : f:(char -> unit) -> string -> unit
val iteri : f:(int -> char -> unit) -> string -> unit
val map : f:(char -> char) -> string -> string
val mapi : f:(int -> char -> char) -> string -> string
val trim : string -> string
val escaped : string -> string
val index : string -> char -> int
val index_opt : string -> char -> int option
val rindex : string -> char -> int
val rindex_opt : string -> char -> int option
val index_from : string -> int -> char -> int
val index_from_opt : string -> int -> char -> int option
val rindex_from : string -> int -> char -> int
val rindex_from_opt : string -> int -> char -> int option
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val uppercase_ascii : string -> string
val lowercase_ascii : string -> string
val capitalize_ascii : string -> string
val uncapitalize_ascii : string -> string
type t = string
val compare : t -> t -> int
val equal : t -> t -> bool
val split_on_char : sep:char -> string -> string list
val to_seq : t -> char Stdlib.Seq.t
val to_seqi : t -> (int * char) Stdlib.Seq.t
val of_seq : char Stdlib.Seq.t -> t
val unsafe_get : string -> int -> char
val unsafe_set : bytes -> int -> char -> unit
val unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit
val unsafe_fill : bytes -> pos:int -> len:int -> char -> unit
val length : t -> int
length s returns the length (number of characters) of the given string s.
val blit : src:t -> src_pos:int -> dst:Stdlib.Bytes.t -> dst_pos:int -> len:int -> unit
blit ~src ~src_pos ~dst ~dst_pos ~len copies len characters from string src starting at character indice src_pos, to the Bytes sequence dst starting at character indice dst_pos. Like String.blit. Compatible with the -safe-string option.
raises Invalid_argument
if indices are not valid.
val fold : f:('a -> char -> 'a) -> init:'a -> t -> 'a
fold ~f ~init s folds on chars by increasing index. Computes f(… (f (f init s.[0]) s.[1]) …) s.[n-1].
since
0.7
val foldi : f:('a -> int -> char -> 'a) -> 'a -> t -> 'a
foldi ~f init s is just like fold, but it also passes in the index of each chars as second argument to the folded function f.
since
NEXT_RELEASE
Conversions
val to_gen : t -> char gen
to_gen s returns the gen of characters contained in the string s.
val to_iter : t -> char iter
to_iter s returns the iter of characters contained in the string s.
since
2.8
val to_seq : t -> char Stdlib.Seq.t
to_seq s returns the Seq.t of characters contained in the string s. Renamed from to std_seq since 3.0.
since
3.0
val to_list : t -> char list
to_list s returns the list of characters contained in the string s.
val pp_buf : Stdlib.Buffer.t -> t -> unit
pp_buf buf s prints s to the buffer buf. Renamed from pp since 2.0.
val pp : Stdlib.Format.formatter -> t -> unit
pp f s prints the string s within quotes to the formatter f. Renamed from print since 2.0.
Strings
val equal : string -> string -> bool
equal s1 s2 returns true iff the strings s1 and s2 are equal.
val compare : string -> string -> int
compare s1 s2 compares the strings s1 and s2 and returns an integer that indicates their relative position in the sort order.
val is_empty : string -> bool
is_empty s returns true iff s is empty (i.e. its length is 0).
since
1.5
val hash : string -> int
hash s returns the hash value of s.
val rev : string -> string
rev s returns the reverse of s.
since
0.17
val pad : ?⁠side:[ `Left | `Right ] -> ?⁠c:char -> int -> string -> string
pad ?side ?c n s ensures that the string s is at least n bytes long, and pads it on the side with c if it's not the case.
parameter side
determines where padding occurs (default: `Left).
parameter c
the char used to pad (default: ' ').
since
0.17
val of_char : char -> string
of_char 'a' is "a".
since
0.19
val of_gen : char gen -> string
of_gen gen converts a gen of characters to a string.
val of_iter : char iter -> string
of_iter iter converts an iter of characters to a string.
since
2.8
val of_seq : char Stdlib.Seq.t -> string
of_seq seq converts a seq of characters to a string. Renamed from of_std_seq since 3.0.
since
3.0
val of_list : char list -> string
of_list lc converts a list of characters lc to a string.
val of_array : char array -> string
of_array ac converts an array of characters ac to a string.
val to_array : string -> char array
to_array s returns the array of characters contained in the string s.
val find : ?⁠start:int -> sub:string -> string -> int
find ?start ~sub s returns the starting index of the first occurrence of sub within s or -1.
parameter start
starting position in s.
val find_all : ?⁠start:int -> sub:string -> string -> int gen
find_all ?start ~sub s finds all occurrences of sub in s, even overlapping instances and returns them in a generator gen.
parameter start
starting position in s.
since
0.17
val find_all_l : ?⁠start:int -> sub:string -> string -> int list
find_all_l ?start ~sub s finds all occurrences of sub in s and returns them in a list.
parameter start
starting position in s.
since
0.17
val mem : ?⁠start:int -> sub:string -> string -> bool
mem ?start ~sub s is true iff sub is a substring of s.
since
0.12
val rfind : sub:string -> string -> int
rfind ~sub s finds sub in string s from the right, returns its first index or -1. Should only be used with very small sub.
since
0.12
val replace : ?⁠which:[ `Left | `Right | `All ] -> sub:string -> by:string -> string -> string
replace ?which ~sub ~by s replaces some occurrences of sub by by in s.
parameter which
decides whether the occurrences to replace are:
  • `Left first occurrence from the left (beginning).
  • `Right first occurrence from the right (end).
  • `All all occurrences (default).
raises Invalid_argument
if sub = "".
since
0.14
val is_sub : sub:string -> sub_pos:int -> string -> pos:int -> sub_len:int -> bool
is_sub ~sub ~sub_pos s ~pos ~sub_len returns true iff the substring of sub starting at position sub_pos and of length sub_len is a substring of s starting at position pos.
val repeat : string -> int -> string
repeat s n creates a string by repeating the string s n times.
val prefix : pre:string -> string -> bool
prefix ~pre s returns true iff pre is a prefix of s.
val suffix : suf:string -> string -> bool
suffix ~suf s returns true iff suf is a suffix of s.
since
0.7
val chop_prefix : pre:string -> string -> string option
chop_prefix ~pre s removes pre from s if pre really is a prefix of s, returns None otherwise.
since
0.17
val chop_suffix : suf:string -> string -> string option
chop_suffix ~suf s removes suf from s if suf really is a suffix of s, returns None otherwise.
since
0.17
val take : int -> string -> string
take n s keeps only the n first chars of s.
since
0.17
val drop : int -> string -> string
drop n s removes the n first chars of s.
since
0.17
val take_drop : int -> string -> string * string
take_drop n s is take n s, drop n s.
since
0.17
val lines : string -> string list
lines s returns a list of the lines of s (splits along '\n').
since
0.10
val lines_gen : string -> string gen
lines_gen s returns a generator gen of the lines of s (splits along '\n').
since
0.10
val lines_iter : string -> string iter
lines_iter s returns the iter of the lines of s (splits along '\n').
since
3.2
val lines_seq : string -> string Stdlib.Seq.t
lines_seq s returns the Seq.t of the lines of s (splits along '\n').
since
3.2
val concat_iter : sep:string -> string iter -> string
concat_iter ~sep iter concatenates all strings of iter, separated with sep.
since
3.2
val concat_gen : sep:string -> string gen -> string
concat_gen ~sep gen concatenates all strings of gen, separated with sep.
since
0.10
val concat_seq : sep:string -> string Stdlib.Seq.t -> string
concat_seq ~sep seq concatenates all strings of seq, separated with sep.
since
3.2
val unlines : string list -> string
unlines ls concatenates all strings of ls, separated with '\n'.
since
0.10
val unlines_gen : string gen -> string
unlines_gen gen concatenates all strings of gen, separated with '\n'.
since
0.10
val unlines_iter : string iter -> string
unlines_iter iter concatenates all strings of iter, separated with '\n'.
since
3.2
val unlines_seq : string Stdlib.Seq.t -> string
unlines_seq seq concatenates all strings of seq, separated with '\n'.
since
3.2
val set : string -> int -> char -> string
set s i c creates a new string which is a copy of s, except for index i, which becomes c.
raises Invalid_argument
if i is an invalid index.
since
0.12
val iter : f:(char -> unit) -> string -> unit
iter ~f s applies function f on each character of s. Alias to String.iter.
since
0.12
val filter_map : f:(char -> char option) -> string -> string
filter_map ~f s calls (f a0) (f a1) … (f an) where a0 … an are the characters of s. It returns the string of characters ci such as f ai = Some ci (when f returns None, the corresponding element of s is discarded).
since
0.17
val filter : f:(char -> bool) -> string -> string
filter ~f s discards characters of s not satisfying f.
since
0.17
val flat_map : ?⁠sep:string -> f:(char -> string) -> string -> string
flat_map ?sep ~f s maps each chars of s to a string, then concatenates them all.
parameter sep
optional separator between each generated string.
since
0.12
val for_all : f:(char -> bool) -> string -> bool
for_all ~f s is true iff all characters of s satisfy the predicate f.
since
0.12
val exists : f:(char -> bool) -> string -> bool
exists ~f s is true iff some character of s satisfy the predicate f.
since
0.12
val drop_while : f:(char -> bool) -> t -> t
drop_while ~f s discards any characters of s starting from the left, up to the first character c not satisfying f c.
since
2.2
val rdrop_while : f:(char -> bool) -> t -> t
rdrop_while ~f s discards any characters of s starting from the right, up to the first character c not satisfying f c.
since
2.2
val ltrim : t -> t
ltrim s trims space on the left (see String.trim for more details).
since
1.2
val rtrim : t -> t
rtrim s trims space on the right (see String.trim for more details).
since
1.2
Operations on 2 strings
val map2 : f:(char -> char -> char) -> string -> string -> string
map2 ~f s1 s2 maps pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iter2 : f:(char -> char -> unit) -> string -> string -> unit
iter2 ~f s1 s2 iterates on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iteri2 : f:(int -> char -> char -> unit) -> string -> string -> unit
iteri2 ~f s1 s2 iterates on pairs of chars with their index.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val fold2 : f:('a -> char -> char -> 'a) -> init:'a -> string -> string -> 'a
fold2 ~f ~init s1 s2 folds on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val for_all2 : f:(char -> char -> bool) -> string -> string -> bool
for_all2 ~f s1 s2 returns true iff all pairs of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val exists2 : f:(char -> char -> bool) -> string -> string -> bool
exists2 ~f s1 s2 returns true iff a pair of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
Ascii functions
Those functions are deprecated in String since 4.03, so we provide a stable alias for them even in older versions.
val capitalize_ascii : string -> string
capitalize_ascii s returns a copy of s with the first character set to uppercase using the US-ASCII character set. See String.
since
0.18
val uncapitalize_ascii : string -> string
uncapitalize_ascii s returns a copy of s with the first character set to lowercase using the US-ASCII character set. See String.
since
0.18
val uppercase_ascii : string -> string
uppercase_ascii s returns a copy of s with all lowercase letters translated to uppercase using the US-ASCII character set. See String.
since
0.18
val lowercase_ascii : string -> string
lowercase_ascii s returns a copy of s with all uppercase letters translated to lowercase using the US-ASCII character set. See String.
since
0.18
val equal_caseless : string -> string -> bool
equal_caseless s1 s2 compares s1 and s2 without respect to ascii lowercase.
since
1.2
Finding
A relatively efficient algorithm for finding sub-strings.
since
1.0
module Find : sig ... end
Splitting
module Split : sig ... end
val split_on_char : by:char -> string -> string list
split_on_char ~by s splits the string s along the given char by.
since
1.2
val split : by:string -> string -> string list
split ~by s splits the string s along the given string by. Alias to Split.list_cpy.
since
1.2
Utils
val compare_versions : string -> string -> int
compare_versions s1 s2 compares version strings s1 and s2, considering that numbers are above text.
since
0.13
val compare_natural : string -> string -> int
compare_natural s1 s2 is the Natural Sort Order, comparing chunks of digits as natural numbers. https://en.wikipedia.org/wiki/Natural_sort_order
since
1.3
val edit_distance : ?⁠cutoff:int -> string -> string -> int
edit_distance ?cutoff s1 s2 is the edition distance between the two strings s1 and s2. This satisfies the classical distance axioms: it is always positive, symmetric, and satisfies the formula distance s1 s2 + distance s2 s3 >= distance s1 s3.
parameter cutoff
if provided, it's a cap on both the number of iterations, and on the result. (since 3.0). This is useful if you just want to check whether the edit distance is less or equal than 2 (use cutoff of 3).
Infix operators
since
3.0
module Infix : sig ... end
include module type of Infix
val (=) : t -> t -> bool
since
3.0
val (<>) : t -> t -> bool
since
3.0
val (<) : t -> t -> bool
since
3.0
val (<=) : t -> t -> bool
since
3.0
val (>=) : t -> t -> bool
since
3.0
val (>) : t -> t -> bool
since
3.0

\ No newline at end of file
+CCStringLabels (containers.CCStringLabels)
Module CCStringLabels
Basic String Utils
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type 'a gen = unit -> 'a option
Documentation for the standard StringLabels module
include module type of sig ... end
val length : string -> int
val get : string -> int -> char
val set : bytes -> int -> char -> unit
val create : int -> bytes
val make : int -> char -> string
val init : int -> f:(int -> char) -> string
val copy : string -> string
val sub : string -> pos:int -> len:int -> string
val fill : bytes -> pos:int -> len:int -> char -> unit
val blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit
val concat : sep:string -> string list -> string
val iter : f:(char -> unit) -> string -> unit
val iteri : f:(int -> char -> unit) -> string -> unit
val map : f:(char -> char) -> string -> string
val mapi : f:(int -> char -> char) -> string -> string
val trim : string -> string
val escaped : string -> string
val index : string -> char -> int
val index_opt : string -> char -> int option
val rindex : string -> char -> int
val rindex_opt : string -> char -> int option
val index_from : string -> int -> char -> int
val index_from_opt : string -> int -> char -> int option
val rindex_from : string -> int -> char -> int
val rindex_from_opt : string -> int -> char -> int option
val contains : string -> char -> bool
val contains_from : string -> int -> char -> bool
val rcontains_from : string -> int -> char -> bool
val uppercase : string -> string
val lowercase : string -> string
val capitalize : string -> string
val uncapitalize : string -> string
val uppercase_ascii : string -> string
val lowercase_ascii : string -> string
val capitalize_ascii : string -> string
val uncapitalize_ascii : string -> string
type t = string
val compare : t -> t -> int
val equal : t -> t -> bool
val split_on_char : sep:char -> string -> string list
val to_seq : t -> char Stdlib.Seq.t
val to_seqi : t -> (int * char) Stdlib.Seq.t
val of_seq : char Stdlib.Seq.t -> t
val unsafe_get : string -> int -> char
val unsafe_set : bytes -> int -> char -> unit
val unsafe_blit : src:string -> src_pos:int -> dst:bytes -> dst_pos:int -> len:int -> unit
val unsafe_fill : bytes -> pos:int -> len:int -> char -> unit
val length : t -> int
length s returns the length (number of characters) of the given string s.
val blit : src:t -> src_pos:int -> dst:Stdlib.Bytes.t -> dst_pos:int -> len:int -> unit
blit ~src ~src_pos ~dst ~dst_pos ~len copies len characters from string src starting at character indice src_pos, to the Bytes sequence dst starting at character indice dst_pos. Like String.blit. Compatible with the -safe-string option.
raises Invalid_argument
if indices are not valid.
val fold : f:('a -> char -> 'a) -> init:'a -> t -> 'a
fold ~f ~init s folds on chars by increasing index. Computes f(… (f (f init s.[0]) s.[1]) …) s.[n-1].
since
0.7
val foldi : f:('a -> int -> char -> 'a) -> 'a -> t -> 'a
foldi ~f init s is just like fold, but it also passes in the index of each chars as second argument to the folded function f.
since
3.3
Conversions
val to_gen : t -> char gen
to_gen s returns the gen of characters contained in the string s.
val to_iter : t -> char iter
to_iter s returns the iter of characters contained in the string s.
since
2.8
val to_seq : t -> char Stdlib.Seq.t
to_seq s returns the Seq.t of characters contained in the string s. Renamed from to std_seq since 3.0.
since
3.0
val to_list : t -> char list
to_list s returns the list of characters contained in the string s.
val pp_buf : Stdlib.Buffer.t -> t -> unit
pp_buf buf s prints s to the buffer buf. Renamed from pp since 2.0.
val pp : Stdlib.Format.formatter -> t -> unit
pp f s prints the string s within quotes to the formatter f. Renamed from print since 2.0.
Strings
val equal : string -> string -> bool
equal s1 s2 returns true iff the strings s1 and s2 are equal.
val compare : string -> string -> int
compare s1 s2 compares the strings s1 and s2 and returns an integer that indicates their relative position in the sort order.
val is_empty : string -> bool
is_empty s returns true iff s is empty (i.e. its length is 0).
since
1.5
val hash : string -> int
hash s returns the hash value of s.
val rev : string -> string
rev s returns the reverse of s.
since
0.17
val pad : ?⁠side:[ `Left | `Right ] -> ?⁠c:char -> int -> string -> string
pad ?side ?c n s ensures that the string s is at least n bytes long, and pads it on the side with c if it's not the case.
parameter side
determines where padding occurs (default: `Left).
parameter c
the char used to pad (default: ' ').
since
0.17
val of_char : char -> string
of_char 'a' is "a".
since
0.19
val of_gen : char gen -> string
of_gen gen converts a gen of characters to a string.
val of_iter : char iter -> string
of_iter iter converts an iter of characters to a string.
since
2.8
val of_seq : char Stdlib.Seq.t -> string
of_seq seq converts a seq of characters to a string. Renamed from of_std_seq since 3.0.
since
3.0
val of_list : char list -> string
of_list lc converts a list of characters lc to a string.
val of_array : char array -> string
of_array ac converts an array of characters ac to a string.
val to_array : string -> char array
to_array s returns the array of characters contained in the string s.
val find : ?⁠start:int -> sub:string -> string -> int
find ?start ~sub s returns the starting index of the first occurrence of sub within s or -1.
parameter start
starting position in s.
val find_all : ?⁠start:int -> sub:string -> string -> int gen
find_all ?start ~sub s finds all occurrences of sub in s, even overlapping instances and returns them in a generator gen.
parameter start
starting position in s.
since
0.17
val find_all_l : ?⁠start:int -> sub:string -> string -> int list
find_all_l ?start ~sub s finds all occurrences of sub in s and returns them in a list.
parameter start
starting position in s.
since
0.17
val mem : ?⁠start:int -> sub:string -> string -> bool
mem ?start ~sub s is true iff sub is a substring of s.
since
0.12
val rfind : sub:string -> string -> int
rfind ~sub s finds sub in string s from the right, returns its first index or -1. Should only be used with very small sub.
since
0.12
val replace : ?⁠which:[ `Left | `Right | `All ] -> sub:string -> by:string -> string -> string
replace ?which ~sub ~by s replaces some occurrences of sub by by in s.
parameter which
decides whether the occurrences to replace are:
  • `Left first occurrence from the left (beginning).
  • `Right first occurrence from the right (end).
  • `All all occurrences (default).
raises Invalid_argument
if sub = "".
since
0.14
val is_sub : sub:string -> sub_pos:int -> string -> pos:int -> sub_len:int -> bool
is_sub ~sub ~sub_pos s ~pos ~sub_len returns true iff the substring of sub starting at position sub_pos and of length sub_len is a substring of s starting at position pos.
val repeat : string -> int -> string
repeat s n creates a string by repeating the string s n times.
val prefix : pre:string -> string -> bool
prefix ~pre s returns true iff pre is a prefix of s.
val suffix : suf:string -> string -> bool
suffix ~suf s returns true iff suf is a suffix of s.
since
0.7
val chop_prefix : pre:string -> string -> string option
chop_prefix ~pre s removes pre from s if pre really is a prefix of s, returns None otherwise.
since
0.17
val chop_suffix : suf:string -> string -> string option
chop_suffix ~suf s removes suf from s if suf really is a suffix of s, returns None otherwise.
since
0.17
val take : int -> string -> string
take n s keeps only the n first chars of s.
since
0.17
val drop : int -> string -> string
drop n s removes the n first chars of s.
since
0.17
val take_drop : int -> string -> string * string
take_drop n s is take n s, drop n s.
since
0.17
val lines : string -> string list
lines s returns a list of the lines of s (splits along '\n').
since
0.10
val lines_gen : string -> string gen
lines_gen s returns a generator gen of the lines of s (splits along '\n').
since
0.10
val lines_iter : string -> string iter
lines_iter s returns the iter of the lines of s (splits along '\n').
since
3.2
val lines_seq : string -> string Stdlib.Seq.t
lines_seq s returns the Seq.t of the lines of s (splits along '\n').
since
3.2
val concat_iter : sep:string -> string iter -> string
concat_iter ~sep iter concatenates all strings of iter, separated with sep.
since
3.2
val concat_gen : sep:string -> string gen -> string
concat_gen ~sep gen concatenates all strings of gen, separated with sep.
since
0.10
val concat_seq : sep:string -> string Stdlib.Seq.t -> string
concat_seq ~sep seq concatenates all strings of seq, separated with sep.
since
3.2
val unlines : string list -> string
unlines ls concatenates all strings of ls, separated with '\n'.
since
0.10
val unlines_gen : string gen -> string
unlines_gen gen concatenates all strings of gen, separated with '\n'.
since
0.10
val unlines_iter : string iter -> string
unlines_iter iter concatenates all strings of iter, separated with '\n'.
since
3.2
val unlines_seq : string Stdlib.Seq.t -> string
unlines_seq seq concatenates all strings of seq, separated with '\n'.
since
3.2
val set : string -> int -> char -> string
set s i c creates a new string which is a copy of s, except for index i, which becomes c.
raises Invalid_argument
if i is an invalid index.
since
0.12
val iter : f:(char -> unit) -> string -> unit
iter ~f s applies function f on each character of s. Alias to String.iter.
since
0.12
val filter_map : f:(char -> char option) -> string -> string
filter_map ~f s calls (f a0) (f a1) … (f an) where a0 … an are the characters of s. It returns the string of characters ci such as f ai = Some ci (when f returns None, the corresponding element of s is discarded).
since
0.17
val filter : f:(char -> bool) -> string -> string
filter ~f s discards characters of s not satisfying f.
since
0.17
val flat_map : ?⁠sep:string -> f:(char -> string) -> string -> string
flat_map ?sep ~f s maps each chars of s to a string, then concatenates them all.
parameter sep
optional separator between each generated string.
since
0.12
val for_all : f:(char -> bool) -> string -> bool
for_all ~f s is true iff all characters of s satisfy the predicate f.
since
0.12
val exists : f:(char -> bool) -> string -> bool
exists ~f s is true iff some character of s satisfy the predicate f.
since
0.12
val drop_while : f:(char -> bool) -> t -> t
drop_while ~f s discards any characters of s starting from the left, up to the first character c not satisfying f c.
since
2.2
val rdrop_while : f:(char -> bool) -> t -> t
rdrop_while ~f s discards any characters of s starting from the right, up to the first character c not satisfying f c.
since
2.2
val ltrim : t -> t
ltrim s trims space on the left (see String.trim for more details).
since
1.2
val rtrim : t -> t
rtrim s trims space on the right (see String.trim for more details).
since
1.2
Operations on 2 strings
val map2 : f:(char -> char -> char) -> string -> string -> string
map2 ~f s1 s2 maps pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iter2 : f:(char -> char -> unit) -> string -> string -> unit
iter2 ~f s1 s2 iterates on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val iteri2 : f:(int -> char -> char -> unit) -> string -> string -> unit
iteri2 ~f s1 s2 iterates on pairs of chars with their index.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val fold2 : f:('a -> char -> char -> 'a) -> init:'a -> string -> string -> 'a
fold2 ~f ~init s1 s2 folds on pairs of chars.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val for_all2 : f:(char -> char -> bool) -> string -> string -> bool
for_all2 ~f s1 s2 returns true iff all pairs of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
val exists2 : f:(char -> char -> bool) -> string -> string -> bool
exists2 ~f s1 s2 returns true iff a pair of chars satisfy the predicate f.
raises Invalid_argument
if the strings have not the same length.
since
0.12
Ascii functions
Those functions are deprecated in String since 4.03, so we provide a stable alias for them even in older versions.
val capitalize_ascii : string -> string
capitalize_ascii s returns a copy of s with the first character set to uppercase using the US-ASCII character set. See String.
since
0.18
val uncapitalize_ascii : string -> string
uncapitalize_ascii s returns a copy of s with the first character set to lowercase using the US-ASCII character set. See String.
since
0.18
val uppercase_ascii : string -> string
uppercase_ascii s returns a copy of s with all lowercase letters translated to uppercase using the US-ASCII character set. See String.
since
0.18
val lowercase_ascii : string -> string
lowercase_ascii s returns a copy of s with all uppercase letters translated to lowercase using the US-ASCII character set. See String.
since
0.18
val equal_caseless : string -> string -> bool
equal_caseless s1 s2 compares s1 and s2 without respect to ascii lowercase.
since
1.2
Finding
A relatively efficient algorithm for finding sub-strings.
since
1.0
module Find : sig ... end
Splitting
module Split : sig ... end
val split_on_char : by:char -> string -> string list
split_on_char ~by s splits the string s along the given char by.
since
1.2
val split : by:string -> string -> string list
split ~by s splits the string s along the given string by. Alias to Split.list_cpy.
since
1.2
Utils
val compare_versions : string -> string -> int
compare_versions s1 s2 compares version strings s1 and s2, considering that numbers are above text.
since
0.13
val compare_natural : string -> string -> int
compare_natural s1 s2 is the Natural Sort Order, comparing chunks of digits as natural numbers. https://en.wikipedia.org/wiki/Natural_sort_order
since
1.3
val edit_distance : ?⁠cutoff:int -> string -> string -> int
edit_distance ?cutoff s1 s2 is the edition distance between the two strings s1 and s2. This satisfies the classical distance axioms: it is always positive, symmetric, and satisfies the formula distance s1 s2 + distance s2 s3 >= distance s1 s3.
parameter cutoff
if provided, it's a cap on both the number of iterations, and on the result. (since 3.0). This is useful if you just want to check whether the edit distance is less or equal than 2 (use cutoff of 3).
Infix operators
since
3.0
module Infix : sig ... end
include module type of Infix
val (=) : t -> t -> bool
since
3.0
val (<>) : t -> t -> bool
since
3.0
val (<) : t -> t -> bool
since
3.0
val (<=) : t -> t -> bool
since
3.0
val (>=) : t -> t -> bool
since
3.0
val (>) : t -> t -> bool
since
3.0

\ No newline at end of file
diff --git a/dev/containers/Containers/Hashtbl/index.html b/dev/containers/Containers/Hashtbl/index.html
index 2ea8863c..1873d8aa 100644
--- a/dev/containers/Containers/Hashtbl/index.html
+++ b/dev/containers/Containers/Hashtbl/index.html
@@ -1,2 +1,2 @@
 
-Hashtbl (containers.Containers.Hashtbl)
Module Containers.Hashtbl
since
0.14
include module type of Stdlib.Hashtbl with type Hashtbl.statistics = Stdlib.Hashtbl.statistics and module Hashtbl.Make = Stdlib.Hashtbl.Make and type ('a, 'b) Hashtbl.t = ('a, 'b) Stdlib.Hashtbl.t
type ('a, 'b) t = ('a, 'b) Stdlib.Hashtbl.t
val create : ?⁠random:bool -> int -> ('a, 'b) t
val clear : ('a, 'b) t -> unit
val reset : ('a, 'b) t -> unit
val copy : ('a, 'b) t -> ('a, 'b) t
val add : ('a, 'b) t -> 'a -> 'b -> unit
val find : ('a, 'b) t -> 'a -> 'b
val find_opt : ('a, 'b) t -> 'a -> 'b option
val find_all : ('a, 'b) t -> 'a -> 'b list
val mem : ('a, 'b) t -> 'a -> bool
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
val length : ('a, 'b) t -> int
val randomize : unit -> unit
val is_randomized : unit -> bool
type statistics = Stdlib.Hashtbl.statistics = {
num_bindings : int;
num_buckets : int;
max_bucket_length : int;
bucket_histogram : int array;
}
val stats : ('a, 'b) t -> statistics
val to_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t
val to_seq_keys : ('a, 'b) t -> 'a Stdlib.Seq.t
val to_seq_values : ('a, 'b) t -> 'b Stdlib.Seq.t
val add_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val replace_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) t
module type HashedType = sig ... end
module type S = sig ... end
module Make : functor (H : Stdlib__hashtbl.HashedType) -> sig ... end
module type SeededHashedType = sig ... end
module type SeededS = sig ... end
module MakeSeeded : functor (H : SeededHashedType) -> sig ... end
val hash : 'a -> int
val seeded_hash : int -> 'a -> int
val hash_param : int -> int -> 'a -> int
val seeded_hash_param : int -> int -> int -> 'a -> int
include CCHashtbl.Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b CCHashtbl.iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_iter : ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a CCHashtbl.iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> 'a CCHashtbl.printer -> 'b CCHashtbl.printer -> ('a, 'b) Stdlib.Hashtbl.t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13
module type S' = CCHashtbl.S
module Make' = CCHashtbl.Make

\ No newline at end of file
+Hashtbl (containers.Containers.Hashtbl)
Module Containers.Hashtbl
since
0.14
include module type of Stdlib.Hashtbl with type Hashtbl.statistics = Stdlib.Hashtbl.statistics and module Hashtbl.Make = Stdlib.Hashtbl.Make and type ('a, 'b) Hashtbl.t = ('a, 'b) Stdlib.Hashtbl.t
type ('a, 'b) t = ('a, 'b) Stdlib.Hashtbl.t
val create : ?⁠random:bool -> int -> ('a, 'b) t
val clear : ('a, 'b) t -> unit
val reset : ('a, 'b) t -> unit
val copy : ('a, 'b) t -> ('a, 'b) t
val add : ('a, 'b) t -> 'a -> 'b -> unit
val find : ('a, 'b) t -> 'a -> 'b
val find_opt : ('a, 'b) t -> 'a -> 'b option
val find_all : ('a, 'b) t -> 'a -> 'b list
val mem : ('a, 'b) t -> 'a -> bool
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
val length : ('a, 'b) t -> int
val randomize : unit -> unit
val is_randomized : unit -> bool
type statistics = Stdlib.Hashtbl.statistics = {
num_bindings : int;
num_buckets : int;
max_bucket_length : int;
bucket_histogram : int array;
}
val stats : ('a, 'b) t -> statistics
val to_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t
val to_seq_keys : ('a, 'b) t -> 'a Stdlib.Seq.t
val to_seq_values : ('a, 'b) t -> 'b Stdlib.Seq.t
val add_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val replace_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) t
module type HashedType = sig ... end
module type S = sig ... end
module Make : functor (H : Stdlib__hashtbl.HashedType) -> sig ... end
module type SeededHashedType = sig ... end
module type SeededS = sig ... end
module MakeSeeded : functor (H : SeededHashedType) -> sig ... end
val hash : 'a -> int
val seeded_hash : int -> 'a -> int
val hash_param : int -> int -> 'a -> int
val seeded_hash_param : int -> int -> int -> 'a -> int
include CCHashtbl.Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b CCHashtbl.iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_iter : ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a CCHashtbl.iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> 'a CCHashtbl.printer -> 'b CCHashtbl.printer -> ('a, 'b) Stdlib.Hashtbl.t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13
module type S' = CCHashtbl.S
module Make' = CCHashtbl.Make

\ No newline at end of file
diff --git a/dev/containers/Containers/Hashtbl/module-type-S'/index.html b/dev/containers/Containers/Hashtbl/module-type-S'/index.html
index f5825b5e..dc5e1f27 100644
--- a/dev/containers/Containers/Hashtbl/module-type-S'/index.html
+++ b/dev/containers/Containers/Hashtbl/module-type-S'/index.html
@@ -1,2 +1,2 @@
 
-S' (containers.Containers.Hashtbl.S')
Module type Hashtbl.S'
include Stdlib.Hashtbl.S
type key
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : 'a t -> key -> 'a option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : 'a t -> key -> default:'a -> 'a
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val add_list : 'a list t -> key -> 'a -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val incr : ?⁠by:int -> int t -> key -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> int t -> key -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val keys : 'a t -> key CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : 'a t -> 'a CCHashtbl.iter
values tbl f iterates on values in the table.
val keys_list : _ t -> key list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : 'a t -> 'a list
values_list t is the list of values in t.
since
0.8
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
Map on a hashtable's items, collect into a list.
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_iter_count : int t -> key CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.
since
3.0
val of_iter_count : key CCHashtbl.iter -> int t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : key Stdlib.Seq.t -> int t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : 'a t -> (key * 'a) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
+S' (containers.Containers.Hashtbl.S')
Module type Hashtbl.S'
include Stdlib.Hashtbl.S
type key
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : 'a t -> key -> 'a option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : 'a t -> key -> default:'a -> 'a
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val add_list : 'a list t -> key -> 'a -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val incr : ?⁠by:int -> int t -> key -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> int t -> key -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val keys : 'a t -> key CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : 'a t -> 'a CCHashtbl.iter
values tbl f iterates on values in the table.
val keys_list : _ t -> key list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : 'a t -> 'a list
values_list t is the list of values in t.
since
0.8
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
Map on a hashtable's items, collect into a list.
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_iter_count : int t -> key CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.
since
3.0
val of_iter_count : key CCHashtbl.iter -> int t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : key Stdlib.Seq.t -> int t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : 'a t -> (key * 'a) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
diff --git a/dev/containers/ContainersLabels/Hashtbl/index.html b/dev/containers/ContainersLabels/Hashtbl/index.html
index 2374a0c9..61c1d6c4 100644
--- a/dev/containers/ContainersLabels/Hashtbl/index.html
+++ b/dev/containers/ContainersLabels/Hashtbl/index.html
@@ -1,2 +1,2 @@
 
-Hashtbl (containers.ContainersLabels.Hashtbl)
Module ContainersLabels.Hashtbl
since
0.14
include module type of Stdlib.Hashtbl with type Hashtbl.statistics = Stdlib.Hashtbl.statistics and module Hashtbl.Make = Stdlib.Hashtbl.Make and type ('a, 'b) Hashtbl.t = ('a, 'b) Stdlib.Hashtbl.t
type ('a, 'b) t = ('a, 'b) Stdlib.Hashtbl.t
val create : ?⁠random:bool -> int -> ('a, 'b) t
val clear : ('a, 'b) t -> unit
val reset : ('a, 'b) t -> unit
val copy : ('a, 'b) t -> ('a, 'b) t
val add : ('a, 'b) t -> 'a -> 'b -> unit
val find : ('a, 'b) t -> 'a -> 'b
val find_opt : ('a, 'b) t -> 'a -> 'b option
val find_all : ('a, 'b) t -> 'a -> 'b list
val mem : ('a, 'b) t -> 'a -> bool
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
val length : ('a, 'b) t -> int
val randomize : unit -> unit
val is_randomized : unit -> bool
type statistics = Stdlib.Hashtbl.statistics = {
num_bindings : int;
num_buckets : int;
max_bucket_length : int;
bucket_histogram : int array;
}
val stats : ('a, 'b) t -> statistics
val to_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t
val to_seq_keys : ('a, 'b) t -> 'a Stdlib.Seq.t
val to_seq_values : ('a, 'b) t -> 'b Stdlib.Seq.t
val add_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val replace_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) t
module type HashedType = sig ... end
module type S = sig ... end
module Make : functor (H : Stdlib__hashtbl.HashedType) -> sig ... end
module type SeededHashedType = sig ... end
module type SeededS = sig ... end
module MakeSeeded : functor (H : SeededHashedType) -> sig ... end
val hash : 'a -> int
val seeded_hash : int -> 'a -> int
val hash_param : int -> int -> 'a -> int
val seeded_hash_param : int -> int -> int -> 'a -> int
include CCHashtbl.Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b CCHashtbl.iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_iter : ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a CCHashtbl.iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> 'a CCHashtbl.printer -> 'b CCHashtbl.printer -> ('a, 'b) Stdlib.Hashtbl.t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13
module type S' = CCHashtbl.S
module Make' = CCHashtbl.Make

\ No newline at end of file
+Hashtbl (containers.ContainersLabels.Hashtbl)
Module ContainersLabels.Hashtbl
since
0.14
include module type of Stdlib.Hashtbl with type Hashtbl.statistics = Stdlib.Hashtbl.statistics and module Hashtbl.Make = Stdlib.Hashtbl.Make and type ('a, 'b) Hashtbl.t = ('a, 'b) Stdlib.Hashtbl.t
type ('a, 'b) t = ('a, 'b) Stdlib.Hashtbl.t
val create : ?⁠random:bool -> int -> ('a, 'b) t
val clear : ('a, 'b) t -> unit
val reset : ('a, 'b) t -> unit
val copy : ('a, 'b) t -> ('a, 'b) t
val add : ('a, 'b) t -> 'a -> 'b -> unit
val find : ('a, 'b) t -> 'a -> 'b
val find_opt : ('a, 'b) t -> 'a -> 'b option
val find_all : ('a, 'b) t -> 'a -> 'b list
val mem : ('a, 'b) t -> 'a -> bool
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit
val iter : ('a -> 'b -> unit) -> ('a, 'b) t -> unit
val filter_map_inplace : ('a -> 'b -> 'b option) -> ('a, 'b) t -> unit
val fold : ('a -> 'b -> 'c -> 'c) -> ('a, 'b) t -> 'c -> 'c
val length : ('a, 'b) t -> int
val randomize : unit -> unit
val is_randomized : unit -> bool
type statistics = Stdlib.Hashtbl.statistics = {
num_bindings : int;
num_buckets : int;
max_bucket_length : int;
bucket_histogram : int array;
}
val stats : ('a, 'b) t -> statistics
val to_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t
val to_seq_keys : ('a, 'b) t -> 'a Stdlib.Seq.t
val to_seq_values : ('a, 'b) t -> 'b Stdlib.Seq.t
val add_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val replace_seq : ('a, 'b) t -> ('a * 'b) Stdlib.Seq.t -> unit
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) t
module type HashedType = sig ... end
module type S = sig ... end
module Make : functor (H : Stdlib__hashtbl.HashedType) -> sig ... end
module type SeededHashedType = sig ... end
module type SeededS = sig ... end
module MakeSeeded : functor (H : SeededHashedType) -> sig ... end
val hash : 'a -> int
val seeded_hash : int -> 'a -> int
val hash_param : int -> int -> 'a -> int
val seeded_hash_param : int -> int -> int -> 'a -> int
include CCHashtbl.Poly
val get : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> 'b option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : ('a, 'b) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val keys : ('a, 'b) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : ('a, 'b) Stdlib.Hashtbl.t -> 'b CCHashtbl.iter
values tbl f iterates on values in the table tbl.
val keys_list : ('a, 'b) Stdlib.Hashtbl.t -> 'a list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : ('a, 'b) Stdlib.Hashtbl.t -> 'b list
values_list tbl is the list of values in tbl.
since
0.8
val map_list : ('a -> 'b -> 'c) -> ('a, 'b) Stdlib.Hashtbl.t -> 'c list
map_list f tbl maps on a tbl's items. Collect into a list.
val incr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> ('a, int) Stdlib.Hashtbl.t -> 'a -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val to_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_list : ('a, 'b list) Stdlib.Hashtbl.t -> 'a -> 'b -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val add_iter : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_seq : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_iter : ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) CCHashtbl.iter -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_seq : ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) Stdlib.Seq.t -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_iter_count : ('a, int) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : ('a, int) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.
since
3.0
val of_iter_count : 'a CCHashtbl.iter -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : 'a Stdlib.Seq.t -> ('a, int) Stdlib.Hashtbl.t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : ('a, 'b) Stdlib.Hashtbl.t -> ('a * 'b) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:('a -> 'b -> 'b -> 'b) -> ('a * 'b) list -> ('a, 'b) Stdlib.Hashtbl.t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val update : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b option -> 'b option) -> k:'a -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : ('a, 'b) Stdlib.Hashtbl.t -> f:('a -> 'b) -> k:'a -> 'b
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> 'a CCHashtbl.printer -> 'b CCHashtbl.printer -> ('a, 'b) Stdlib.Hashtbl.t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13
module type S' = CCHashtbl.S
module Make' = CCHashtbl.Make

\ No newline at end of file
diff --git a/dev/containers/ContainersLabels/Hashtbl/module-type-S'/index.html b/dev/containers/ContainersLabels/Hashtbl/module-type-S'/index.html
index d8bc99ab..94b5c1a5 100644
--- a/dev/containers/ContainersLabels/Hashtbl/module-type-S'/index.html
+++ b/dev/containers/ContainersLabels/Hashtbl/module-type-S'/index.html
@@ -1,2 +1,2 @@
 
-S' (containers.ContainersLabels.Hashtbl.S')
Module type Hashtbl.S'
include Stdlib.Hashtbl.S
type key
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : 'a t -> key -> 'a option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : 'a t -> key -> default:'a -> 'a
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val add_list : 'a list t -> key -> 'a -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val incr : ?⁠by:int -> int t -> key -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> int t -> key -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val keys : 'a t -> key CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : 'a t -> 'a CCHashtbl.iter
values tbl f iterates on values in the table.
val keys_list : _ t -> key list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : 'a t -> 'a list
values_list t is the list of values in t.
since
0.8
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
Map on a hashtable's items, collect into a list.
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val add_iter_count : int t -> key CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.
since
3.0
val of_iter_count : key CCHashtbl.iter -> int t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : key Stdlib.Seq.t -> int t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : 'a t -> (key * 'a) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
NEXT_RELEASE
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
+S' (containers.ContainersLabels.Hashtbl.S')
Module type Hashtbl.S'
include Stdlib.Hashtbl.S
type key
type 'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : (key -> 'a -> unit) -> 'a t -> unit
val filter_map_inplace : (key -> 'a -> 'a option) -> 'a t -> unit
val fold : (key -> 'a -> 'b -> 'b) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib.Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
val get : 'a t -> key -> 'a option
get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.
val get_or : 'a t -> key -> default:'a -> 'a
get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).
since
0.16
val add_list : 'a list t -> key -> 'a -> unit
add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.
since
0.16
val incr : ?⁠by:int -> int t -> key -> unit
incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).
parameter by
if specified, the int value is incremented by by rather than 1.
since
0.16
val decr : ?⁠by:int -> int t -> key -> unit
decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.
since
0.16
val keys : 'a t -> key CCHashtbl.iter
keys tbl f iterates on keys (similar order as Hashtbl.iter).
val values : 'a t -> 'a CCHashtbl.iter
values tbl f iterates on values in the table.
val keys_list : _ t -> key list
keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.
since
0.8
val values_list : 'a t -> 'a list
values_list t is the list of values in t.
since
0.8
val map_list : (key -> 'a -> 'b) -> 'a t -> 'b list
Map on a hashtable's items, collect into a list.
val to_iter : 'a t -> (key * 'a) CCHashtbl.iter
Iterate on bindings in the table.
since
2.8
val add_iter : 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add.
since
2.8
val add_iter_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) CCHashtbl.iter -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.
since
3.0
val add_seq_with : f:(key -> 'a -> 'a -> 'a) -> 'a t -> (key * 'a) Stdlib.Seq.t -> unit
Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_iter : (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order.
since
2.8
val of_iter_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) CCHashtbl.iter -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. Renamed from of_std_seq since 3.0.
since
3.0
val of_seq_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) Stdlib.Seq.t -> 'a t
From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val add_iter_count : int t -> key CCHashtbl.iter -> unit
add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.
since
2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit
add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.
since
3.0
val of_iter_count : key CCHashtbl.iter -> int t
Like add_seq_count, but allocates a new table and returns it.
since
2.8
val of_seq_count : key Stdlib.Seq.t -> int t
Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.
since
3.0
val to_list : 'a t -> (key * 'a) list
to_list tbl returns the list of (key,value) bindings (order unspecified).
val of_list : (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.
val of_list_with : f:(key -> 'a -> 'a -> 'a) -> (key * 'a) list -> 'a t
of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.
since
3.3
val update : 'a t -> f:(key -> 'a option -> 'a option) -> k:key -> unit
update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.
since
0.14
val get_or_add : 'a t -> f:(key -> 'a) -> k:key -> 'a
get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.
since
1.0
val pp : ?⁠pp_start:unit CCHashtbl.printer -> ?⁠pp_stop:unit CCHashtbl.printer -> ?⁠pp_sep:unit CCHashtbl.printer -> ?⁠pp_arrow:unit CCHashtbl.printer -> key CCHashtbl.printer -> 'a CCHashtbl.printer -> 'a t CCHashtbl.printer
pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.
since
0.13

\ No newline at end of file
diff --git a/dev/index.html b/dev/index.html
index c0e93dbc..827886ce 100644
--- a/dev/index.html
+++ b/dev/index.html
@@ -11,9 +11,9 @@
       

       
OCaml package documentation

       
    
-      
  1. containers 3.2
    2. 
-      
  2. containers-data 3.2
    3. 
-      
  3. containers-thread 3.2
    4. 
+      
  4. containers 3.3
    5. 
+      
  5. containers-data 3.3
    6. 
+      
  6. containers-thread 3.3
    7.