diff --git a/dev/containers/CCEither/index.html b/dev/containers/CCEither/index.html index b269e51f..83a37381 100644 --- a/dev/containers/CCEither/index.html +++ b/dev/containers/CCEither/index.html @@ -1,2 +1,2 @@ -CCEither (containers.CCEither)

Module CCEither

Either Monad

Module that is compatible with Either form OCaml 4.12 but can be use with any ocaml version compatible with container

since
NEXT_RELEASE
type 'a iter = ('a -> unit) -> unit
type 'a equal = 'a -> 'a -> bool
type 'a ord = 'a -> 'a -> int
type 'a printer = Stdlib.Format.formatter -> 'a -> unit

Basics

include module type of CCShimsEither_
type ('a, 'b) t =
| Left of 'a
| Right of 'b
val left : 'a -> ('a, 'b) t

left l is Left l

val right : 'b -> ('a, 'b) t

right r is Right r

val is_left : ('a, 'b) t -> bool

is_left x checks if x = Left _

val is_right : ('a, 'b) t -> bool

is_right x checks if x = Right _

val find_left : ('a, 'b) t -> 'a option

find_left x returns l if x = Left l and None otherwise.

val find_right : ('a, 'b) t -> 'b option

find_right x returns r if x = Left r and None otherwise.

val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t

Map of the Left variant.

val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t

Map of the Right variant.

val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t

Map using left or right.

val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c

Fold using left or right.

val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit

Iter using left or right.

val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool

Check some property on Left or Right variant.

val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int

IO

val pp : left:'a printer -> right:'b printer -> ('a, 'b) t printer

Pretty printer.

\ No newline at end of file +CCEither (containers.CCEither)

Module CCEither

Either Monad

Module that is compatible with Either form OCaml 4.12 but can be use with any ocaml version compatible with container

since
3.2
type 'a iter = ('a -> unit) -> unit
type 'a equal = 'a -> 'a -> bool
type 'a ord = 'a -> 'a -> int
type 'a printer = Stdlib.Format.formatter -> 'a -> unit

Basics

include module type of CCShimsEither_
type ('a, 'b) t =
| Left of 'a
| Right of 'b
val left : 'a -> ('a, 'b) t

left l is Left l

val right : 'b -> ('a, 'b) t

right r is Right r

val is_left : ('a, 'b) t -> bool

is_left x checks if x = Left _

val is_right : ('a, 'b) t -> bool

is_right x checks if x = Right _

val find_left : ('a, 'b) t -> 'a option

find_left x returns l if x = Left l and None otherwise.

val find_right : ('a, 'b) t -> 'b option

find_right x returns r if x = Left r and None otherwise.

val map_left : ('a1 -> 'a2) -> ('a1, 'b) t -> ('a2, 'b) t

Map of the Left variant.

val map_right : ('b1 -> 'b2) -> ('a, 'b1) t -> ('a, 'b2) t

Map of the Right variant.

val map : left:('a1 -> 'a2) -> right:('b1 -> 'b2) -> ('a1, 'b1) t -> ('a2, 'b2) t

Map using left or right.

val fold : left:('a -> 'c) -> right:('b -> 'c) -> ('a, 'b) t -> 'c

Fold using left or right.

val iter : left:('a -> unit) -> right:('b -> unit) -> ('a, 'b) t -> unit

Iter using left or right.

val for_all : left:('a -> bool) -> right:('b -> bool) -> ('a, 'b) t -> bool

Check some property on Left or Right variant.

val equal : left:('a -> 'a -> bool) -> right:('b -> 'b -> bool) -> ('a, 'b) t -> ('a, 'b) t -> bool
val compare : left:('a -> 'a -> int) -> right:('b -> 'b -> int) -> ('a, 'b) t -> ('a, 'b) t -> int

IO

val pp : left:'a printer -> right:'b printer -> ('a, 'b) t printer

Pretty printer.

\ No newline at end of file diff --git a/dev/containers/CCFormat/Infix/index.html b/dev/containers/CCFormat/Infix/index.html index acb104f9..1568fb3d 100644 --- a/dev/containers/CCFormat/Infix/index.html +++ b/dev/containers/CCFormat/Infix/index.html @@ -1,2 +1,2 @@ -Infix (containers.CCFormat.Infix)

Module CCFormat.Infix

val (++) : unit printer -> unit printer -> unit printer

Alias to append.

since
NEXT_RELEASE
\ No newline at end of file +Infix (containers.CCFormat.Infix)

Module CCFormat.Infix

val (++) : unit printer -> unit printer -> unit printer

Alias to append.

since
3.2
\ No newline at end of file diff --git a/dev/containers/CCFormat/index.html b/dev/containers/CCFormat/index.html index 3ad7f570..77b0b56d 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
NEXT_RELEASE
val cut : unit printer

Alias to pp_print_cut.

since
NEXT_RELEASE
val break : (int * int) printer

Tuple-ized printer form of pp_print_break.

since
NEXT_RELEASE
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 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
NEXT_RELEASE
val append_l : unit printer list -> unit printer

append_l pps runs the printers in pps sequentially.

since
NEXT_RELEASE
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 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 *)
@@ -11,4 +11,4 @@ CCFormat.sprintf_dyn_color ~colors:false "@{<Red>%a@}"
   CCFormat.Dump.(list int) [1;2;3] |> print_endline;;
since
0.21
val fprintf : t -> ('a, t, unit) Stdlib.format -> 'a
Alias to Format.fprintf.
since
0.14
val fprintf_dyn_color : colors:bool -> t -> ('a, t, unit) Stdlib.format -> 'a
Like fprintf but enable/disable colors depending on colors.
since
0.21
val ksprintf : ?⁠margin:int -> f:(string -> 'b) -> ('a, Stdlib.Format.formatter, unit, 'b) Stdlib.format4 -> 'a
ksprintf fmt ~f formats using fmt, in a way similar to sprintf, and then calls f on the resulting string.
parameter margin
set margin (since 2.1)
since
0.14
val to_file : string -> ('a, t, unit, unit) Stdlib.format4 -> 'a
Print to the given file.
Dump
Print structures as OCaml values, so that they can be parsed back by OCaml (typically, in the toplevel, for debugging).
Example:
Format.printf "%a@." CCFormat.Dump.(list int) CCList.(1 -- 200);;
 
 Format.printf "%a@." CCFormat.Dump.(array (list (pair int bool)))
-  [| [1, true; 2, false]; []; [42, false] |];;
since
0.21
module Dump : sig ... end
module Infix : sig ... end
include module type of Infix
val (++) : unit printer -> unit printer -> unit printer
Alias to append.
since
NEXT_RELEASE

\ No newline at end of file
+  [| [1, true; 2, false]; []; [42, false] |];;
since
0.21
module Dump : sig ... end
module Infix : sig ... end
include module type of Infix
val (++) : unit printer -> unit printer -> unit printer

Alias to append.

since
3.2
\ No newline at end of file diff --git a/dev/containers/CCList/index.html b/dev/containers/CCList/index.html index 61693ca0..18a722b4 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 (@) : '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
NEXT_RELEASE
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
NEXT_RELEASE
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 (@) : '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 : ('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_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 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
NEXT_RELEASE
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 : ('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_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 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 d0dddb24..b048d5d2 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_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
NEXT_RELEASE
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
NEXT_RELEASE
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_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 : f:('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_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 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
NEXT_RELEASE
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 : f:('a -> [< `Left of 'b | `Right of 'c | `Drop ]) -> 'a list -> 'b list * 'c list
partition_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 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/CCString/index.html b/dev/containers/CCString/index.html
index 12a350e2..2c892b9f 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
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
NEXT_RELEASE
val lines_seq : string -> string Stdlib.Seq.t
lines_seq s returns the Seq.t of the lines of s (splits along '\n').
since
NEXT_RELEASE
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
NEXT_RELEASE
val concat_iter : sep:string -> string iter -> string
concat_iter ~sep iter concatenates all strings of iter, separated with sep.
since
NEXT_RELEASE
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
NEXT_RELEASE
val unlines_seq : string Stdlib.Seq.t -> string
unlines_seq seq concatenates all strings of seq, separated with '\n'.
since
NEXT_RELEASE
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
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 e5725334..4f90537e 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
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
NEXT_RELEASE
val lines_seq : string -> string Stdlib.Seq.t
lines_seq s returns the Seq.t of the lines of s (splits along '\n').
since
NEXT_RELEASE
val concat_iter : sep:string -> string iter -> string
concat_iter ~sep iter concatenates all strings of iter, separated with sep.
since
NEXT_RELEASE
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
NEXT_RELEASE
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
NEXT_RELEASE
val unlines_seq : string Stdlib.Seq.t -> string
unlines_seq seq concatenates all strings of seq, separated with '\n'.
since
NEXT_RELEASE
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
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/CCUtf8_string/index.html b/dev/containers/CCUtf8_string/index.html
index b4c97128..e7b3a7a5 100644
--- a/dev/containers/CCUtf8_string/index.html
+++ b/dev/containers/CCUtf8_string/index.html
@@ -1,2 +1,2 @@
 
-CCUtf8_string (containers.CCUtf8_string)
Module CCUtf8_string
Unicode String, in UTF8
type uchar = Stdlib.Uchar.t
type 'a gen = unit -> 'a option
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type t = private string
A UTF8 string
val equal : t -> t -> bool
val hash : t -> int
val compare : t -> t -> int
val pp : Stdlib.Format.formatter -> t -> unit
val to_string : t -> string
Identity.
exception Malformed of string * int
Malformed string at given offset
val to_gen : ?⁠idx:int -> t -> uchar gen
Generator of unicode codepoints.
parameter idx
offset where to start the decoding.
val to_iter : ?⁠idx:int -> t -> uchar iter
Iterator of unicode codepoints.
parameter idx
offset where to start the decoding.
since
2.8
val to_seq : ?⁠idx:int -> t -> uchar Stdlib.Seq.t
Iter of unicode codepoints. Renamed from to_std_seq since 3.0.
parameter idx
offset where to start the decoding.
since
3.0
val to_list : ?⁠idx:int -> t -> uchar list
List of unicode codepoints.
parameter idx
offset where to start the decoding.
val fold : ?⁠idx:int -> ('a -> uchar -> 'a) -> 'a -> t -> 'a
val iter : ?⁠idx:int -> (uchar -> unit) -> t -> unit
val n_chars : t -> int
Number of characters.
val n_bytes : t -> int
Number of bytes.
val map : (uchar -> uchar) -> t -> t
val filter_map : (uchar -> uchar option) -> t -> t
val flat_map : (uchar -> t) -> t -> t
val append : t -> t -> t
val concat : t -> t list -> t
val of_seq : uchar Stdlib.Seq.t -> t
Build a string from unicode codepoints Renamed from of_std_seq since 3.0.
since
3.0
val of_iter : uchar iter -> t
Build a string from unicode codepoints
since
2.8
val uchar_to_bytes : uchar -> char iter
Translate the unicode codepoint to a list of utf-8 bytes. This can be used, for example, in combination with Buffer.add_char on a pre-allocated buffer to add the bytes one by one (despite its name, Buffer.add_char takes individual bytes, not unicode codepoints).
since
NEXT_RELEASE
val of_gen : uchar gen -> t
val of_list : uchar list -> t
val of_string_exn : string -> t
Validate string by checking it is valid UTF8.
raises Invalid_argument
if the string is not valid UTF8.
val of_string : string -> t option
Safe version of of_string_exn.
val is_valid : string -> bool
Valid UTF8?
val unsafe_of_string : string -> t
Conversion from a string without validating. CAUTION this is unsafe and can break all the other functions in this module. Use only if you're sure the string is valid UTF8. Upon iteration, if an invalid substring is met, Malformed will be raised.

\ No newline at end of file
+CCUtf8_string (containers.CCUtf8_string)
Module CCUtf8_string
Unicode String, in UTF8
type uchar = Stdlib.Uchar.t
type 'a gen = unit -> 'a option
type 'a iter = ('a -> unit) -> unit
Fast internal iterator.
since
2.8
type t = private string
A UTF8 string
val equal : t -> t -> bool
val hash : t -> int
val compare : t -> t -> int
val pp : Stdlib.Format.formatter -> t -> unit
val to_string : t -> string
Identity.
exception Malformed of string * int
Malformed string at given offset
val to_gen : ?⁠idx:int -> t -> uchar gen
Generator of unicode codepoints.
parameter idx
offset where to start the decoding.
val to_iter : ?⁠idx:int -> t -> uchar iter
Iterator of unicode codepoints.
parameter idx
offset where to start the decoding.
since
2.8
val to_seq : ?⁠idx:int -> t -> uchar Stdlib.Seq.t
Iter of unicode codepoints. Renamed from to_std_seq since 3.0.
parameter idx
offset where to start the decoding.
since
3.0
val to_list : ?⁠idx:int -> t -> uchar list
List of unicode codepoints.
parameter idx
offset where to start the decoding.
val fold : ?⁠idx:int -> ('a -> uchar -> 'a) -> 'a -> t -> 'a
val iter : ?⁠idx:int -> (uchar -> unit) -> t -> unit
val n_chars : t -> int
Number of characters.
val n_bytes : t -> int
Number of bytes.
val map : (uchar -> uchar) -> t -> t
val filter_map : (uchar -> uchar option) -> t -> t
val flat_map : (uchar -> t) -> t -> t
val append : t -> t -> t
val concat : t -> t list -> t
val of_seq : uchar Stdlib.Seq.t -> t
Build a string from unicode codepoints Renamed from of_std_seq since 3.0.
since
3.0
val of_iter : uchar iter -> t
Build a string from unicode codepoints
since
2.8
val uchar_to_bytes : uchar -> char iter
Translate the unicode codepoint to a list of utf-8 bytes. This can be used, for example, in combination with Buffer.add_char on a pre-allocated buffer to add the bytes one by one (despite its name, Buffer.add_char takes individual bytes, not unicode codepoints).
since
3.2
val of_gen : uchar gen -> t
val of_list : uchar list -> t
val of_string_exn : string -> t
Validate string by checking it is valid UTF8.
raises Invalid_argument
if the string is not valid UTF8.
val of_string : string -> t option
Safe version of of_string_exn.
val is_valid : string -> bool
Valid UTF8?
val unsafe_of_string : string -> t
Conversion from a string without validating. CAUTION this is unsafe and can break all the other functions in this module. Use only if you're sure the string is valid UTF8. Upon iteration, if an invalid substring is met, Malformed will be raised.

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

       
OCaml package documentation

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