diff --git a/dev/containers-data/CCBijection/Make/argument-1-L/index.html b/dev/containers-data/CCBijection/Make/argument-1-L/index.html new file mode 100644 index 00000000..f52229b6 --- /dev/null +++ b/dev/containers-data/CCBijection/Make/argument-1-L/index.html @@ -0,0 +1,2 @@ + +L (containers-data.CCBijection.Make.1-L)

Parameter Make.1-L

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCBijection/Make/argument-2-R/index.html b/dev/containers-data/CCBijection/Make/argument-2-R/index.html new file mode 100644 index 00000000..52ab9c85 --- /dev/null +++ b/dev/containers-data/CCBijection/Make/argument-2-R/index.html @@ -0,0 +1,2 @@ + +R (containers-data.CCBijection.Make.2-R)

Parameter Make.2-R

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCBijection/Make/index.html b/dev/containers-data/CCBijection/Make/index.html new file mode 100644 index 00000000..0a12d184 --- /dev/null +++ b/dev/containers-data/CCBijection/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCBijection.Make)

Module CCBijection.Make

Parameters

module L : OrderedType
module R : OrderedType

Signature

type t
type left = L.t
type right = R.t
val empty : t
val is_empty : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val add : left -> right -> t -> t

Add left and right correspondence to bijection such that left and right are unique in their respective sets and only correspond to each other.

val cardinal : t -> int

Number of bindings. O(n) time.

val mem : left -> right -> t -> bool

Check both sides for key membership.

val mem_left : left -> t -> bool

Check for membership of correspondence using left key.

val mem_right : right -> t -> bool

Check for membership of correspondence using right key.

val find_left : left -> t -> right
  • raises Not_found

    if left is not found.

val find_right : right -> t -> left
  • raises Not_found

    if right is not found.

val remove : left -> right -> t -> t

Remove the left, right binding if it exists. Return the same bijection otherwise.

val remove_left : left -> t -> t

Remove the binding with left key if it exists. Return the same bijection otherwise.

val remove_right : right -> t -> t

Remove the binding with right key if it exists. Return the same bijection otherwise.

val list_left : t -> (left * right) list

Return the bindings as a list of (left, right) values.

val list_right : t -> (right * left) list

Return the bindings as a list of (right, left) values.

val add_iter : (left * right) iter -> t -> t
val of_iter : (left * right) iter -> t
val to_iter : t -> (left * right) iter
val add_list : (left * right) list -> t -> t
val of_list : (left * right) list -> t
val to_list : t -> (left * right) list
\ No newline at end of file diff --git a/dev/containers-data/CCBijection/module-type-OrderedType/index.html b/dev/containers-data/CCBijection/module-type-OrderedType/index.html new file mode 100644 index 00000000..9bcd05d1 --- /dev/null +++ b/dev/containers-data/CCBijection/module-type-OrderedType/index.html @@ -0,0 +1,2 @@ + +OrderedType (containers-data.CCBijection.OrderedType)

Module type CCBijection.OrderedType

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCBijection/module-type-S/index.html b/dev/containers-data/CCBijection/module-type-S/index.html new file mode 100644 index 00000000..e2ac598c --- /dev/null +++ b/dev/containers-data/CCBijection/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCBijection.S)

Module type CCBijection.S

type t
type left
type right
val empty : t
val is_empty : t -> bool
val equal : t -> t -> bool
val compare : t -> t -> int
val add : left -> right -> t -> t

Add left and right correspondence to bijection such that left and right are unique in their respective sets and only correspond to each other.

val cardinal : t -> int

Number of bindings. O(n) time.

val mem : left -> right -> t -> bool

Check both sides for key membership.

val mem_left : left -> t -> bool

Check for membership of correspondence using left key.

val mem_right : right -> t -> bool

Check for membership of correspondence using right key.

val find_left : left -> t -> right
  • raises Not_found

    if left is not found.

val find_right : right -> t -> left
  • raises Not_found

    if right is not found.

val remove : left -> right -> t -> t

Remove the left, right binding if it exists. Return the same bijection otherwise.

val remove_left : left -> t -> t

Remove the binding with left key if it exists. Return the same bijection otherwise.

val remove_right : right -> t -> t

Remove the binding with right key if it exists. Return the same bijection otherwise.

val list_left : t -> (left * right) list

Return the bindings as a list of (left, right) values.

val list_right : t -> (right * left) list

Return the bindings as a list of (right, left) values.

val add_iter : (left * right) iter -> t -> t
val of_iter : (left * right) iter -> t
val to_iter : t -> (left * right) iter
val add_list : (left * right) list -> t -> t
val of_list : (left * right) list -> t
val to_list : t -> (left * right) list
\ No newline at end of file diff --git a/dev/containers-data/CCBitField/Make/argument-1-_/index.html b/dev/containers-data/CCBitField/Make/argument-1-_/index.html new file mode 100644 index 00000000..29dc27e5 --- /dev/null +++ b/dev/containers-data/CCBitField/Make/argument-1-_/index.html @@ -0,0 +1,2 @@ + +_ (containers-data.CCBitField.Make.1-_)

Parameter Make.1-_

\ No newline at end of file diff --git a/dev/containers-data/CCBitField/Make/index.html b/dev/containers-data/CCBitField/Make/index.html new file mode 100644 index 00000000..8ba4e812 --- /dev/null +++ b/dev/containers-data/CCBitField/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCBitField.Make)

Module CCBitField.Make

Create a new bitfield type

Parameters

module _ : sig ... end

Signature

type t = private int

Generative type of bitfields. Each instantiation of the functor should create a new, incompatible type

val empty : t

Empty bitfields (all bits 0).

type field
val get : field -> t -> bool

Get the value of this field.

val set : field -> bool -> t -> t

Set the value of this field.

val mk_field : unit -> field

Make a new field.

val freeze : unit -> unit

Prevent new fields from being added. From now on, creating a field will raise Frozen.

val total_width : unit -> int

Current width of the bitfield.

\ No newline at end of file diff --git a/dev/containers-data/CCBitField/module-type-S/index.html b/dev/containers-data/CCBitField/module-type-S/index.html new file mode 100644 index 00000000..f8547102 --- /dev/null +++ b/dev/containers-data/CCBitField/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCBitField.S)

Module type CCBitField.S

Bitfield Signature

type t = private int

Generative type of bitfields. Each instantiation of the functor should create a new, incompatible type

val empty : t

Empty bitfields (all bits 0).

type field
val get : field -> t -> bool

Get the value of this field.

val set : field -> bool -> t -> t

Set the value of this field.

val mk_field : unit -> field

Make a new field.

val freeze : unit -> unit

Prevent new fields from being added. From now on, creating a field will raise Frozen.

val total_width : unit -> int

Current width of the bitfield.

\ No newline at end of file diff --git a/dev/containers-data/CCGraph/Dot/index.html b/dev/containers-data/CCGraph/Dot/index.html new file mode 100644 index 00000000..046b5be5 --- /dev/null +++ b/dev/containers-data/CCGraph/Dot/index.html @@ -0,0 +1,20 @@ + +Dot (containers-data.CCGraph.Dot)

Module CCGraph.Dot

type attribute = [
| `Color of string
| `Shape of string
| `Weight of int
| `Style of string
| `Label of string
| `Other of string * string
]

Dot attribute

type vertex_state

Hidden state associated to a vertex

val pp : + tbl:( 'v, vertex_state ) table -> + eq:( 'v -> 'v -> bool ) -> + ?attrs_v:( 'v -> attribute list ) -> + ?attrs_e:( 'e -> attribute list ) -> + ?name:string -> + graph:( 'v, 'e ) t -> + Stdlib.Format.formatter -> + 'v -> + unit

Print the graph, starting from given vertex, on the formatter.

  • parameter attrs_v

    attributes for vertices.

  • parameter attrs_e

    attributes for edges.

  • parameter name

    name of the graph.

val pp_all : + tbl:( 'v, vertex_state ) table -> + eq:( 'v -> 'v -> bool ) -> + ?attrs_v:( 'v -> attribute list ) -> + ?attrs_e:( 'e -> attribute list ) -> + ?name:string -> + graph:( 'v, 'e ) t -> + Stdlib.Format.formatter -> + 'v iter -> + unit

Same as pp but starting from several vertices, not just one.

  • since 2.8
val with_out : string -> ( Stdlib.Format.formatter -> 'a ) -> 'a

Shortcut to open a file and write to it.

\ No newline at end of file diff --git a/dev/containers-data/CCGraph/Iter/index.html b/dev/containers-data/CCGraph/Iter/index.html new file mode 100644 index 00000000..3410bb83 --- /dev/null +++ b/dev/containers-data/CCGraph/Iter/index.html @@ -0,0 +1,2 @@ + +Iter (containers-data.CCGraph.Iter)

Module CCGraph.Iter

type 'a t = 'a iter
val return : 'a -> 'a t
val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t
val map : ( 'a -> 'b ) -> 'a t -> 'b t
val filter_map : ( 'a -> 'b option ) -> 'a t -> 'b t
val iter : ( 'a -> unit ) -> 'a t -> unit
val fold : ( 'b -> 'a -> 'b ) -> 'b -> 'a t -> 'b
val to_list : 'a t -> 'a list
\ No newline at end of file diff --git a/dev/containers-data/CCGraph/Lazy_tree/index.html b/dev/containers-data/CCGraph/Lazy_tree/index.html new file mode 100644 index 00000000..e10efb1c --- /dev/null +++ b/dev/containers-data/CCGraph/Lazy_tree/index.html @@ -0,0 +1,2 @@ + +Lazy_tree (containers-data.CCGraph.Lazy_tree)

Module CCGraph.Lazy_tree

type ('v, 'e) t = {
vertex : 'v;
children : ('e * ( 'v, 'e ) t) list Stdlib.Lazy.t;
}
val map_v : ( 'a -> 'b ) -> ( 'a, 'e ) t -> ( 'b, 'e ) t
val fold_v : ( 'acc -> 'v -> 'acc ) -> 'acc -> ( 'v, _ ) t -> 'acc
\ No newline at end of file diff --git a/dev/containers-data/CCGraph/Map/index.html b/dev/containers-data/CCGraph/Map/index.html new file mode 100644 index 00000000..ed5f135d --- /dev/null +++ b/dev/containers-data/CCGraph/Map/index.html @@ -0,0 +1,2 @@ + +Map (containers-data.CCGraph.Map)

Module CCGraph.Map

Parameters

module O : Stdlib.Map.OrderedType

Signature

type vertex = O.t
type 'a t
val as_graph : 'a t -> ( vertex, 'a ) graph

Graph view of the map.

val empty : 'a t
val add_edge : vertex -> 'a -> vertex -> 'a t -> 'a t
val remove_edge : vertex -> vertex -> 'a t -> 'a t
val add : vertex -> 'a t -> 'a t

Add a vertex, possibly with no outgoing edge.

val remove : vertex -> 'a t -> 'a t

Remove the vertex and all its outgoing edges. Edges that point to the vertex are NOT removed, they must be manually removed with remove_edge.

val union : 'a t -> 'a t -> 'a t
val vertices : _ t -> vertex iter
val vertices_l : _ t -> vertex list
val of_list : (vertex * 'a * vertex) list -> 'a t
val add_list : (vertex * 'a * vertex) list -> 'a t -> 'a t
val to_list : 'a t -> (vertex * 'a * vertex) list
val of_iter : (vertex * 'a * vertex) iter -> 'a t
  • since 2.8
val add_iter : (vertex * 'a * vertex) iter -> 'a t -> 'a t
  • since 2.8
val to_iter : 'a t -> (vertex * 'a * vertex) iter
  • since 2.8
\ No newline at end of file diff --git a/dev/containers-data/CCGraph/Traverse/Event/index.html b/dev/containers-data/CCGraph/Traverse/Event/index.html new file mode 100644 index 00000000..d154dae9 --- /dev/null +++ b/dev/containers-data/CCGraph/Traverse/Event/index.html @@ -0,0 +1,12 @@ + +Event (containers-data.CCGraph.Traverse.Event)

Module Traverse.Event

More detailed interface

type edge_kind = [
| `Forward
| `Back
| `Cross
]
type ('v, 'e) t = [
| `Enter of 'v * int * ( 'v, 'e ) path
| `Exit of 'v
| `Edge of 'v * 'e * 'v * edge_kind
]

A traversal is a sequence of such events

val get_vertex : ( 'v, 'e ) t -> ('v * [ `Enter | `Exit ]) option
val get_enter : ( 'v, 'e ) t -> 'v option
val get_exit : ( 'v, 'e ) t -> 'v option
val get_edge : ( 'v, 'e ) t -> ('v * 'e * 'v) option
val get_edge_kind : ( 'v, 'e ) t -> ('v * 'e * 'v * edge_kind) option
val dfs : + tbl:'v set -> + eq:( 'v -> 'v -> bool ) -> + graph:( 'v, 'e ) graph -> + 'v iter -> + ( 'v, 'e ) t iter_once

Full version of DFS.

  • parameter eq

    equality predicate on vertices.

val dfs_tag : + eq:( 'v -> 'v -> bool ) -> + tags:'v tag_set -> + graph:( 'v, 'e ) graph -> + 'v iter -> + ( 'v, 'e ) t iter_once

Full version of DFS using integer tags.

  • parameter eq

    equality predicate on vertices.

\ No newline at end of file diff --git a/dev/containers-data/CCGraph/Traverse/index.html b/dev/containers-data/CCGraph/Traverse/index.html new file mode 100644 index 00000000..b0f134ed --- /dev/null +++ b/dev/containers-data/CCGraph/Traverse/index.html @@ -0,0 +1,22 @@ + +Traverse (containers-data.CCGraph.Traverse)

Module CCGraph.Traverse

type ('v, 'e) path = ('v * 'e * 'v) list
val generic : + tbl:'v set -> + bag:'v bag -> + graph:( 'v, 'e ) t -> + 'v iter -> + 'v iter_once

Traversal of the given graph, starting from a sequence of vertices, using the given bag to choose the next vertex to explore. Each vertex is visited at most once.

val generic_tag : + tags:'v tag_set -> + bag:'v bag -> + graph:( 'v, 'e ) t -> + 'v iter -> + 'v iter_once

One-shot traversal of the graph using a tag set and the given bag.

val dfs : tbl:'v set -> graph:( 'v, 'e ) t -> 'v iter -> 'v iter_once
val dfs_tag : tags:'v tag_set -> graph:( 'v, 'e ) t -> 'v iter -> 'v iter_once
val bfs : tbl:'v set -> graph:( 'v, 'e ) t -> 'v iter -> 'v iter_once
val bfs_tag : tags:'v tag_set -> graph:( 'v, 'e ) t -> 'v iter -> 'v iter_once
val dijkstra : + tbl:'v set -> + ?dist:( 'e -> int ) -> + graph:( 'v, 'e ) t -> + 'v iter -> + ('v * int * ( 'v, 'e ) path) iter_once

Dijkstra algorithm, traverses a graph in increasing distance order. Yields each vertex paired with its distance to the set of initial vertices (the smallest distance needed to reach the node from the initial vertices).

  • parameter dist

    distance from origin of the edge to destination, must be strictly positive. Default is 1 for every edge.

val dijkstra_tag : + ?dist:( 'e -> int ) -> + tags:'v tag_set -> + graph:( 'v, 'e ) t -> + 'v iter -> + ('v * int * ( 'v, 'e ) path) iter_once
module Event : sig ... end
\ No newline at end of file diff --git a/dev/containers-data/CCGraph/module-type-MAP/index.html b/dev/containers-data/CCGraph/module-type-MAP/index.html new file mode 100644 index 00000000..8723c250 --- /dev/null +++ b/dev/containers-data/CCGraph/module-type-MAP/index.html @@ -0,0 +1,2 @@ + +MAP (containers-data.CCGraph.MAP)

Module type CCGraph.MAP

type vertex
type 'a t
val as_graph : 'a t -> ( vertex, 'a ) graph

Graph view of the map.

val empty : 'a t
val add_edge : vertex -> 'a -> vertex -> 'a t -> 'a t
val remove_edge : vertex -> vertex -> 'a t -> 'a t
val add : vertex -> 'a t -> 'a t

Add a vertex, possibly with no outgoing edge.

val remove : vertex -> 'a t -> 'a t

Remove the vertex and all its outgoing edges. Edges that point to the vertex are NOT removed, they must be manually removed with remove_edge.

val union : 'a t -> 'a t -> 'a t
val vertices : _ t -> vertex iter
val vertices_l : _ t -> vertex list
val of_list : (vertex * 'a * vertex) list -> 'a t
val add_list : (vertex * 'a * vertex) list -> 'a t -> 'a t
val to_list : 'a t -> (vertex * 'a * vertex) list
val of_iter : (vertex * 'a * vertex) iter -> 'a t
  • since 2.8
val add_iter : (vertex * 'a * vertex) iter -> 'a t -> 'a t
  • since 2.8
val to_iter : 'a t -> (vertex * 'a * vertex) iter
  • since 2.8
\ No newline at end of file diff --git a/dev/containers-data/CCHashSet/Make/argument-1-E/index.html b/dev/containers-data/CCHashSet/Make/argument-1-E/index.html new file mode 100644 index 00000000..4dcbdb86 --- /dev/null +++ b/dev/containers-data/CCHashSet/Make/argument-1-E/index.html @@ -0,0 +1,2 @@ + +E (containers-data.CCHashSet.Make.1-E)

Parameter Make.1-E

type t
val equal : t -> t -> bool
val hash : t -> int

Positive value

\ No newline at end of file diff --git a/dev/containers-data/CCHashSet/Make/index.html b/dev/containers-data/CCHashSet/Make/index.html new file mode 100644 index 00000000..229e31cf --- /dev/null +++ b/dev/containers-data/CCHashSet/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCHashSet.Make)

Module CCHashSet.Make

Parameters

module E : ELEMENT

Signature

type t
type elt = E.t
val create : int -> t

create n makes a new set with the given capacity n.

val singleton : elt -> t

singleton x is the singleton {x}.

val clear : t -> unit

clear s removes all elements from s.

val copy : t -> t

Fresh copy.

val copy_into : into:t -> t -> unit

copy_into ~into s copies all elements of s into into.

val insert : t -> elt -> unit

insert s x adds x into s.

val remove : t -> elt -> unit

Remove the element, if it were in there.

val cardinal : t -> int

cardinal s returns the number of elements in s.

val mem : t -> elt -> bool

mem s x returns true iff x is in s.

val find_exn : t -> elt -> elt

find_exn s x returns y if x and y are equal, and mem s y.

  • raises Not_found

    if x not in s.

val find : t -> elt -> elt option

Safe version of find_exn.

val inter : t -> t -> t

inter a b returns a ∩ b.

val inter_mut : into:t -> t -> unit

inter_mut ~into a changes into into a ∩ into.

val union : t -> t -> t

union a b returns a ∪ b.

val union_mut : into:t -> t -> unit

union_mut ~into a changes into into a ∪ into.

val diff : t -> t -> t

diff a b returns a - b.

val subset : t -> t -> bool

subset a b returns true if all elements of a are in b.

val equal : t -> t -> bool

equal a b is extensional equality (a and b have the same elements).

val for_all : ( elt -> bool ) -> t -> bool
val exists : ( elt -> bool ) -> t -> bool
val iter : ( elt -> unit ) -> t -> unit

Iterate on values.

val fold : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a

Fold on values.

val elements : t -> elt list

List of elements.

val of_list : elt list -> t
val to_iter : t -> elt iter
val of_iter : elt iter -> t
val add_iter : t -> elt iter -> unit
val pp : ?pp_sep:unit printer -> elt printer -> t printer

pp pp_elt returns a set printer, given a printer for individual elements.

\ No newline at end of file diff --git a/dev/containers-data/CCHashSet/module-type-ELEMENT/index.html b/dev/containers-data/CCHashSet/module-type-ELEMENT/index.html new file mode 100644 index 00000000..01e04e6d --- /dev/null +++ b/dev/containers-data/CCHashSet/module-type-ELEMENT/index.html @@ -0,0 +1,2 @@ + +ELEMENT (containers-data.CCHashSet.ELEMENT)

Module type CCHashSet.ELEMENT

type t
val equal : t -> t -> bool
val hash : t -> int

Positive value

\ No newline at end of file diff --git a/dev/containers-data/CCHashSet/module-type-S/index.html b/dev/containers-data/CCHashSet/module-type-S/index.html new file mode 100644 index 00000000..86e68ed8 --- /dev/null +++ b/dev/containers-data/CCHashSet/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCHashSet.S)

Module type CCHashSet.S

type t
type elt
val create : int -> t

create n makes a new set with the given capacity n.

val singleton : elt -> t

singleton x is the singleton {x}.

val clear : t -> unit

clear s removes all elements from s.

val copy : t -> t

Fresh copy.

val copy_into : into:t -> t -> unit

copy_into ~into s copies all elements of s into into.

val insert : t -> elt -> unit

insert s x adds x into s.

val remove : t -> elt -> unit

Remove the element, if it were in there.

val cardinal : t -> int

cardinal s returns the number of elements in s.

val mem : t -> elt -> bool

mem s x returns true iff x is in s.

val find_exn : t -> elt -> elt

find_exn s x returns y if x and y are equal, and mem s y.

  • raises Not_found

    if x not in s.

val find : t -> elt -> elt option

Safe version of find_exn.

val inter : t -> t -> t

inter a b returns a ∩ b.

val inter_mut : into:t -> t -> unit

inter_mut ~into a changes into into a ∩ into.

val union : t -> t -> t

union a b returns a ∪ b.

val union_mut : into:t -> t -> unit

union_mut ~into a changes into into a ∪ into.

val diff : t -> t -> t

diff a b returns a - b.

val subset : t -> t -> bool

subset a b returns true if all elements of a are in b.

val equal : t -> t -> bool

equal a b is extensional equality (a and b have the same elements).

val for_all : ( elt -> bool ) -> t -> bool
val exists : ( elt -> bool ) -> t -> bool
val iter : ( elt -> unit ) -> t -> unit

Iterate on values.

val fold : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a

Fold on values.

val elements : t -> elt list

List of elements.

val of_list : elt list -> t
val to_iter : t -> elt iter
val of_iter : elt iter -> t
val add_iter : t -> elt iter -> unit
val pp : ?pp_sep:unit printer -> elt printer -> t printer

pp pp_elt returns a set printer, given a printer for individual elements.

\ No newline at end of file diff --git a/dev/containers-data/CCHashTrie/Make/argument-1-K/index.html b/dev/containers-data/CCHashTrie/Make/argument-1-K/index.html new file mode 100644 index 00000000..ccfa81ff --- /dev/null +++ b/dev/containers-data/CCHashTrie/Make/argument-1-K/index.html @@ -0,0 +1,2 @@ + +K (containers-data.CCHashTrie.Make.1-K)

Parameter Make.1-K

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCHashTrie/Make/index.html b/dev/containers-data/CCHashTrie/Make/index.html new file mode 100644 index 00000000..15d736f8 --- /dev/null +++ b/dev/containers-data/CCHashTrie/Make/index.html @@ -0,0 +1,7 @@ + +Make (containers-data.CCHashTrie.Make)

Module CCHashTrie.Make

Functors

Parameters

module K : KEY

Signature

type key = K.t
type 'a t
val empty : 'a t
val is_empty : _ t -> bool
val singleton : key -> 'a -> 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> _ t -> bool
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
  • raises Not_found

    if key not present.

val remove : key -> 'a t -> 'a t

Remove the key, if present.

val update : key -> f:( 'a option -> 'a option ) -> 'a t -> 'a t

update k ~f m calls f (Some v) if get k m = Some v, f None otherwise. Then, if f returns Some v' it binds k to v', if f returns None it removes k.

val add_mut : id:Transient.t -> key -> 'a -> 'a t -> 'a t

add_mut ~id k v m behaves like add k v m, except it will mutate in place whenever possible. Changes done with an id might affect all versions of the structure obtained with the same id (but not other versions).

  • raises Transient.Frozen

    if id is frozen.

val remove_mut : id:Transient.t -> key -> 'a t -> 'a t

Same as remove, but modifies in place whenever possible.

  • raises Transient.Frozen

    if id is frozen.

val update_mut : + id:Transient.t -> + key -> + f:( 'a option -> 'a option ) -> + 'a t -> + 'a t

Same as update but with mutability.

  • raises Transient.Frozen

    if id is frozen.

val cardinal : _ t -> int
val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
  • raises Not_found

    if not pair was found.

val iter : f:( key -> 'a -> unit ) -> 'a t -> unit
val fold : f:( 'b -> key -> 'a -> 'b ) -> x:'b -> 'a t -> 'b
Conversions
val to_list : 'a t -> (key * 'a) list
val add_list : 'a t -> (key * 'a) list -> 'a t
val add_list_mut : id:Transient.t -> 'a t -> (key * 'a) list -> 'a t
  • raises Frozen

    if the ID is frozen.

val of_list : (key * 'a) list -> 'a t
val add_iter : 'a t -> (key * 'a) iter -> 'a t
val add_iter_mut : id:Transient.t -> 'a t -> (key * 'a) iter -> 'a t
  • raises Frozen

    if the ID is frozen.

val of_iter : (key * 'a) iter -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val add_gen : 'a t -> (key * 'a) gen -> 'a t
val add_gen_mut : id:Transient.t -> 'a t -> (key * 'a) gen -> 'a t
  • raises Frozen

    if the ID is frozen.

val of_gen : (key * 'a) gen -> 'a t
val to_gen : 'a t -> (key * 'a) gen
IO
val pp : key printer -> 'a printer -> 'a t printer

Renamed from val print.

  • since 2.0
val as_tree : 'a t -> [ `L of int * (key * 'a) list | `N ] ktree

For debugging purpose: explore the structure of the tree, with `L (h,l) being a leaf (with shared hash h) and `N an inner node.

\ No newline at end of file diff --git a/dev/containers-data/CCHashTrie/Transient/index.html b/dev/containers-data/CCHashTrie/Transient/index.html new file mode 100644 index 00000000..541fb8ae --- /dev/null +++ b/dev/containers-data/CCHashTrie/Transient/index.html @@ -0,0 +1,2 @@ + +Transient (containers-data.CCHashTrie.Transient)

Module CCHashTrie.Transient

Transient Identifiers

type t

Identifiers for transient modifications. A transient modification is uniquely identified by a Transient.t. Once Transient.freeze r is called, r cannot be used to modify the structure again.

val create : unit -> t

Create a new, active ID.

val equal : t -> t -> bool

Equality between IDs.

val frozen : t -> bool

frozen i returns true if freeze i was called before. In this case, the ID cannot be used for modifications again.

val active : t -> bool

active i is not (frozen i).

val freeze : t -> unit

freeze i makes i unusable for new modifications. The values created with i will now be immutable.

val with_ : ( t -> 'a ) -> 'a

with_ f creates a transient ID i, calls f i, freezes the ID i and returns the result of f i.

exception Frozen

Raised when a frozen ID is used.

\ No newline at end of file diff --git a/dev/containers-data/CCHashTrie/module-type-KEY/index.html b/dev/containers-data/CCHashTrie/module-type-KEY/index.html new file mode 100644 index 00000000..46b1c0a6 --- /dev/null +++ b/dev/containers-data/CCHashTrie/module-type-KEY/index.html @@ -0,0 +1,2 @@ + +KEY (containers-data.CCHashTrie.KEY)

Module type CCHashTrie.KEY

Type for keys

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCHashTrie/module-type-S/index.html b/dev/containers-data/CCHashTrie/module-type-S/index.html new file mode 100644 index 00000000..57c1b366 --- /dev/null +++ b/dev/containers-data/CCHashTrie/module-type-S/index.html @@ -0,0 +1,7 @@ + +S (containers-data.CCHashTrie.S)

Module type CCHashTrie.S

Signature

type key
type 'a t
val empty : 'a t
val is_empty : _ t -> bool
val singleton : key -> 'a -> 'a t
val add : key -> 'a -> 'a t -> 'a t
val mem : key -> _ t -> bool
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
  • raises Not_found

    if key not present.

val remove : key -> 'a t -> 'a t

Remove the key, if present.

val update : key -> f:( 'a option -> 'a option ) -> 'a t -> 'a t

update k ~f m calls f (Some v) if get k m = Some v, f None otherwise. Then, if f returns Some v' it binds k to v', if f returns None it removes k.

val add_mut : id:Transient.t -> key -> 'a -> 'a t -> 'a t

add_mut ~id k v m behaves like add k v m, except it will mutate in place whenever possible. Changes done with an id might affect all versions of the structure obtained with the same id (but not other versions).

  • raises Transient.Frozen

    if id is frozen.

val remove_mut : id:Transient.t -> key -> 'a t -> 'a t

Same as remove, but modifies in place whenever possible.

  • raises Transient.Frozen

    if id is frozen.

val update_mut : + id:Transient.t -> + key -> + f:( 'a option -> 'a option ) -> + 'a t -> + 'a t

Same as update but with mutability.

  • raises Transient.Frozen

    if id is frozen.

val cardinal : _ t -> int
val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
  • raises Not_found

    if not pair was found.

val iter : f:( key -> 'a -> unit ) -> 'a t -> unit
val fold : f:( 'b -> key -> 'a -> 'b ) -> x:'b -> 'a t -> 'b
Conversions
val to_list : 'a t -> (key * 'a) list
val add_list : 'a t -> (key * 'a) list -> 'a t
val add_list_mut : id:Transient.t -> 'a t -> (key * 'a) list -> 'a t
  • raises Frozen

    if the ID is frozen.

val of_list : (key * 'a) list -> 'a t
val add_iter : 'a t -> (key * 'a) iter -> 'a t
val add_iter_mut : id:Transient.t -> 'a t -> (key * 'a) iter -> 'a t
  • raises Frozen

    if the ID is frozen.

val of_iter : (key * 'a) iter -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val add_gen : 'a t -> (key * 'a) gen -> 'a t
val add_gen_mut : id:Transient.t -> 'a t -> (key * 'a) gen -> 'a t
  • raises Frozen

    if the ID is frozen.

val of_gen : (key * 'a) gen -> 'a t
val to_gen : 'a t -> (key * 'a) gen
IO
val pp : key printer -> 'a printer -> 'a t printer

Renamed from val print.

  • since 2.0
val as_tree : 'a t -> [ `L of int * (key * 'a) list | `N ] ktree

For debugging purpose: explore the structure of the tree, with `L (h,l) being a leaf (with shared hash h) and `N an inner node.

\ No newline at end of file diff --git a/dev/containers-data/CCHet/Key/index.html b/dev/containers-data/CCHet/Key/index.html new file mode 100644 index 00000000..c4809928 --- /dev/null +++ b/dev/containers-data/CCHet/Key/index.html @@ -0,0 +1,2 @@ + +Key (containers-data.CCHet.Key)

Module CCHet.Key

type 'a t
val create : unit -> 'a t
val equal : 'a t -> 'a t -> bool

Compare two keys that have compatible types.

\ No newline at end of file diff --git a/dev/containers-data/CCHet/Map/index.html b/dev/containers-data/CCHet/Map/index.html new file mode 100644 index 00000000..279d4829 --- /dev/null +++ b/dev/containers-data/CCHet/Map/index.html @@ -0,0 +1,2 @@ + +Map (containers-data.CCHet.Map)

Module CCHet.Map

Immutable map

type t
val empty : t
val mem : _ Key.t -> t -> bool
val add : 'a Key.t -> 'a -> t -> t
val remove : _ Key.t -> t -> t
val length : t -> int
val cardinal : t -> int
val find : 'a Key.t -> t -> 'a option
val find_exn : 'a Key.t -> t -> 'a
  • raises Not_found

    if the key is not in the table.

val iter : ( pair -> unit ) -> t -> unit
val to_iter : t -> pair iter
val of_iter : pair iter -> t
val add_iter : t -> pair iter -> t
val add_list : t -> pair list -> t
val of_list : pair list -> t
val to_list : t -> pair list
\ No newline at end of file diff --git a/dev/containers-data/CCHet/Tbl/index.html b/dev/containers-data/CCHet/Tbl/index.html new file mode 100644 index 00000000..94c97285 --- /dev/null +++ b/dev/containers-data/CCHet/Tbl/index.html @@ -0,0 +1,2 @@ + +Tbl (containers-data.CCHet.Tbl)

Module CCHet.Tbl

Imperative table indexed by Key

type t
val create : ?size:int -> unit -> t
val mem : t -> _ Key.t -> bool
val add : t -> 'a Key.t -> 'a -> unit
val remove : t -> _ Key.t -> unit
val length : t -> int
val find : t -> 'a Key.t -> 'a option
val find_exn : t -> 'a Key.t -> 'a
  • raises Not_found

    if the key is not in the table.

val iter : ( pair -> unit ) -> t -> unit
val to_iter : t -> pair iter
val of_iter : pair iter -> t
val add_iter : t -> pair iter -> unit
val add_list : t -> pair list -> unit
val of_list : pair list -> t
val to_list : t -> pair list
\ No newline at end of file diff --git a/dev/containers-data/CCKTree/Dot/index.html b/dev/containers-data/CCKTree/Dot/index.html new file mode 100644 index 00000000..dca613c9 --- /dev/null +++ b/dev/containers-data/CCKTree/Dot/index.html @@ -0,0 +1,2 @@ + +Dot (containers-data.CCKTree.Dot)

Module CCKTree.Dot

type attribute = [
| `Color of string
| `Shape of string
| `Weight of int
| `Style of string
| `Label of string
| `Id of string(*

Unique ID in the graph. Allows sharing.

*)
| `Other of string * string
]

Dot attributes for nodes

type graph = string * attribute list t list

A dot graph is a name, plus a list of trees labelled with attributes

val mk_id : ( 'a, Stdlib.Buffer.t, unit, attribute ) Stdlib.format4 -> 'a

Using a formatter string, build an ID.

val mk_label : ( 'a, Stdlib.Buffer.t, unit, attribute ) Stdlib.format4 -> 'a

Using a formatter string, build a label.

val make : name:string -> attribute list t list -> graph
val singleton : name:string -> attribute list t -> graph
val pp_single : string -> attribute list t printer
val pp : graph printer

Printer to DOT with indentation, etc.

  • since 0.6.1
val print_to_file : string -> graph -> unit

print_to_file filename g prints g into a file whose name is filename.

  • since 0.6.1
val to_file : ?name:string -> string -> attribute list t list -> unit

to_file filename trees makes a graph out of the trees, opens the file filename and prints the graph into the file.

  • parameter name

    name of the graph.

  • since 0.6.1
\ No newline at end of file diff --git a/dev/containers-data/CCKTree/class-type-pset/index.html b/dev/containers-data/CCKTree/class-type-pset/index.html new file mode 100644 index 00000000..2120caef --- /dev/null +++ b/dev/containers-data/CCKTree/class-type-pset/index.html @@ -0,0 +1,2 @@ + +pset (containers-data.CCKTree.pset)

Class type CCKTree.pset

Abstract Set structure

method add : 'a -> 'a pset
method mem : 'a -> bool
\ No newline at end of file diff --git a/dev/containers-data/CCLazy_list/Infix/index.html b/dev/containers-data/CCLazy_list/Infix/index.html new file mode 100644 index 00000000..47555026 --- /dev/null +++ b/dev/containers-data/CCLazy_list/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers-data.CCLazy_list.Infix)

Module CCLazy_list.Infix

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t
val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t
val (<|>) : 'a t -> 'a t -> 'a t

Alias to default.

  • since 2.1
\ No newline at end of file diff --git a/dev/containers-data/CCMixmap/Make/argument-1-X/index.html b/dev/containers-data/CCMixmap/Make/argument-1-X/index.html new file mode 100644 index 00000000..f00a1e0d --- /dev/null +++ b/dev/containers-data/CCMixmap/Make/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers-data.CCMixmap.Make.1-X)

Parameter Make.1-X

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCMixmap/Make/index.html b/dev/containers-data/CCMixmap/Make/index.html new file mode 100644 index 00000000..87c7812a --- /dev/null +++ b/dev/containers-data/CCMixmap/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCMixmap.Make)

Module CCMixmap.Make

Parameters

module X : ORD

Signature

type key = X.t
type t

A map containing values of different types, indexed by key.

val empty : t

Empty map.

val get : inj:'a injection -> key -> t -> 'a option

Get the value corresponding to this key, if it exists and belongs to the same key.

val add : inj:'a injection -> key -> 'a -> t -> t

Bind the key to the value, using inj.

val find : inj:'a injection -> key -> t -> 'a

Find the value for the given key, which must be of the right type.

  • raises Not_found

    if either the key is not found, or if its value doesn't belong to the right type.

val cardinal : t -> int

Number of bindings.

val remove : key -> t -> t

Remove the binding for this key.

val mem : inj:_ injection -> key -> t -> bool

Is the given key in the map, with the right type?

val iter_keys : f:( key -> unit ) -> t -> unit

Iterate on the keys of this map.

val fold_keys : f:( 'a -> key -> 'a ) -> x:'a -> t -> 'a

Fold over the keys.

Iterators

type 'a iter = ( 'a -> unit ) -> unit
val keys_iter : t -> key iter

All the keys.

val bindings_of : inj:'a injection -> t -> (key * 'a) iter

All the bindings that come from the corresponding injection.

type value =
| Value : ( 'a injection -> 'a option ) -> value
val bindings : t -> (key * value) iter

Iterate on all bindings.

\ No newline at end of file diff --git a/dev/containers-data/CCMixmap/module-type-ORD/index.html b/dev/containers-data/CCMixmap/module-type-ORD/index.html new file mode 100644 index 00000000..85dd12e5 --- /dev/null +++ b/dev/containers-data/CCMixmap/module-type-ORD/index.html @@ -0,0 +1,2 @@ + +ORD (containers-data.CCMixmap.ORD)

Module type CCMixmap.ORD

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCMixmap/module-type-S/index.html b/dev/containers-data/CCMixmap/module-type-S/index.html new file mode 100644 index 00000000..4981811b --- /dev/null +++ b/dev/containers-data/CCMixmap/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCMixmap.S)

Module type CCMixmap.S

type key
type t

A map containing values of different types, indexed by key.

val empty : t

Empty map.

val get : inj:'a injection -> key -> t -> 'a option

Get the value corresponding to this key, if it exists and belongs to the same key.

val add : inj:'a injection -> key -> 'a -> t -> t

Bind the key to the value, using inj.

val find : inj:'a injection -> key -> t -> 'a

Find the value for the given key, which must be of the right type.

  • raises Not_found

    if either the key is not found, or if its value doesn't belong to the right type.

val cardinal : t -> int

Number of bindings.

val remove : key -> t -> t

Remove the binding for this key.

val mem : inj:_ injection -> key -> t -> bool

Is the given key in the map, with the right type?

val iter_keys : f:( key -> unit ) -> t -> unit

Iterate on the keys of this map.

val fold_keys : f:( 'a -> key -> 'a ) -> x:'a -> t -> 'a

Fold over the keys.

Iterators

type 'a iter = ( 'a -> unit ) -> unit
val keys_iter : t -> key iter

All the keys.

val bindings_of : inj:'a injection -> t -> (key * 'a) iter

All the bindings that come from the corresponding injection.

type value =
| Value : ( 'a injection -> 'a option ) -> value
val bindings : t -> (key * value) iter

Iterate on all bindings.

\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/Make/argument-1-K/index.html b/dev/containers-data/CCMultiMap/Make/argument-1-K/index.html new file mode 100644 index 00000000..695b09f1 --- /dev/null +++ b/dev/containers-data/CCMultiMap/Make/argument-1-K/index.html @@ -0,0 +1,2 @@ + +K (containers-data.CCMultiMap.Make.1-K)

Parameter Make.1-K

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/Make/argument-2-V/index.html b/dev/containers-data/CCMultiMap/Make/argument-2-V/index.html new file mode 100644 index 00000000..dfea939d --- /dev/null +++ b/dev/containers-data/CCMultiMap/Make/argument-2-V/index.html @@ -0,0 +1,2 @@ + +V (containers-data.CCMultiMap.Make.2-V)

Parameter Make.2-V

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/Make/index.html b/dev/containers-data/CCMultiMap/Make/index.html new file mode 100644 index 00000000..7e7b915e --- /dev/null +++ b/dev/containers-data/CCMultiMap/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCMultiMap.Make)

Module CCMultiMap.Make

Parameters

module K : OrderedType
module V : OrderedType

Signature

type key = K.t
type value = V.t
type t
val empty : t

Empty multimap.

val is_empty : t -> bool

Empty multimap?

val add : t -> key -> value -> t

Add a key/value binding.

val remove : t -> key -> value -> t

Remove the binding.

val remove_all : t -> key -> t

Remove the key from the map.

val mem : t -> key -> bool

Is there a binding for this key?

val find : t -> key -> value list

List of values for this key.

val find_iter : t -> key -> ( value -> unit ) -> unit

Iterate on bindings for this key.

val count : t -> key -> int

Number of bindings for this key.

val iter : t -> ( key -> value -> unit ) -> unit

Iterate on all key/value.

val fold : t -> 'a -> ( 'a -> key -> value -> 'a ) -> 'a

Fold on all key/value.

val size : t -> int

Number of keys.

val union : t -> t -> t

Union of multimaps.

val inter : t -> t -> t

Intersection of multimaps.

val diff : t -> t -> t

Difference of maps, i.e. bindings of the first that are not in the second.

val equal : t -> t -> bool

Same multimap.

val compare : t -> t -> int

Total order on multimaps.

val submap : t -> t -> bool

submap m1 m2 is true iff all bindings of m1 are also in m2.

val to_iter : t -> (key * value) iter
val of_iter : ?init:t -> (key * value) iter -> t
val keys : t -> key iter
val values : t -> value iter

Some values may occur several times.

\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/MakeBidir/argument-1-L/index.html b/dev/containers-data/CCMultiMap/MakeBidir/argument-1-L/index.html new file mode 100644 index 00000000..aaf310e5 --- /dev/null +++ b/dev/containers-data/CCMultiMap/MakeBidir/argument-1-L/index.html @@ -0,0 +1,2 @@ + +L (containers-data.CCMultiMap.MakeBidir.1-L)

Parameter MakeBidir.1-L

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/MakeBidir/argument-2-R/index.html b/dev/containers-data/CCMultiMap/MakeBidir/argument-2-R/index.html new file mode 100644 index 00000000..8d63bfab --- /dev/null +++ b/dev/containers-data/CCMultiMap/MakeBidir/argument-2-R/index.html @@ -0,0 +1,2 @@ + +R (containers-data.CCMultiMap.MakeBidir.2-R)

Parameter MakeBidir.2-R

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/MakeBidir/index.html b/dev/containers-data/CCMultiMap/MakeBidir/index.html new file mode 100644 index 00000000..78fd1b9c --- /dev/null +++ b/dev/containers-data/CCMultiMap/MakeBidir/index.html @@ -0,0 +1,2 @@ + +MakeBidir (containers-data.CCMultiMap.MakeBidir)

Module CCMultiMap.MakeBidir

Parameters

module L : OrderedType
module R : OrderedType

Signature

type t
type left = L.t
type right = R.t
val empty : t
val is_empty : t -> bool
val add : t -> left -> right -> t

Add a binding (left,right).

val remove : t -> left -> right -> t

Remove a specific binding.

val cardinal_left : t -> int

Number of distinct left keys.

val cardinal_right : t -> int

Number of distinct right keys.

val remove_left : t -> left -> t

Remove all bindings for the left key.

val remove_right : t -> right -> t

Remove all bindings for the right key.

val mem_left : t -> left -> bool

Is the left key present in at least one pair?

val mem_right : t -> right -> bool

Is the right key present in at least one pair?

val find_left : t -> left -> right iter

Find all bindings for this given left-key.

val find_right : t -> right -> left iter

Find all bindings for this given right-key.

val find1_left : t -> left -> right option

Like find_left but returns at most one value.

val find1_right : t -> right -> left option

Like find_right but returns at most one value.

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

Fold on pairs.

val pairs : t -> (left * right) iter

Iterate on pairs.

val add_pairs : t -> (left * right) iter -> t

Add pairs.

val iter_left : t -> left iter
val iter_right : t -> right iter
\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/module-type-BIDIR/index.html b/dev/containers-data/CCMultiMap/module-type-BIDIR/index.html new file mode 100644 index 00000000..b3c09954 --- /dev/null +++ b/dev/containers-data/CCMultiMap/module-type-BIDIR/index.html @@ -0,0 +1,2 @@ + +BIDIR (containers-data.CCMultiMap.BIDIR)

Module type CCMultiMap.BIDIR

type t
type left
type right
val empty : t
val is_empty : t -> bool
val add : t -> left -> right -> t

Add a binding (left,right).

val remove : t -> left -> right -> t

Remove a specific binding.

val cardinal_left : t -> int

Number of distinct left keys.

val cardinal_right : t -> int

Number of distinct right keys.

val remove_left : t -> left -> t

Remove all bindings for the left key.

val remove_right : t -> right -> t

Remove all bindings for the right key.

val mem_left : t -> left -> bool

Is the left key present in at least one pair?

val mem_right : t -> right -> bool

Is the right key present in at least one pair?

val find_left : t -> left -> right iter

Find all bindings for this given left-key.

val find_right : t -> right -> left iter

Find all bindings for this given right-key.

val find1_left : t -> left -> right option

Like find_left but returns at most one value.

val find1_right : t -> right -> left option

Like find_right but returns at most one value.

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

Fold on pairs.

val pairs : t -> (left * right) iter

Iterate on pairs.

val add_pairs : t -> (left * right) iter -> t

Add pairs.

val iter_left : t -> left iter
val iter_right : t -> right iter
\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/module-type-OrderedType/index.html b/dev/containers-data/CCMultiMap/module-type-OrderedType/index.html new file mode 100644 index 00000000..2971425d --- /dev/null +++ b/dev/containers-data/CCMultiMap/module-type-OrderedType/index.html @@ -0,0 +1,2 @@ + +OrderedType (containers-data.CCMultiMap.OrderedType)

Module type CCMultiMap.OrderedType

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCMultiMap/module-type-S/index.html b/dev/containers-data/CCMultiMap/module-type-S/index.html new file mode 100644 index 00000000..d2b14b48 --- /dev/null +++ b/dev/containers-data/CCMultiMap/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCMultiMap.S)

Module type CCMultiMap.S

type key
type value
type t
val empty : t

Empty multimap.

val is_empty : t -> bool

Empty multimap?

val add : t -> key -> value -> t

Add a key/value binding.

val remove : t -> key -> value -> t

Remove the binding.

val remove_all : t -> key -> t

Remove the key from the map.

val mem : t -> key -> bool

Is there a binding for this key?

val find : t -> key -> value list

List of values for this key.

val find_iter : t -> key -> ( value -> unit ) -> unit

Iterate on bindings for this key.

val count : t -> key -> int

Number of bindings for this key.

val iter : t -> ( key -> value -> unit ) -> unit

Iterate on all key/value.

val fold : t -> 'a -> ( 'a -> key -> value -> 'a ) -> 'a

Fold on all key/value.

val size : t -> int

Number of keys.

val union : t -> t -> t

Union of multimaps.

val inter : t -> t -> t

Intersection of multimaps.

val diff : t -> t -> t

Difference of maps, i.e. bindings of the first that are not in the second.

val equal : t -> t -> bool

Same multimap.

val compare : t -> t -> int

Total order on multimaps.

val submap : t -> t -> bool

submap m1 m2 is true iff all bindings of m1 are also in m2.

val to_iter : t -> (key * value) iter
val of_iter : ?init:t -> (key * value) iter -> t
val keys : t -> key iter
val values : t -> value iter

Some values may occur several times.

\ No newline at end of file diff --git a/dev/containers-data/CCMultiSet/Make/index.html b/dev/containers-data/CCMultiSet/Make/index.html new file mode 100644 index 00000000..15a7e7f0 --- /dev/null +++ b/dev/containers-data/CCMultiSet/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCMultiSet.Make)

Module CCMultiSet.Make

Parameters

module O : Stdlib.Set.OrderedType

Signature

type elt = O.t
type t
val empty : t
val is_empty : t -> bool
val mem : t -> elt -> bool
val count : t -> elt -> int
val singleton : elt -> t
val add : t -> elt -> t
val remove : t -> elt -> t
val add_mult : t -> elt -> int -> t

add_mult set x n adds n occurrences of x to set.

  • raises Invalid_argument

    if n < 0.

  • since 0.6
val remove_mult : t -> elt -> int -> t

remove_mult set x n removes at most n occurrences of x from set.

  • raises Invalid_argument

    if n < 0.

  • since 0.6
val remove_all : t -> elt -> t

remove_all set x removes all occurrences of x from set.

  • since 0.22
val update : t -> elt -> ( int -> int ) -> t

update set x f calls f n where n is the current multiplicity of x in set (0 to indicate its absence); the result of f n is the new multiplicity of x.

  • raises Invalid_argument

    if f n < 0.

  • since 0.6
val min : t -> elt

Minimal element w.r.t the total ordering on elements.

val max : t -> elt

Maximal element w.r.t the total ordering on elements.

val union : t -> t -> t

union a b contains as many occurrences of an element x as count a x + count b x.

val meet : t -> t -> t

meet a b is a multiset such that count (meet a b) x = max (count a x) (count b x).

val intersection : t -> t -> t

intersection a b is a multiset such that count (intersection a b) x = min (count a x) (count b x).

val diff : t -> t -> t

MultiSet difference. count (diff a b) x = max (count a x - count b x) 0.

val contains : t -> t -> bool

contains a x = (count m x > 0).

val compare : t -> t -> int
val equal : t -> t -> bool
val cardinal : t -> int

Number of distinct elements.

val iter : t -> ( int -> elt -> unit ) -> unit
val fold : t -> 'b -> ( 'b -> int -> elt -> 'b ) -> 'b
val of_list : elt list -> t
val to_list : t -> elt list
val to_iter : t -> elt iter
val of_iter : elt iter -> t
val of_list_mult : (elt * int) list -> t
  • since 0.19
val to_list_mult : t -> (elt * int) list
  • since 0.19
val to_iter_mult : t -> (elt * int) iter
  • since 0.19
val of_iter_mult : (elt * int) iter -> t
  • since 0.19
\ No newline at end of file diff --git a/dev/containers-data/CCMultiSet/module-type-S/index.html b/dev/containers-data/CCMultiSet/module-type-S/index.html new file mode 100644 index 00000000..8bba78e3 --- /dev/null +++ b/dev/containers-data/CCMultiSet/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCMultiSet.S)

Module type CCMultiSet.S

type elt
type t
val empty : t
val is_empty : t -> bool
val mem : t -> elt -> bool
val count : t -> elt -> int
val singleton : elt -> t
val add : t -> elt -> t
val remove : t -> elt -> t
val add_mult : t -> elt -> int -> t

add_mult set x n adds n occurrences of x to set.

  • raises Invalid_argument

    if n < 0.

  • since 0.6
val remove_mult : t -> elt -> int -> t

remove_mult set x n removes at most n occurrences of x from set.

  • raises Invalid_argument

    if n < 0.

  • since 0.6
val remove_all : t -> elt -> t

remove_all set x removes all occurrences of x from set.

  • since 0.22
val update : t -> elt -> ( int -> int ) -> t

update set x f calls f n where n is the current multiplicity of x in set (0 to indicate its absence); the result of f n is the new multiplicity of x.

  • raises Invalid_argument

    if f n < 0.

  • since 0.6
val min : t -> elt

Minimal element w.r.t the total ordering on elements.

val max : t -> elt

Maximal element w.r.t the total ordering on elements.

val union : t -> t -> t

union a b contains as many occurrences of an element x as count a x + count b x.

val meet : t -> t -> t

meet a b is a multiset such that count (meet a b) x = max (count a x) (count b x).

val intersection : t -> t -> t

intersection a b is a multiset such that count (intersection a b) x = min (count a x) (count b x).

val diff : t -> t -> t

MultiSet difference. count (diff a b) x = max (count a x - count b x) 0.

val contains : t -> t -> bool

contains a x = (count m x > 0).

val compare : t -> t -> int
val equal : t -> t -> bool
val cardinal : t -> int

Number of distinct elements.

val iter : t -> ( int -> elt -> unit ) -> unit
val fold : t -> 'b -> ( 'b -> int -> elt -> 'b ) -> 'b
val of_list : elt list -> t
val to_list : t -> elt list
val to_iter : t -> elt iter
val of_iter : elt iter -> t
val of_list_mult : (elt * int) list -> t
  • since 0.19
val to_list_mult : t -> (elt * int) list
  • since 0.19
val to_iter_mult : t -> (elt * int) iter
  • since 0.19
val of_iter_mult : (elt * int) iter -> t
  • since 0.19
\ No newline at end of file diff --git a/dev/containers-data/CCMutHeap/Make/argument-1-X/index.html b/dev/containers-data/CCMutHeap/Make/argument-1-X/index.html new file mode 100644 index 00000000..76fa090f --- /dev/null +++ b/dev/containers-data/CCMutHeap/Make/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers-data.CCMutHeap.Make.1-X)

Parameter Make.1-X

type t
val idx : t -> int

Index in heap. return -1 if never set

val set_idx : t -> int -> unit

Update index in heap

val lt : t -> t -> bool

cmp a b is true iff a < b

\ No newline at end of file diff --git a/dev/containers-data/CCMutHeap/Make/index.html b/dev/containers-data/CCMutHeap/Make/index.html new file mode 100644 index 00000000..422e9467 --- /dev/null +++ b/dev/containers-data/CCMutHeap/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCMutHeap.Make)

Module CCMutHeap.Make

Parameters

module X : RANKED

Signature

type elt = X.t

Type of elements

type t

Heap of elt, whose priority is increased or decreased incrementally (see decrease for instance)

val create : unit -> t

Create a heap

val decrease : t -> elt -> unit

decrease h x decreases the value associated to x within h

val increase : t -> elt -> unit

increase h x increases the value associated to x within h

val in_heap : elt -> bool
val size : t -> int

Number of integers within the heap

val is_empty : t -> bool
val clear : t -> unit

Clear the content of the heap

val insert : t -> elt -> unit

Insert a new element into the heap

val remove_min : t -> elt

Remove and return the integer that has the lowest value from the heap

  • raises Not_found

    if the heap is empty

val filter : t -> ( elt -> bool ) -> unit

Filter out values that don't satisfy the predicate

\ No newline at end of file diff --git a/dev/containers-data/CCMutHeap_intf/module-type-RANKED/index.html b/dev/containers-data/CCMutHeap_intf/module-type-RANKED/index.html new file mode 100644 index 00000000..fa23f9e1 --- /dev/null +++ b/dev/containers-data/CCMutHeap_intf/module-type-RANKED/index.html @@ -0,0 +1,2 @@ + +RANKED (containers-data.CCMutHeap_intf.RANKED)

Module type CCMutHeap_intf.RANKED

type t
val idx : t -> int

Index in heap. return -1 if never set

val set_idx : t -> int -> unit

Update index in heap

val lt : t -> t -> bool

cmp a b is true iff a < b

\ No newline at end of file diff --git a/dev/containers-data/CCMutHeap_intf/module-type-S/index.html b/dev/containers-data/CCMutHeap_intf/module-type-S/index.html new file mode 100644 index 00000000..226a5ac5 --- /dev/null +++ b/dev/containers-data/CCMutHeap_intf/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCMutHeap_intf.S)

Module type CCMutHeap_intf.S

type elt

Type of elements

type t

Heap of elt, whose priority is increased or decreased incrementally (see decrease for instance)

val create : unit -> t

Create a heap

val decrease : t -> elt -> unit

decrease h x decreases the value associated to x within h

val increase : t -> elt -> unit

increase h x increases the value associated to x within h

val in_heap : elt -> bool
val size : t -> int

Number of integers within the heap

val is_empty : t -> bool
val clear : t -> unit

Clear the content of the heap

val insert : t -> elt -> unit

Insert a new element into the heap

val remove_min : t -> elt

Remove and return the integer that has the lowest value from the heap

  • raises Not_found

    if the heap is empty

val filter : t -> ( elt -> bool ) -> unit

Filter out values that don't satisfy the predicate

\ No newline at end of file diff --git a/dev/containers-data/CCPersistentHashtbl/Make/argument-1-H/index.html b/dev/containers-data/CCPersistentHashtbl/Make/argument-1-H/index.html new file mode 100644 index 00000000..e0cbdf7f --- /dev/null +++ b/dev/containers-data/CCPersistentHashtbl/Make/argument-1-H/index.html @@ -0,0 +1,2 @@ + +H (containers-data.CCPersistentHashtbl.Make.1-H)

Parameter Make.1-H

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCPersistentHashtbl/Make/index.html b/dev/containers-data/CCPersistentHashtbl/Make/index.html new file mode 100644 index 00000000..e2dab6d9 --- /dev/null +++ b/dev/containers-data/CCPersistentHashtbl/Make/index.html @@ -0,0 +1,13 @@ + +Make (containers-data.CCPersistentHashtbl.Make)

Module CCPersistentHashtbl.Make

Parameters

module H : HashedType

Signature

type key = H.t
type 'a t
val empty : unit -> 'a t

Empty table. The table will be allocated at the first binding.

val create : int -> 'a t

Create a new hashtable, with the given initial capacity.

val is_empty : 'a t -> bool

Is the table empty?

val find : 'a t -> key -> 'a

Find the value for this key, or fails.

  • raises Not_found

    if the key is not present in the table.

val get_exn : key -> 'a t -> 'a

Synonym to find with flipped arguments.

val get : key -> 'a t -> 'a option

Safe version of get_exn.

val mem : 'a t -> key -> bool

Is the key bound?

val length : _ t -> int

Number of bindings.

val add : 'a t -> key -> 'a -> 'a t

Add the binding to the table, returning a new table. The old binding for this key, if it exists, is shadowed and will be restored upon remove tbl k.

  • since 0.14
val replace : 'a t -> key -> 'a -> 'a t

Add the binding to the table, returning a new table. This erases the current binding for key, if any.

val update : 'a t -> key -> ( 'a option -> 'a option ) -> 'a t

update tbl key f calls f None if key doesn't belong in tbl, f (Some v) if key -> v otherwise; If f returns None then key is removed, else it returns Some v' and key -> v' is added.

val remove : 'a t -> key -> 'a t

Remove the key.

val copy : 'a t -> 'a t

Fresh copy of the table; the underlying structure is not shared anymore, so using both tables alternatively will be efficient.

val merge : + f:( key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option ) -> + 'a t -> + 'b t -> + 'c t

Merge two tables together into a new table. The function's argument correspond to values associated with the key (if present); if the function returns None the key will not appear in the result.

val iter : 'a t -> ( key -> 'a -> unit ) -> unit

Iterate over bindings.

val fold : ( 'b -> key -> 'a -> 'b ) -> 'b -> 'a t -> 'b

Fold over bindings.

val map : ( key -> 'a -> 'b ) -> 'a t -> 'b t

Map all values.

val filter : ( key -> 'a -> bool ) -> 'a t -> 'a t
val filter_map : ( key -> 'a -> 'b option ) -> 'a t -> 'b t
val for_all : ( key -> 'a -> bool ) -> 'a t -> bool
val exists : ( key -> 'a -> bool ) -> 'a t -> bool

Conversions

val of_iter : (key * 'a) iter -> 'a t

Add (replace) bindings from the sequence to the table.

val of_list : (key * 'a) list -> 'a t
val add_iter : 'a t -> (key * 'a) iter -> 'a t
val add_list : 'a t -> (key * 'a) list -> 'a t
val to_iter : 'a t -> (key * 'a) iter

Iter of the bindings of the table.

val to_list : 'a t -> (key * 'a) list

Misc

val equal : 'a equal -> 'a t equal
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + ?pp_arrow:unit printer -> + key printer -> + 'a printer -> + 'a t printer
val stats : _ t -> Stdlib.Hashtbl.statistics

Statistics on the internal table.

  • since 0.14
\ No newline at end of file diff --git a/dev/containers-data/CCPersistentHashtbl/module-type-HashedType/index.html b/dev/containers-data/CCPersistentHashtbl/module-type-HashedType/index.html new file mode 100644 index 00000000..ce61d9b5 --- /dev/null +++ b/dev/containers-data/CCPersistentHashtbl/module-type-HashedType/index.html @@ -0,0 +1,2 @@ + +HashedType (containers-data.CCPersistentHashtbl.HashedType)

Module type CCPersistentHashtbl.HashedType

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCPersistentHashtbl/module-type-S/index.html b/dev/containers-data/CCPersistentHashtbl/module-type-S/index.html new file mode 100644 index 00000000..4db3ccfd --- /dev/null +++ b/dev/containers-data/CCPersistentHashtbl/module-type-S/index.html @@ -0,0 +1,13 @@ + +S (containers-data.CCPersistentHashtbl.S)

Module type CCPersistentHashtbl.S

type key
type 'a t
val empty : unit -> 'a t

Empty table. The table will be allocated at the first binding.

val create : int -> 'a t

Create a new hashtable, with the given initial capacity.

val is_empty : 'a t -> bool

Is the table empty?

val find : 'a t -> key -> 'a

Find the value for this key, or fails.

  • raises Not_found

    if the key is not present in the table.

val get_exn : key -> 'a t -> 'a

Synonym to find with flipped arguments.

val get : key -> 'a t -> 'a option

Safe version of get_exn.

val mem : 'a t -> key -> bool

Is the key bound?

val length : _ t -> int

Number of bindings.

val add : 'a t -> key -> 'a -> 'a t

Add the binding to the table, returning a new table. The old binding for this key, if it exists, is shadowed and will be restored upon remove tbl k.

  • since 0.14
val replace : 'a t -> key -> 'a -> 'a t

Add the binding to the table, returning a new table. This erases the current binding for key, if any.

val update : 'a t -> key -> ( 'a option -> 'a option ) -> 'a t

update tbl key f calls f None if key doesn't belong in tbl, f (Some v) if key -> v otherwise; If f returns None then key is removed, else it returns Some v' and key -> v' is added.

val remove : 'a t -> key -> 'a t

Remove the key.

val copy : 'a t -> 'a t

Fresh copy of the table; the underlying structure is not shared anymore, so using both tables alternatively will be efficient.

val merge : + f:( key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option ) -> + 'a t -> + 'b t -> + 'c t

Merge two tables together into a new table. The function's argument correspond to values associated with the key (if present); if the function returns None the key will not appear in the result.

val iter : 'a t -> ( key -> 'a -> unit ) -> unit

Iterate over bindings.

val fold : ( 'b -> key -> 'a -> 'b ) -> 'b -> 'a t -> 'b

Fold over bindings.

val map : ( key -> 'a -> 'b ) -> 'a t -> 'b t

Map all values.

val filter : ( key -> 'a -> bool ) -> 'a t -> 'a t
val filter_map : ( key -> 'a -> 'b option ) -> 'a t -> 'b t
val for_all : ( key -> 'a -> bool ) -> 'a t -> bool
val exists : ( key -> 'a -> bool ) -> 'a t -> bool

Conversions

val of_iter : (key * 'a) iter -> 'a t

Add (replace) bindings from the sequence to the table.

val of_list : (key * 'a) list -> 'a t
val add_iter : 'a t -> (key * 'a) iter -> 'a t
val add_list : 'a t -> (key * 'a) list -> 'a t
val to_iter : 'a t -> (key * 'a) iter

Iter of the bindings of the table.

val to_list : 'a t -> (key * 'a) list

Misc

val equal : 'a equal -> 'a t equal
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + ?pp_arrow:unit printer -> + key printer -> + 'a printer -> + 'a t printer
val stats : _ t -> Stdlib.Hashtbl.statistics

Statistics on the internal table.

  • since 0.14
\ No newline at end of file diff --git a/dev/containers-data/CCRAL/Infix/index.html b/dev/containers-data/CCRAL/Infix/index.html new file mode 100644 index 00000000..c17fa2e4 --- /dev/null +++ b/dev/containers-data/CCRAL/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers-data.CCRAL.Infix)

Module CCRAL.Infix

val (@+) : 'a -> 'a t -> 'a t

Cons (alias to cons).

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

Alias to flat_map.

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

Alias to map.

val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t

Alias to app.

val (--) : int -> int -> int t

Alias to range.

val (--^) : int -> int -> int t

a --^ b is the integer range from a to b, where b is excluded.

  • since 0.17
\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Array/Byte/index.html b/dev/containers-data/CCRingBuffer/Array/Byte/index.html new file mode 100644 index 00000000..267747ea --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Array/Byte/index.html @@ -0,0 +1,2 @@ + +Byte (containers-data.CCRingBuffer.Array.Byte)

Module Array.Byte

Efficient array version for the char type

type elt = char

The element type

type t = Stdlib.Bytes.t

The type of an array instance

val dummy : elt

A dummy element used for empty slots in the array

  • since 2.4
val create : int -> t

Make an array of the given size, filled with dummy elements.

val length : t -> int

length t gets the total number of elements currently in t.

val get : t -> int -> elt

get t i gets the element at position i.

val set : t -> int -> elt -> unit

set t i e sets the element at position i to e.

val sub : t -> int -> int -> t

sub t i len gets the sub-array of t from position i to i + len.

val copy : t -> t

copy t makes a fresh copy of the array t.

val blit : t -> int -> t -> int -> int -> unit

blit t s arr i len copies len elements from arr starting at i to position s from t.

val iter : ( elt -> unit ) -> t -> unit

iter f t iterates over the array t invoking f with the current element, in array order.

\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Array/Make/argument-1-Elt/index.html b/dev/containers-data/CCRingBuffer/Array/Make/argument-1-Elt/index.html new file mode 100644 index 00000000..ee038525 --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Array/Make/argument-1-Elt/index.html @@ -0,0 +1,2 @@ + +Elt (containers-data.CCRingBuffer.Array.Make.1-Elt)

Parameter Make.1-Elt

type t
val dummy : t
\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Array/Make/index.html b/dev/containers-data/CCRingBuffer/Array/Make/index.html new file mode 100644 index 00000000..1099acb4 --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Array/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCRingBuffer.Array.Make)

Module Array.Make

Makes an array given an arbitrary element type

Parameters

module Elt : sig ... end

Signature

type elt = Elt.t

The element type

type t = Elt.t array

The type of an array instance

val dummy : elt

A dummy element used for empty slots in the array

  • since 2.4
val create : int -> t

Make an array of the given size, filled with dummy elements.

val length : t -> int

length t gets the total number of elements currently in t.

val get : t -> int -> elt

get t i gets the element at position i.

val set : t -> int -> elt -> unit

set t i e sets the element at position i to e.

val sub : t -> int -> int -> t

sub t i len gets the sub-array of t from position i to i + len.

val copy : t -> t

copy t makes a fresh copy of the array t.

val blit : t -> int -> t -> int -> int -> unit

blit t s arr i len copies len elements from arr starting at i to position s from t.

val iter : ( elt -> unit ) -> t -> unit

iter f t iterates over the array t invoking f with the current element, in array order.

\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Array/index.html b/dev/containers-data/CCRingBuffer/Array/index.html new file mode 100644 index 00000000..0450116b --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Array/index.html @@ -0,0 +1,4 @@ + +Array (containers-data.CCRingBuffer.Array)

Module CCRingBuffer.Array

The abstract type for arrays

module type S = sig ... end
module Byte : S with type elt = char and type t = Stdlib.Bytes.t

Efficient array version for the char type

module Make + (Elt : sig ... end) : + S with type elt = Elt.t and type t = Elt.t array

Makes an array given an arbitrary element type

\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Array/module-type-S/index.html b/dev/containers-data/CCRingBuffer/Array/module-type-S/index.html new file mode 100644 index 00000000..7fca6df8 --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Array/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCRingBuffer.Array.S)

Module type Array.S

type elt

The element type

type t

The type of an array instance

val dummy : elt

A dummy element used for empty slots in the array

  • since 2.4
val create : int -> t

Make an array of the given size, filled with dummy elements.

val length : t -> int

length t gets the total number of elements currently in t.

val get : t -> int -> elt

get t i gets the element at position i.

val set : t -> int -> elt -> unit

set t i e sets the element at position i to e.

val sub : t -> int -> int -> t

sub t i len gets the sub-array of t from position i to i + len.

val copy : t -> t

copy t makes a fresh copy of the array t.

val blit : t -> int -> t -> int -> int -> unit

blit t s arr i len copies len elements from arr starting at i to position s from t.

val iter : ( elt -> unit ) -> t -> unit

iter f t iterates over the array t invoking f with the current element, in array order.

\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Byte/index.html b/dev/containers-data/CCRingBuffer/Byte/index.html new file mode 100644 index 00000000..a630e9cc --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Byte/index.html @@ -0,0 +1,2 @@ + +Byte (containers-data.CCRingBuffer.Byte)

Module CCRingBuffer.Byte

An efficient byte based ring buffer

module Array = Array.Byte

The module type of Array for this ring buffer

type t

Defines the bounded ring buffer type

exception Empty

Raised in querying functions when the buffer is empty

val create : int -> t

create size creates a new bounded buffer with given size. The underlying array is allocated immediately and no further (large) allocation will happen from now on.

  • raises Invalid_argument

    if the argument is < 1.

val copy : t -> t

Make a fresh copy of the buffer.

val capacity : t -> int

Length of the inner buffer.

val length : t -> int

Number of elements currently stored in the buffer.

val is_full : t -> bool

true if pushing an element would erase another element.

  • since 1.3
val blit_from : t -> Array.t -> int -> int -> unit

blit_from buf from_buf o len copies the slice o, ... o + len - 1 from an input buffer from_buf to the end of the buffer. If the slice is too large for the buffer, only the last part of the array will be copied.

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val blit_into : t -> Array.t -> int -> int -> int

blit_into buf to_buf o len copies at most len elements from buf into to_buf starting at offset o in s.

  • returns

    the number of elements actually copied (min len (length buf)).

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val append : t -> into:t -> unit

append b ~into copies all data from b and adds it at the end of into. Erases data of into if there is not enough room.

val to_list : t -> Array.elt list

Extract the current content into a list.

val clear : t -> unit

Clear the content of the buffer

val is_empty : t -> bool

Is the buffer empty (i.e. contains no elements)?

val junk_front : t -> unit

Drop the front element from t.

  • raises Empty

    if the buffer is already empty.

val junk_back : t -> unit

Drop the back element from t.

  • raises Empty

    if the buffer is already empty.

val skip : t -> int -> unit

skip b len removes len elements from the front of b.

  • raises Invalid_argument

    if len > length b.

val iter : t -> f:( Array.elt -> unit ) -> unit

iter b ~f calls f i t for each element t in buf.

val iteri : t -> f:( int -> Array.elt -> unit ) -> unit

iteri b ~f calls f i t for each element t in buf, with i being its relative index within buf.

val get_front : t -> int -> Array.elt

get_front buf i returns the i-th element of buf from the front, i.e. the one returned by take_front buf after i-1 calls to junk_front buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val get_back : t -> int -> Array.elt

get_back buf i returns the i-th element of buf from the back, i.e. the one returned by take_back buf after i-1 calls to junk_back buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val push_back : t -> Array.elt -> unit

Push value at the back of t. If t.bounded=false, the buffer will grow as needed, otherwise the oldest elements are replaced first.

val peek_front : t -> Array.elt option

First value from front of t, without modification.

val peek_front_exn : t -> Array.elt

First value from front of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val peek_back : t -> Array.elt option

Get the last value from back of t, without modification.

val peek_back_exn : t -> Array.elt

Get the last value from back of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val take_back : t -> Array.elt option

Take and remove the last value from back of t, if any.

val take_back_exn : t -> Array.elt

Take and remove the last value from back of t.

  • raises Empty

    if buffer is already empty.

val take_front : t -> Array.elt option

Take and remove the first value from front of t, if any.

val take_front_exn : t -> Array.elt

Take and remove the first value from front of t.

  • raises Empty

    if buffer is already empty.

val of_array : Array.t -> t

Create a buffer from an initial array, but doesn't take ownership of it (still allocates a new internal array).

  • since 0.11
val to_array : t -> Array.t

Create an array from the elements, in order.

  • since 0.11
\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Make/Array/index.html b/dev/containers-data/CCRingBuffer/Make/Array/index.html new file mode 100644 index 00000000..39f66c9c --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Make/Array/index.html @@ -0,0 +1,2 @@ + +Array (containers-data.CCRingBuffer.Make.Array)

Module Make.Array

The module type of Array for this ring buffer

type elt = X.t

The element type

type t = X.t array

The type of an array instance

val dummy : elt

A dummy element used for empty slots in the array

  • since 2.4
val create : int -> t

Make an array of the given size, filled with dummy elements.

val length : t -> int

length t gets the total number of elements currently in t.

val get : t -> int -> elt

get t i gets the element at position i.

val set : t -> int -> elt -> unit

set t i e sets the element at position i to e.

val sub : t -> int -> int -> t

sub t i len gets the sub-array of t from position i to i + len.

val copy : t -> t

copy t makes a fresh copy of the array t.

val blit : t -> int -> t -> int -> int -> unit

blit t s arr i len copies len elements from arr starting at i to position s from t.

val iter : ( elt -> unit ) -> t -> unit

iter f t iterates over the array t invoking f with the current element, in array order.

\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Make/argument-1-X/index.html b/dev/containers-data/CCRingBuffer/Make/argument-1-X/index.html new file mode 100644 index 00000000..334d8feb --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Make/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers-data.CCRingBuffer.Make.1-X)

Parameter Make.1-X

type t
val dummy : t
\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/Make/index.html b/dev/containers-data/CCRingBuffer/Make/index.html new file mode 100644 index 00000000..a7422f4a --- /dev/null +++ b/dev/containers-data/CCRingBuffer/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCRingBuffer.Make)

Module CCRingBuffer.Make

Buffer using regular arrays

Parameters

module X : sig ... end

Signature

module Array : Array.S with type elt = X.t with type t = X.t array

The module type of Array for this ring buffer

type t

Defines the bounded ring buffer type

exception Empty

Raised in querying functions when the buffer is empty

val create : int -> t

create size creates a new bounded buffer with given size. The underlying array is allocated immediately and no further (large) allocation will happen from now on.

  • raises Invalid_argument

    if the argument is < 1.

val copy : t -> t

Make a fresh copy of the buffer.

val capacity : t -> int

Length of the inner buffer.

val length : t -> int

Number of elements currently stored in the buffer.

val is_full : t -> bool

true if pushing an element would erase another element.

  • since 1.3
val blit_from : t -> Array.t -> int -> int -> unit

blit_from buf from_buf o len copies the slice o, ... o + len - 1 from an input buffer from_buf to the end of the buffer. If the slice is too large for the buffer, only the last part of the array will be copied.

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val blit_into : t -> Array.t -> int -> int -> int

blit_into buf to_buf o len copies at most len elements from buf into to_buf starting at offset o in s.

  • returns

    the number of elements actually copied (min len (length buf)).

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val append : t -> into:t -> unit

append b ~into copies all data from b and adds it at the end of into. Erases data of into if there is not enough room.

val to_list : t -> Array.elt list

Extract the current content into a list.

val clear : t -> unit

Clear the content of the buffer

val is_empty : t -> bool

Is the buffer empty (i.e. contains no elements)?

val junk_front : t -> unit

Drop the front element from t.

  • raises Empty

    if the buffer is already empty.

val junk_back : t -> unit

Drop the back element from t.

  • raises Empty

    if the buffer is already empty.

val skip : t -> int -> unit

skip b len removes len elements from the front of b.

  • raises Invalid_argument

    if len > length b.

val iter : t -> f:( Array.elt -> unit ) -> unit

iter b ~f calls f i t for each element t in buf.

val iteri : t -> f:( int -> Array.elt -> unit ) -> unit

iteri b ~f calls f i t for each element t in buf, with i being its relative index within buf.

val get_front : t -> int -> Array.elt

get_front buf i returns the i-th element of buf from the front, i.e. the one returned by take_front buf after i-1 calls to junk_front buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val get_back : t -> int -> Array.elt

get_back buf i returns the i-th element of buf from the back, i.e. the one returned by take_back buf after i-1 calls to junk_back buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val push_back : t -> Array.elt -> unit

Push value at the back of t. If t.bounded=false, the buffer will grow as needed, otherwise the oldest elements are replaced first.

val peek_front : t -> Array.elt option

First value from front of t, without modification.

val peek_front_exn : t -> Array.elt

First value from front of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val peek_back : t -> Array.elt option

Get the last value from back of t, without modification.

val peek_back_exn : t -> Array.elt

Get the last value from back of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val take_back : t -> Array.elt option

Take and remove the last value from back of t, if any.

val take_back_exn : t -> Array.elt

Take and remove the last value from back of t.

  • raises Empty

    if buffer is already empty.

val take_front : t -> Array.elt option

Take and remove the first value from front of t, if any.

val take_front_exn : t -> Array.elt

Take and remove the first value from front of t.

  • raises Empty

    if buffer is already empty.

val of_array : Array.t -> t

Create a buffer from an initial array, but doesn't take ownership of it (still allocates a new internal array).

  • since 0.11
val to_array : t -> Array.t

Create an array from the elements, in order.

  • since 0.11
\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/MakeFromArray/argument-1-A/index.html b/dev/containers-data/CCRingBuffer/MakeFromArray/argument-1-A/index.html new file mode 100644 index 00000000..21f036fe --- /dev/null +++ b/dev/containers-data/CCRingBuffer/MakeFromArray/argument-1-A/index.html @@ -0,0 +1,2 @@ + +A (containers-data.CCRingBuffer.MakeFromArray.1-A)

Parameter MakeFromArray.1-A

type elt

The element type

type t

The type of an array instance

val dummy : elt

A dummy element used for empty slots in the array

  • since 2.4
val create : int -> t

Make an array of the given size, filled with dummy elements.

val length : t -> int

length t gets the total number of elements currently in t.

val get : t -> int -> elt

get t i gets the element at position i.

val set : t -> int -> elt -> unit

set t i e sets the element at position i to e.

val sub : t -> int -> int -> t

sub t i len gets the sub-array of t from position i to i + len.

val copy : t -> t

copy t makes a fresh copy of the array t.

val blit : t -> int -> t -> int -> int -> unit

blit t s arr i len copies len elements from arr starting at i to position s from t.

val iter : ( elt -> unit ) -> t -> unit

iter f t iterates over the array t invoking f with the current element, in array order.

\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/MakeFromArray/index.html b/dev/containers-data/CCRingBuffer/MakeFromArray/index.html new file mode 100644 index 00000000..c3fe5605 --- /dev/null +++ b/dev/containers-data/CCRingBuffer/MakeFromArray/index.html @@ -0,0 +1,2 @@ + +MakeFromArray (containers-data.CCRingBuffer.MakeFromArray)

Module CCRingBuffer.MakeFromArray

Makes a ring buffer module with the given array type

Parameters

module A : Array.S

Signature

module Array = A

The module type of Array for this ring buffer

type t

Defines the bounded ring buffer type

exception Empty

Raised in querying functions when the buffer is empty

val create : int -> t

create size creates a new bounded buffer with given size. The underlying array is allocated immediately and no further (large) allocation will happen from now on.

  • raises Invalid_argument

    if the argument is < 1.

val copy : t -> t

Make a fresh copy of the buffer.

val capacity : t -> int

Length of the inner buffer.

val length : t -> int

Number of elements currently stored in the buffer.

val is_full : t -> bool

true if pushing an element would erase another element.

  • since 1.3
val blit_from : t -> Array.t -> int -> int -> unit

blit_from buf from_buf o len copies the slice o, ... o + len - 1 from an input buffer from_buf to the end of the buffer. If the slice is too large for the buffer, only the last part of the array will be copied.

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val blit_into : t -> Array.t -> int -> int -> int

blit_into buf to_buf o len copies at most len elements from buf into to_buf starting at offset o in s.

  • returns

    the number of elements actually copied (min len (length buf)).

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val append : t -> into:t -> unit

append b ~into copies all data from b and adds it at the end of into. Erases data of into if there is not enough room.

val to_list : t -> Array.elt list

Extract the current content into a list.

val clear : t -> unit

Clear the content of the buffer

val is_empty : t -> bool

Is the buffer empty (i.e. contains no elements)?

val junk_front : t -> unit

Drop the front element from t.

  • raises Empty

    if the buffer is already empty.

val junk_back : t -> unit

Drop the back element from t.

  • raises Empty

    if the buffer is already empty.

val skip : t -> int -> unit

skip b len removes len elements from the front of b.

  • raises Invalid_argument

    if len > length b.

val iter : t -> f:( Array.elt -> unit ) -> unit

iter b ~f calls f i t for each element t in buf.

val iteri : t -> f:( int -> Array.elt -> unit ) -> unit

iteri b ~f calls f i t for each element t in buf, with i being its relative index within buf.

val get_front : t -> int -> Array.elt

get_front buf i returns the i-th element of buf from the front, i.e. the one returned by take_front buf after i-1 calls to junk_front buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val get_back : t -> int -> Array.elt

get_back buf i returns the i-th element of buf from the back, i.e. the one returned by take_back buf after i-1 calls to junk_back buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val push_back : t -> Array.elt -> unit

Push value at the back of t. If t.bounded=false, the buffer will grow as needed, otherwise the oldest elements are replaced first.

val peek_front : t -> Array.elt option

First value from front of t, without modification.

val peek_front_exn : t -> Array.elt

First value from front of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val peek_back : t -> Array.elt option

Get the last value from back of t, without modification.

val peek_back_exn : t -> Array.elt

Get the last value from back of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val take_back : t -> Array.elt option

Take and remove the last value from back of t, if any.

val take_back_exn : t -> Array.elt

Take and remove the last value from back of t.

  • raises Empty

    if buffer is already empty.

val take_front : t -> Array.elt option

Take and remove the first value from front of t, if any.

val take_front_exn : t -> Array.elt

Take and remove the first value from front of t.

  • raises Empty

    if buffer is already empty.

val of_array : Array.t -> t

Create a buffer from an initial array, but doesn't take ownership of it (still allocates a new internal array).

  • since 0.11
val to_array : t -> Array.t

Create an array from the elements, in order.

  • since 0.11
\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/module-type-S/Array/index.html b/dev/containers-data/CCRingBuffer/module-type-S/Array/index.html new file mode 100644 index 00000000..3c9c8a08 --- /dev/null +++ b/dev/containers-data/CCRingBuffer/module-type-S/Array/index.html @@ -0,0 +1,2 @@ + +Array (containers-data.CCRingBuffer.S.Array)

Module S.Array

The module type of Array for this ring buffer

type elt

The element type

type t

The type of an array instance

val dummy : elt

A dummy element used for empty slots in the array

  • since 2.4
val create : int -> t

Make an array of the given size, filled with dummy elements.

val length : t -> int

length t gets the total number of elements currently in t.

val get : t -> int -> elt

get t i gets the element at position i.

val set : t -> int -> elt -> unit

set t i e sets the element at position i to e.

val sub : t -> int -> int -> t

sub t i len gets the sub-array of t from position i to i + len.

val copy : t -> t

copy t makes a fresh copy of the array t.

val blit : t -> int -> t -> int -> int -> unit

blit t s arr i len copies len elements from arr starting at i to position s from t.

val iter : ( elt -> unit ) -> t -> unit

iter f t iterates over the array t invoking f with the current element, in array order.

\ No newline at end of file diff --git a/dev/containers-data/CCRingBuffer/module-type-S/index.html b/dev/containers-data/CCRingBuffer/module-type-S/index.html new file mode 100644 index 00000000..5161039e --- /dev/null +++ b/dev/containers-data/CCRingBuffer/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCRingBuffer.S)

Module type CCRingBuffer.S

Ring Buffer

The abstract ring buffer type, made concrete by choice of ARRAY module implementation

module Array : Array.S

The module type of Array for this ring buffer

type t

Defines the bounded ring buffer type

exception Empty

Raised in querying functions when the buffer is empty

val create : int -> t

create size creates a new bounded buffer with given size. The underlying array is allocated immediately and no further (large) allocation will happen from now on.

  • raises Invalid_argument

    if the argument is < 1.

val copy : t -> t

Make a fresh copy of the buffer.

val capacity : t -> int

Length of the inner buffer.

val length : t -> int

Number of elements currently stored in the buffer.

val is_full : t -> bool

true if pushing an element would erase another element.

  • since 1.3
val blit_from : t -> Array.t -> int -> int -> unit

blit_from buf from_buf o len copies the slice o, ... o + len - 1 from an input buffer from_buf to the end of the buffer. If the slice is too large for the buffer, only the last part of the array will be copied.

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val blit_into : t -> Array.t -> int -> int -> int

blit_into buf to_buf o len copies at most len elements from buf into to_buf starting at offset o in s.

  • returns

    the number of elements actually copied (min len (length buf)).

  • raises Invalid_argument

    if o,len is not a valid slice of s.

val append : t -> into:t -> unit

append b ~into copies all data from b and adds it at the end of into. Erases data of into if there is not enough room.

val to_list : t -> Array.elt list

Extract the current content into a list.

val clear : t -> unit

Clear the content of the buffer

val is_empty : t -> bool

Is the buffer empty (i.e. contains no elements)?

val junk_front : t -> unit

Drop the front element from t.

  • raises Empty

    if the buffer is already empty.

val junk_back : t -> unit

Drop the back element from t.

  • raises Empty

    if the buffer is already empty.

val skip : t -> int -> unit

skip b len removes len elements from the front of b.

  • raises Invalid_argument

    if len > length b.

val iter : t -> f:( Array.elt -> unit ) -> unit

iter b ~f calls f i t for each element t in buf.

val iteri : t -> f:( int -> Array.elt -> unit ) -> unit

iteri b ~f calls f i t for each element t in buf, with i being its relative index within buf.

val get_front : t -> int -> Array.elt

get_front buf i returns the i-th element of buf from the front, i.e. the one returned by take_front buf after i-1 calls to junk_front buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val get_back : t -> int -> Array.elt

get_back buf i returns the i-th element of buf from the back, i.e. the one returned by take_back buf after i-1 calls to junk_back buf.

  • raises Invalid_argument

    if the index is invalid (> length buf).

val push_back : t -> Array.elt -> unit

Push value at the back of t. If t.bounded=false, the buffer will grow as needed, otherwise the oldest elements are replaced first.

val peek_front : t -> Array.elt option

First value from front of t, without modification.

val peek_front_exn : t -> Array.elt

First value from front of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val peek_back : t -> Array.elt option

Get the last value from back of t, without modification.

val peek_back_exn : t -> Array.elt

Get the last value from back of t, without modification.

  • raises Empty

    if buffer is empty.

  • since 1.3
val take_back : t -> Array.elt option

Take and remove the last value from back of t, if any.

val take_back_exn : t -> Array.elt

Take and remove the last value from back of t.

  • raises Empty

    if buffer is already empty.

val take_front : t -> Array.elt option

Take and remove the first value from front of t, if any.

val take_front_exn : t -> Array.elt

Take and remove the first value from front of t.

  • raises Empty

    if buffer is already empty.

val of_array : Array.t -> t

Create a buffer from an initial array, but doesn't take ownership of it (still allocates a new internal array).

  • since 0.11
val to_array : t -> Array.t

Create an array from the elements, in order.

  • since 0.11
\ No newline at end of file diff --git a/dev/containers-data/CCSimple_queue/Infix/index.html b/dev/containers-data/CCSimple_queue/Infix/index.html new file mode 100644 index 00000000..45e8bb46 --- /dev/null +++ b/dev/containers-data/CCSimple_queue/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers-data.CCSimple_queue.Infix)

Module CCSimple_queue.Infix

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

Alias to map.

val (@) : 'a t -> 'a t -> 'a t

Alias to append.

val (<::) : 'a t -> 'a -> 'a t

Alias to snoc.

\ No newline at end of file diff --git a/dev/containers-data/CCTrie/Make/argument-1-W/index.html b/dev/containers-data/CCTrie/Make/argument-1-W/index.html new file mode 100644 index 00000000..582f7acc --- /dev/null +++ b/dev/containers-data/CCTrie/Make/argument-1-W/index.html @@ -0,0 +1,2 @@ + +W (containers-data.CCTrie.Make.1-W)

Parameter Make.1-W

type t
type char_
val compare : char_ -> char_ -> int
val to_iter : t -> char_ iter
val of_list : char_ list -> t
\ No newline at end of file diff --git a/dev/containers-data/CCTrie/Make/index.html b/dev/containers-data/CCTrie/Make/index.html new file mode 100644 index 00000000..1bf24721 --- /dev/null +++ b/dev/containers-data/CCTrie/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-data.CCTrie.Make)

Module CCTrie.Make

Parameters

module W : WORD

Signature

type char_ = W.char_
type key = W.t
type 'a t
val empty : 'a t
val is_empty : _ t -> bool
val add : key -> 'a -> 'a t -> 'a t

Add a binding to the trie (possibly erasing the previous one).

val remove : key -> 'a t -> 'a t

Remove the key, if present.

val find : key -> 'a t -> 'a option

Find the value associated with the key, if any.

val find_exn : key -> 'a t -> 'a

Same as find but can fail.

  • raises Not_found

    if the key is not present.

val longest_prefix : key -> 'a t -> key

longest_prefix k m finds the longest prefix of k that leads to at least one path in m (it does not mean that the prefix is bound to a value.

Example: if m has keys "abc0" and "abcd", then longest_prefix "abc2" m will return "abc".

  • since 0.17
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

Update the binding for the given key. The function is given None if the key is absent, or Some v if key is bound to v; if it returns None the key is removed, otherwise it returns Some y and key becomes bound to y.

val fold : ( 'b -> key -> 'a -> 'b ) -> 'b -> 'a t -> 'b

Fold on key/value bindings. Will use WORD.of_list to rebuild keys.

val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : ( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : ( key -> 'a -> unit ) -> 'a t -> unit

Same as fold, but for effectful functions.

val fold_values : ( 'b -> 'a -> 'b ) -> 'b -> 'a t -> 'b

More efficient version of fold, that doesn't keep keys.

val iter_values : ( 'a -> unit ) -> 'a t -> unit
val merge : ( 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t

Merge two tries together. The function is used in case of conflicts, when a key belongs to both tries.

val size : _ t -> int

Number of bindings.

Conversions
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val of_iter : (key * 'a) iter -> 'a t
val to_iter_values : 'a t -> 'a iter
val to_tree : 'a t -> [ `Char of char_ | `Val of 'a | `Switch ] ktree
Ranges
val above : key -> 'a t -> (key * 'a) iter

All bindings whose key is bigger or equal to the given key, in ascending order.

val below : key -> 'a t -> (key * 'a) iter

All bindings whose key is smaller or equal to the given key, in decreasing order.

\ No newline at end of file diff --git a/dev/containers-data/CCTrie/MakeArray/argument-1-X/index.html b/dev/containers-data/CCTrie/MakeArray/argument-1-X/index.html new file mode 100644 index 00000000..0991dd66 --- /dev/null +++ b/dev/containers-data/CCTrie/MakeArray/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers-data.CCTrie.MakeArray.1-X)

Parameter MakeArray.1-X

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCTrie/MakeArray/index.html b/dev/containers-data/CCTrie/MakeArray/index.html new file mode 100644 index 00000000..0f61c779 --- /dev/null +++ b/dev/containers-data/CCTrie/MakeArray/index.html @@ -0,0 +1,2 @@ + +MakeArray (containers-data.CCTrie.MakeArray)

Module CCTrie.MakeArray

Parameters

module X : ORDERED

Signature

type char_ = X.t
type key = X.t array
type 'a t
val empty : 'a t
val is_empty : _ t -> bool
val add : key -> 'a -> 'a t -> 'a t

Add a binding to the trie (possibly erasing the previous one).

val remove : key -> 'a t -> 'a t

Remove the key, if present.

val find : key -> 'a t -> 'a option

Find the value associated with the key, if any.

val find_exn : key -> 'a t -> 'a

Same as find but can fail.

  • raises Not_found

    if the key is not present.

val longest_prefix : key -> 'a t -> key

longest_prefix k m finds the longest prefix of k that leads to at least one path in m (it does not mean that the prefix is bound to a value.

Example: if m has keys "abc0" and "abcd", then longest_prefix "abc2" m will return "abc".

  • since 0.17
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

Update the binding for the given key. The function is given None if the key is absent, or Some v if key is bound to v; if it returns None the key is removed, otherwise it returns Some y and key becomes bound to y.

val fold : ( 'b -> key -> 'a -> 'b ) -> 'b -> 'a t -> 'b

Fold on key/value bindings. Will use WORD.of_list to rebuild keys.

val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : ( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : ( key -> 'a -> unit ) -> 'a t -> unit

Same as fold, but for effectful functions.

val fold_values : ( 'b -> 'a -> 'b ) -> 'b -> 'a t -> 'b

More efficient version of fold, that doesn't keep keys.

val iter_values : ( 'a -> unit ) -> 'a t -> unit
val merge : ( 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t

Merge two tries together. The function is used in case of conflicts, when a key belongs to both tries.

val size : _ t -> int

Number of bindings.

Conversions
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val of_iter : (key * 'a) iter -> 'a t
val to_iter_values : 'a t -> 'a iter
val to_tree : 'a t -> [ `Char of char_ | `Val of 'a | `Switch ] ktree
Ranges
val above : key -> 'a t -> (key * 'a) iter

All bindings whose key is bigger or equal to the given key, in ascending order.

val below : key -> 'a t -> (key * 'a) iter

All bindings whose key is smaller or equal to the given key, in decreasing order.

\ No newline at end of file diff --git a/dev/containers-data/CCTrie/MakeList/argument-1-X/index.html b/dev/containers-data/CCTrie/MakeList/argument-1-X/index.html new file mode 100644 index 00000000..aaf6b47a --- /dev/null +++ b/dev/containers-data/CCTrie/MakeList/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers-data.CCTrie.MakeList.1-X)

Parameter MakeList.1-X

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCTrie/MakeList/index.html b/dev/containers-data/CCTrie/MakeList/index.html new file mode 100644 index 00000000..fd538657 --- /dev/null +++ b/dev/containers-data/CCTrie/MakeList/index.html @@ -0,0 +1,2 @@ + +MakeList (containers-data.CCTrie.MakeList)

Module CCTrie.MakeList

Parameters

module X : ORDERED

Signature

type char_ = X.t
type key = X.t list
type 'a t
val empty : 'a t
val is_empty : _ t -> bool
val add : key -> 'a -> 'a t -> 'a t

Add a binding to the trie (possibly erasing the previous one).

val remove : key -> 'a t -> 'a t

Remove the key, if present.

val find : key -> 'a t -> 'a option

Find the value associated with the key, if any.

val find_exn : key -> 'a t -> 'a

Same as find but can fail.

  • raises Not_found

    if the key is not present.

val longest_prefix : key -> 'a t -> key

longest_prefix k m finds the longest prefix of k that leads to at least one path in m (it does not mean that the prefix is bound to a value.

Example: if m has keys "abc0" and "abcd", then longest_prefix "abc2" m will return "abc".

  • since 0.17
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

Update the binding for the given key. The function is given None if the key is absent, or Some v if key is bound to v; if it returns None the key is removed, otherwise it returns Some y and key becomes bound to y.

val fold : ( 'b -> key -> 'a -> 'b ) -> 'b -> 'a t -> 'b

Fold on key/value bindings. Will use WORD.of_list to rebuild keys.

val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : ( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : ( key -> 'a -> unit ) -> 'a t -> unit

Same as fold, but for effectful functions.

val fold_values : ( 'b -> 'a -> 'b ) -> 'b -> 'a t -> 'b

More efficient version of fold, that doesn't keep keys.

val iter_values : ( 'a -> unit ) -> 'a t -> unit
val merge : ( 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t

Merge two tries together. The function is used in case of conflicts, when a key belongs to both tries.

val size : _ t -> int

Number of bindings.

Conversions
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val of_iter : (key * 'a) iter -> 'a t
val to_iter_values : 'a t -> 'a iter
val to_tree : 'a t -> [ `Char of char_ | `Val of 'a | `Switch ] ktree
Ranges
val above : key -> 'a t -> (key * 'a) iter

All bindings whose key is bigger or equal to the given key, in ascending order.

val below : key -> 'a t -> (key * 'a) iter

All bindings whose key is smaller or equal to the given key, in decreasing order.

\ No newline at end of file diff --git a/dev/containers-data/CCTrie/String/index.html b/dev/containers-data/CCTrie/String/index.html new file mode 100644 index 00000000..e2e611b5 --- /dev/null +++ b/dev/containers-data/CCTrie/String/index.html @@ -0,0 +1,2 @@ + +String (containers-data.CCTrie.String)

Module CCTrie.String

type char_ = char
type key = string
type 'a t
val empty : 'a t
val is_empty : _ t -> bool
val add : key -> 'a -> 'a t -> 'a t

Add a binding to the trie (possibly erasing the previous one).

val remove : key -> 'a t -> 'a t

Remove the key, if present.

val find : key -> 'a t -> 'a option

Find the value associated with the key, if any.

val find_exn : key -> 'a t -> 'a

Same as find but can fail.

  • raises Not_found

    if the key is not present.

val longest_prefix : key -> 'a t -> key

longest_prefix k m finds the longest prefix of k that leads to at least one path in m (it does not mean that the prefix is bound to a value.

Example: if m has keys "abc0" and "abcd", then longest_prefix "abc2" m will return "abc".

  • since 0.17
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

Update the binding for the given key. The function is given None if the key is absent, or Some v if key is bound to v; if it returns None the key is removed, otherwise it returns Some y and key becomes bound to y.

val fold : ( 'b -> key -> 'a -> 'b ) -> 'b -> 'a t -> 'b

Fold on key/value bindings. Will use WORD.of_list to rebuild keys.

val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : ( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : ( key -> 'a -> unit ) -> 'a t -> unit

Same as fold, but for effectful functions.

val fold_values : ( 'b -> 'a -> 'b ) -> 'b -> 'a t -> 'b

More efficient version of fold, that doesn't keep keys.

val iter_values : ( 'a -> unit ) -> 'a t -> unit
val merge : ( 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t

Merge two tries together. The function is used in case of conflicts, when a key belongs to both tries.

val size : _ t -> int

Number of bindings.

Conversions
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val of_iter : (key * 'a) iter -> 'a t
val to_iter_values : 'a t -> 'a iter
val to_tree : 'a t -> [ `Char of char_ | `Val of 'a | `Switch ] ktree
Ranges
val above : key -> 'a t -> (key * 'a) iter

All bindings whose key is bigger or equal to the given key, in ascending order.

val below : key -> 'a t -> (key * 'a) iter

All bindings whose key is smaller or equal to the given key, in decreasing order.

\ No newline at end of file diff --git a/dev/containers-data/CCTrie/module-type-ORDERED/index.html b/dev/containers-data/CCTrie/module-type-ORDERED/index.html new file mode 100644 index 00000000..748ce098 --- /dev/null +++ b/dev/containers-data/CCTrie/module-type-ORDERED/index.html @@ -0,0 +1,2 @@ + +ORDERED (containers-data.CCTrie.ORDERED)

Module type CCTrie.ORDERED

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCTrie/module-type-S/index.html b/dev/containers-data/CCTrie/module-type-S/index.html new file mode 100644 index 00000000..c68de924 --- /dev/null +++ b/dev/containers-data/CCTrie/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers-data.CCTrie.S)

Module type CCTrie.S

type char_
type key
type 'a t
val empty : 'a t
val is_empty : _ t -> bool
val add : key -> 'a -> 'a t -> 'a t

Add a binding to the trie (possibly erasing the previous one).

val remove : key -> 'a t -> 'a t

Remove the key, if present.

val find : key -> 'a t -> 'a option

Find the value associated with the key, if any.

val find_exn : key -> 'a t -> 'a

Same as find but can fail.

  • raises Not_found

    if the key is not present.

val longest_prefix : key -> 'a t -> key

longest_prefix k m finds the longest prefix of k that leads to at least one path in m (it does not mean that the prefix is bound to a value.

Example: if m has keys "abc0" and "abcd", then longest_prefix "abc2" m will return "abc".

  • since 0.17
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

Update the binding for the given key. The function is given None if the key is absent, or Some v if key is bound to v; if it returns None the key is removed, otherwise it returns Some y and key becomes bound to y.

val fold : ( 'b -> key -> 'a -> 'b ) -> 'b -> 'a t -> 'b

Fold on key/value bindings. Will use WORD.of_list to rebuild keys.

val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : ( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : ( key -> 'a -> unit ) -> 'a t -> unit

Same as fold, but for effectful functions.

val fold_values : ( 'b -> 'a -> 'b ) -> 'b -> 'a t -> 'b

More efficient version of fold, that doesn't keep keys.

val iter_values : ( 'a -> unit ) -> 'a t -> unit
val merge : ( 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t

Merge two tries together. The function is used in case of conflicts, when a key belongs to both tries.

val size : _ t -> int

Number of bindings.

Conversions
val to_list : 'a t -> (key * 'a) list
val of_list : (key * 'a) list -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val of_iter : (key * 'a) iter -> 'a t
val to_iter_values : 'a t -> 'a iter
val to_tree : 'a t -> [ `Char of char_ | `Val of 'a | `Switch ] ktree
Ranges
val above : key -> 'a t -> (key * 'a) iter

All bindings whose key is bigger or equal to the given key, in ascending order.

val below : key -> 'a t -> (key * 'a) iter

All bindings whose key is smaller or equal to the given key, in decreasing order.

\ No newline at end of file diff --git a/dev/containers-data/CCTrie/module-type-WORD/index.html b/dev/containers-data/CCTrie/module-type-WORD/index.html new file mode 100644 index 00000000..bd8d3d12 --- /dev/null +++ b/dev/containers-data/CCTrie/module-type-WORD/index.html @@ -0,0 +1,2 @@ + +WORD (containers-data.CCTrie.WORD)

Module type CCTrie.WORD

type t
type char_
val compare : char_ -> char_ -> int
val to_iter : t -> char_ iter
val of_list : char_ list -> t
\ No newline at end of file diff --git a/dev/containers-data/CCWBTree/Make/argument-1-X/index.html b/dev/containers-data/CCWBTree/Make/argument-1-X/index.html new file mode 100644 index 00000000..9dea930d --- /dev/null +++ b/dev/containers-data/CCWBTree/Make/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers-data.CCWBTree.Make.1-X)

Parameter Make.1-X

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCWBTree/Make/index.html b/dev/containers-data/CCWBTree/Make/index.html new file mode 100644 index 00000000..3ec0c8f9 --- /dev/null +++ b/dev/containers-data/CCWBTree/Make/index.html @@ -0,0 +1,13 @@ + +Make (containers-data.CCWBTree.Make)

Module CCWBTree.Make

Parameters

module X : ORD

Signature

type key = X.t
type +'a t
val empty : 'a t
val is_empty : _ t -> bool
val singleton : key -> 'a -> 'a t
val mem : key -> _ t -> bool
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
  • raises Not_found

    if the key is not present.

val nth : int -> 'a t -> (key * 'a) option

nth i m returns the i-th key, value in the ascending order. Complexity is O(log (cardinal m)).

val nth_exn : int -> 'a t -> key * 'a
  • raises Not_found

    if the index is invalid.

val get_rank : key -> 'a t -> [ `At of int | `After of int | `First ]

get_rank k m looks for the rank of k in m, i.e. the index of k in the sorted list of bindings of m. let (`At n) = get_rank k m in nth_exn n m = get m k should hold.

  • since 1.4
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

update k f m calls f (Some v) if get k m = Some v, f None otherwise. Then, if f returns Some v' it binds k to v', if f returns None it removes k.

val cardinal : _ t -> int
val weight : _ t -> int
val fold : f:( 'b -> key -> 'a -> 'b ) -> x:'b -> 'a t -> 'b
val mapi : f:( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : f:( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : f:( key -> 'a -> unit ) -> 'a t -> unit
val split : key -> 'a t -> 'a t * 'a option * 'a t

split k t returns l, o, r where l is the part of the map with keys smaller than k, r has keys bigger than k, and o = Some v if k, v belonged to the map.

val merge : + f:( key -> 'a option -> 'b option -> 'c option ) -> + 'a t -> + 'b t -> + 'c t

Like Map.S.merge.

val extract_min : 'a t -> key * 'a * 'a t

extract_min m returns k, v, m' where k,v is the pair with the smallest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty.

val extract_max : 'a t -> key * 'a * 'a t

extract_max m returns k, v, m' where k,v is the pair with the highest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty.

val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
  • raises Not_found

    if the tree is empty.

val random_choose : Stdlib.Random.State.t -> 'a t -> key * 'a

Randomly choose a (key,value) pair within the tree, using weights as probability weights.

  • raises Not_found

    if the tree is empty.

val add_list : 'a t -> (key * 'a) list -> 'a t
val of_list : (key * 'a) list -> 'a t
val to_list : 'a t -> (key * 'a) list
val add_iter : 'a t -> (key * 'a) iter -> 'a t
val of_iter : (key * 'a) iter -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val add_gen : 'a t -> (key * 'a) gen -> 'a t
val of_gen : (key * 'a) gen -> 'a t
val to_gen : 'a t -> (key * 'a) gen
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_arrow:unit printer -> + ?pp_sep:unit printer -> + key printer -> + 'a printer -> + 'a t printer

Renamed from val print.

  • since 2.0
\ No newline at end of file diff --git a/dev/containers-data/CCWBTree/MakeFull/argument-1-X/index.html b/dev/containers-data/CCWBTree/MakeFull/argument-1-X/index.html new file mode 100644 index 00000000..e957ba79 --- /dev/null +++ b/dev/containers-data/CCWBTree/MakeFull/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers-data.CCWBTree.MakeFull.1-X)

Parameter MakeFull.1-X

include ORD
type t
val compare : t -> t -> int
val weight : t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCWBTree/MakeFull/index.html b/dev/containers-data/CCWBTree/MakeFull/index.html new file mode 100644 index 00000000..d14ad81c --- /dev/null +++ b/dev/containers-data/CCWBTree/MakeFull/index.html @@ -0,0 +1,13 @@ + +MakeFull (containers-data.CCWBTree.MakeFull)

Module CCWBTree.MakeFull

Use the custom X.weight function

Parameters

module X : KEY

Signature

type key = X.t
type +'a t
val empty : 'a t
val is_empty : _ t -> bool
val singleton : key -> 'a -> 'a t
val mem : key -> _ t -> bool
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
  • raises Not_found

    if the key is not present.

val nth : int -> 'a t -> (key * 'a) option

nth i m returns the i-th key, value in the ascending order. Complexity is O(log (cardinal m)).

val nth_exn : int -> 'a t -> key * 'a
  • raises Not_found

    if the index is invalid.

val get_rank : key -> 'a t -> [ `At of int | `After of int | `First ]

get_rank k m looks for the rank of k in m, i.e. the index of k in the sorted list of bindings of m. let (`At n) = get_rank k m in nth_exn n m = get m k should hold.

  • since 1.4
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

update k f m calls f (Some v) if get k m = Some v, f None otherwise. Then, if f returns Some v' it binds k to v', if f returns None it removes k.

val cardinal : _ t -> int
val weight : _ t -> int
val fold : f:( 'b -> key -> 'a -> 'b ) -> x:'b -> 'a t -> 'b
val mapi : f:( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : f:( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : f:( key -> 'a -> unit ) -> 'a t -> unit
val split : key -> 'a t -> 'a t * 'a option * 'a t

split k t returns l, o, r where l is the part of the map with keys smaller than k, r has keys bigger than k, and o = Some v if k, v belonged to the map.

val merge : + f:( key -> 'a option -> 'b option -> 'c option ) -> + 'a t -> + 'b t -> + 'c t

Like Map.S.merge.

val extract_min : 'a t -> key * 'a * 'a t

extract_min m returns k, v, m' where k,v is the pair with the smallest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty.

val extract_max : 'a t -> key * 'a * 'a t

extract_max m returns k, v, m' where k,v is the pair with the highest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty.

val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
  • raises Not_found

    if the tree is empty.

val random_choose : Stdlib.Random.State.t -> 'a t -> key * 'a

Randomly choose a (key,value) pair within the tree, using weights as probability weights.

  • raises Not_found

    if the tree is empty.

val add_list : 'a t -> (key * 'a) list -> 'a t
val of_list : (key * 'a) list -> 'a t
val to_list : 'a t -> (key * 'a) list
val add_iter : 'a t -> (key * 'a) iter -> 'a t
val of_iter : (key * 'a) iter -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val add_gen : 'a t -> (key * 'a) gen -> 'a t
val of_gen : (key * 'a) gen -> 'a t
val to_gen : 'a t -> (key * 'a) gen
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_arrow:unit printer -> + ?pp_sep:unit printer -> + key printer -> + 'a printer -> + 'a t printer

Renamed from val print.

  • since 2.0
\ No newline at end of file diff --git a/dev/containers-data/CCWBTree/module-type-KEY/index.html b/dev/containers-data/CCWBTree/module-type-KEY/index.html new file mode 100644 index 00000000..4722dc49 --- /dev/null +++ b/dev/containers-data/CCWBTree/module-type-KEY/index.html @@ -0,0 +1,2 @@ + +KEY (containers-data.CCWBTree.KEY)

Module type CCWBTree.KEY

include ORD
type t
val compare : t -> t -> int
val weight : t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCWBTree/module-type-ORD/index.html b/dev/containers-data/CCWBTree/module-type-ORD/index.html new file mode 100644 index 00000000..a38b7f6b --- /dev/null +++ b/dev/containers-data/CCWBTree/module-type-ORD/index.html @@ -0,0 +1,2 @@ + +ORD (containers-data.CCWBTree.ORD)

Module type CCWBTree.ORD

type t
val compare : t -> t -> int
\ No newline at end of file diff --git a/dev/containers-data/CCWBTree/module-type-S/index.html b/dev/containers-data/CCWBTree/module-type-S/index.html new file mode 100644 index 00000000..0d8add83 --- /dev/null +++ b/dev/containers-data/CCWBTree/module-type-S/index.html @@ -0,0 +1,13 @@ + +S (containers-data.CCWBTree.S)

Module type CCWBTree.S

type key
type +'a t
val empty : 'a t
val is_empty : _ t -> bool
val singleton : key -> 'a -> 'a t
val mem : key -> _ t -> bool
val get : key -> 'a t -> 'a option
val get_exn : key -> 'a t -> 'a
  • raises Not_found

    if the key is not present.

val nth : int -> 'a t -> (key * 'a) option

nth i m returns the i-th key, value in the ascending order. Complexity is O(log (cardinal m)).

val nth_exn : int -> 'a t -> key * 'a
  • raises Not_found

    if the index is invalid.

val get_rank : key -> 'a t -> [ `At of int | `After of int | `First ]

get_rank k m looks for the rank of k in m, i.e. the index of k in the sorted list of bindings of m. let (`At n) = get_rank k m in nth_exn n m = get m k should hold.

  • since 1.4
val add : key -> 'a -> 'a t -> 'a t
val remove : key -> 'a t -> 'a t
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

update k f m calls f (Some v) if get k m = Some v, f None otherwise. Then, if f returns Some v' it binds k to v', if f returns None it removes k.

val cardinal : _ t -> int
val weight : _ t -> int
val fold : f:( 'b -> key -> 'a -> 'b ) -> x:'b -> 'a t -> 'b
val mapi : f:( key -> 'a -> 'b ) -> 'a t -> 'b t

Map values, giving both key and value. Will use WORD.of_list to rebuild keys.

  • since 0.17
val map : f:( 'a -> 'b ) -> 'a t -> 'b t

Map values, giving only the value.

  • since 0.17
val iter : f:( key -> 'a -> unit ) -> 'a t -> unit
val split : key -> 'a t -> 'a t * 'a option * 'a t

split k t returns l, o, r where l is the part of the map with keys smaller than k, r has keys bigger than k, and o = Some v if k, v belonged to the map.

val merge : + f:( key -> 'a option -> 'b option -> 'c option ) -> + 'a t -> + 'b t -> + 'c t

Like Map.S.merge.

val extract_min : 'a t -> key * 'a * 'a t

extract_min m returns k, v, m' where k,v is the pair with the smallest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty.

val extract_max : 'a t -> key * 'a * 'a t

extract_max m returns k, v, m' where k,v is the pair with the highest key in m, and m' does not contain k.

  • raises Not_found

    if the map is empty.

val choose : 'a t -> (key * 'a) option
val choose_exn : 'a t -> key * 'a
  • raises Not_found

    if the tree is empty.

val random_choose : Stdlib.Random.State.t -> 'a t -> key * 'a

Randomly choose a (key,value) pair within the tree, using weights as probability weights.

  • raises Not_found

    if the tree is empty.

val add_list : 'a t -> (key * 'a) list -> 'a t
val of_list : (key * 'a) list -> 'a t
val to_list : 'a t -> (key * 'a) list
val add_iter : 'a t -> (key * 'a) iter -> 'a t
val of_iter : (key * 'a) iter -> 'a t
val to_iter : 'a t -> (key * 'a) iter
val add_gen : 'a t -> (key * 'a) gen -> 'a t
val of_gen : (key * 'a) gen -> 'a t
val to_gen : 'a t -> (key * 'a) gen
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_arrow:unit printer -> + ?pp_sep:unit printer -> + key printer -> + 'a printer -> + 'a t printer

Renamed from val print.

  • since 2.0
\ No newline at end of file diff --git a/dev/containers-thread/CCLock/LockRef/index.html b/dev/containers-thread/CCLock/LockRef/index.html new file mode 100644 index 00000000..e8e89340 --- /dev/null +++ b/dev/containers-thread/CCLock/LockRef/index.html @@ -0,0 +1,2 @@ + +LockRef (containers-thread.CCLock.LockRef)

Module CCLock.LockRef

Type allowing to manipulate the lock as a reference.

type 'a t
val get : 'a t -> 'a
val set : 'a t -> 'a -> unit
val update : 'a t -> ( 'a -> 'a ) -> unit
\ No newline at end of file diff --git a/dev/containers-thread/CCPool/Make/Fut/Infix/index.html b/dev/containers-thread/CCPool/Make/Fut/Infix/index.html new file mode 100644 index 00000000..76358dcb --- /dev/null +++ b/dev/containers-thread/CCPool/Make/Fut/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers-thread.CCPool.Make.Fut.Infix)

Module Fut.Infix

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t
val (>>) : 'a t -> ( unit -> 'b t ) -> 'b t
val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t
val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t

Let operators on OCaml >= 4.08.0, nothing otherwise

  • since 2.8
include CCShims_syntax.LET with type 'a t := 'a t
val let+ : 'a t -> ( 'a -> 'b ) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ( 'a -> 'b t ) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
\ No newline at end of file diff --git a/dev/containers-thread/CCPool/Make/Fut/index.html b/dev/containers-thread/CCPool/Make/Fut/index.html new file mode 100644 index 00000000..99e8e290 --- /dev/null +++ b/dev/containers-thread/CCPool/Make/Fut/index.html @@ -0,0 +1,2 @@ + +Fut (containers-thread.CCPool.Make.Fut)

Module Make.Fut

Futures

The futures are registration points for callbacks, storing a state, that are executed in the pool using run.

type 'a t

A future value of type 'a

type 'a future = 'a t

Constructors

val return : 'a -> 'a t

Future that is already computed.

val fail : exn -> 'a t

Future that fails immediately.

val make : ( unit -> 'a ) -> 'a t

Create a future, representing a value that will be computed by the function. If the function raises, the future will fail.

val make1 : ( 'a -> 'b ) -> 'a -> 'b t
val make2 : ( 'a -> 'b -> 'c ) -> 'a -> 'b -> 'c t

Basics

val get : 'a t -> 'a

Blocking get: wait for the future to be evaluated, and get the value, or the exception that failed the future is returned. Raise e if the future failed with e.

val state : 'a t -> 'a state

State of the future.

val is_done : 'a t -> bool

Is the future evaluated (success/failure)?

Combinators

val on_success : 'a t -> ( 'a -> unit ) -> unit

Attach a handler to be called upon success. The handler should not call functions on the future. Might be evaluated now if the future is already done.

val on_failure : _ t -> ( exn -> unit ) -> unit

Attach a handler to be called upon failure. The handler should not call any function on the future. Might be evaluated now if the future is already done.

val on_finish : 'a t -> ( 'a state -> unit ) -> unit

Attach a handler to be called when the future is evaluated. The handler should not call functions on the future. Might be evaluated now if the future is already done.

val flat_map : ( 'a -> 'b t ) -> 'a t -> 'b t

Monadic combination of futures.

val and_then : 'a t -> ( unit -> 'b t ) -> 'b t

Wait for the first future to succeed, then launch the second.

val sequence_a : 'a t array -> 'a array t

Future that waits for all previous futures to terminate. If any future in the array fails, sequence_a l fails too.

val map_a : ( 'a -> 'b t ) -> 'a array -> 'b array t

map_a f a maps f on every element of a, and will return the array of every result if all calls succeed, or an error otherwise.

val sequence_l : 'a t list -> 'a list t

Future that waits for all previous futures to terminate. If any future in the list fails, sequence_l l fails too.

val map_l : ( 'a -> 'b t ) -> 'a list -> 'b list t

map_l f l maps f on every element of l, and will return the list of every result if all calls succeed, or an error otherwise.

val choose_a : 'a t array -> 'a t

Choose among those futures (the first to terminate). Behaves like the first future that terminates, by failing if the future fails.

val choose_l : 'a t list -> 'a t

Choose among those futures (the first to terminate). Behaves like the first future that terminates, by failing if the future fails.

val map : ( 'a -> 'b ) -> 'a t -> 'b t

Map the value inside the future. The function doesn't run in its own task; if it can take time, use flat_map or map_async.

val map_async : ( 'a -> 'b ) -> 'a t -> 'b t

Map the value inside the future, to be computed in a separated job.

val monoid_product : ( 'a -> 'b -> 'c ) -> 'a t -> 'b t -> 'c t

Cartesian product of the content of these futures.

  • since 2.8
val app : ( 'a -> 'b ) t -> 'a t -> 'b t

app f x applies the result of f to the result of x.

val app_async : ( 'a -> 'b ) t -> 'a t -> 'b t

app_async f x applies the result of f to the result of x, in a separated job scheduled in the pool.

val sleep : float -> unit t

Future that returns with success in the given amount of seconds. Blocks the thread! If you need to wait on many events, consider using CCTimer.

module Infix : sig ... end
include module type of Infix
val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t
val (>>) : 'a t -> ( unit -> 'b t ) -> 'b t
val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t
val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t

Let operators on OCaml >= 4.08.0, nothing otherwise

  • since 2.8
include CCShims_syntax.LET with type 'a t := 'a t
val let+ : 'a t -> ( 'a -> 'b ) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ( 'a -> 'b t ) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
\ No newline at end of file diff --git a/dev/containers-thread/CCPool/Make/argument-1-P/index.html b/dev/containers-thread/CCPool/Make/argument-1-P/index.html new file mode 100644 index 00000000..5734ba21 --- /dev/null +++ b/dev/containers-thread/CCPool/Make/argument-1-P/index.html @@ -0,0 +1,2 @@ + +P (containers-thread.CCPool.Make.1-P)

Parameter Make.1-P

val max_size : int

Maximum number of threads in the pool.

\ No newline at end of file diff --git a/dev/containers-thread/CCPool/Make/index.html b/dev/containers-thread/CCPool/Make/index.html new file mode 100644 index 00000000..c4f41a23 --- /dev/null +++ b/dev/containers-thread/CCPool/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers-thread.CCPool.Make)

Module CCPool.Make

Create a new Pool

Parameters

module P : PARAM

Signature

val run : ( unit -> _ ) -> unit

run f schedules f for being executed in the thread pool.

val run1 : ( 'a -> _ ) -> 'a -> unit

run1 f x is similar to run (fun () -> f x).

val run2 : ( 'a -> 'b -> _ ) -> 'a -> 'b -> unit
val run3 : ( 'a -> 'b -> 'c -> _ ) -> 'a -> 'b -> 'c -> unit
val set_exn_handler : ( exn -> unit ) -> unit
val active : unit -> bool

active () is true as long as stop() has not been called yet.

val stop : unit -> unit

After calling stop (), most functions will raise Stopped. This has the effect of preventing new tasks from being executed.

module Fut : sig ... end
\ No newline at end of file diff --git a/dev/containers-thread/CCPool/module-type-PARAM/index.html b/dev/containers-thread/CCPool/module-type-PARAM/index.html new file mode 100644 index 00000000..c1c16fce --- /dev/null +++ b/dev/containers-thread/CCPool/module-type-PARAM/index.html @@ -0,0 +1,2 @@ + +PARAM (containers-thread.CCPool.PARAM)

Module type CCPool.PARAM

val max_size : int

Maximum number of threads in the pool.

\ No newline at end of file diff --git a/dev/containers-thread/CCThread/Arr/index.html b/dev/containers-thread/CCThread/Arr/index.html new file mode 100644 index 00000000..67a5d20d --- /dev/null +++ b/dev/containers-thread/CCThread/Arr/index.html @@ -0,0 +1,2 @@ + +Arr (containers-thread.CCThread.Arr)

Module CCThread.Arr

Array of threads

val spawn : int -> ( int -> 'a ) -> t array

Arr.spawn n f creates an array res of length n, such that res.(i) = spawn (fun () -> f i).

val join : t array -> unit

Arr.join a joins every thread in a.

\ No newline at end of file diff --git a/dev/containers-thread/CCThread/Barrier/index.html b/dev/containers-thread/CCThread/Barrier/index.html new file mode 100644 index 00000000..0cac68db --- /dev/null +++ b/dev/containers-thread/CCThread/Barrier/index.html @@ -0,0 +1,2 @@ + +Barrier (containers-thread.CCThread.Barrier)

Module CCThread.Barrier

type t

Barrier, used to synchronize threads

val create : unit -> t

Create a barrier.

val reset : t -> unit

Reset to initial (non-triggered) state.

val wait : t -> unit

wait b waits for barrier b to be activated by activate b. All threads calling this wait until activate b is called. If b is already activated, wait b does nothing.

val activate : t -> unit

activate b unblocks all threads that were waiting on b.

val activated : t -> bool

activated b returns true iff activate b was called, and reset b was not called since. In other words, activated b = true means wait b will not block.

\ No newline at end of file diff --git a/dev/containers/CCArray/Floatarray/index.html b/dev/containers/CCArray/Floatarray/index.html new file mode 100644 index 00000000..cb140abb --- /dev/null +++ b/dev/containers/CCArray/Floatarray/index.html @@ -0,0 +1,2 @@ + +Floatarray (containers.CCArray.Floatarray)

Module CCArray.Floatarray

val create : int -> floatarray
val length : floatarray -> int
val get : floatarray -> int -> float
val set : floatarray -> int -> float -> unit
val unsafe_get : floatarray -> int -> float
val unsafe_set : floatarray -> int -> float -> unit
\ No newline at end of file diff --git a/dev/containers/CCArray/Infix/index.html b/dev/containers/CCArray/Infix/index.html new file mode 100644 index 00000000..e68b9002 --- /dev/null +++ b/dev/containers/CCArray/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCArray.Infix)

Module CCArray.Infix

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

a >>= f is the infix version of flat_map.

val (>>|) : 'a t -> ( 'a -> 'b ) -> 'b t

a >>| f is the infix version of map.

  • since 0.8
val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

a >|= f is the infix version of map.

  • since 0.8
val (--) : int -> int -> int t

x -- y creates an array containing integers in the range x .. y. Bounds included.

val (--^) : int -> int -> int t

x --^ y creates an array containing integers in the range x .. y. Right bound excluded.

  • since 0.17

Let operators on OCaml >= 4.08.0, nothing otherwise

  • since 2.8
val let+ : 'a array -> ( 'a -> 'b ) -> 'b array
val and+ : 'a array -> 'b array -> ('a * 'b) array
val let* : 'a array -> ( 'a -> 'b array ) -> 'b array
val and* : 'a array -> 'b array -> ('a * 'b) array
\ No newline at end of file diff --git a/dev/containers/CCArray/module-type-MONO_ARRAY/index.html b/dev/containers/CCArray/module-type-MONO_ARRAY/index.html new file mode 100644 index 00000000..bed99707 --- /dev/null +++ b/dev/containers/CCArray/module-type-MONO_ARRAY/index.html @@ -0,0 +1,2 @@ + +MONO_ARRAY (containers.CCArray.MONO_ARRAY)

Module type CCArray.MONO_ARRAY

type elt
type t
val length : t -> int
val get : t -> int -> elt
val set : t -> int -> elt -> unit
\ No newline at end of file diff --git a/dev/containers/CCArrayLabels/Floatarray/index.html b/dev/containers/CCArrayLabels/Floatarray/index.html new file mode 100644 index 00000000..efc53a15 --- /dev/null +++ b/dev/containers/CCArrayLabels/Floatarray/index.html @@ -0,0 +1,2 @@ + +Floatarray (containers.CCArrayLabels.Floatarray)

Module CCArrayLabels.Floatarray

val create : int -> floatarray
val length : floatarray -> int
val get : floatarray -> int -> float
val set : floatarray -> int -> float -> unit
val unsafe_get : floatarray -> int -> float
val unsafe_set : floatarray -> int -> float -> unit
\ No newline at end of file diff --git a/dev/containers/CCArrayLabels/Infix/index.html b/dev/containers/CCArrayLabels/Infix/index.html new file mode 100644 index 00000000..64e9e797 --- /dev/null +++ b/dev/containers/CCArrayLabels/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCArrayLabels.Infix)

Module CCArrayLabels.Infix

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

a >>= f is the infix version of flat_map.

val (>>|) : 'a t -> ( 'a -> 'b ) -> 'b t

a >>| f is the infix version of map.

  • since 0.8
val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

a >|= f is the infix version of map.

  • since 0.8
val (--) : int -> int -> int t

x -- y creates an array containing integers in the range x .. y. Bounds included.

val (--^) : int -> int -> int t

x --^ y creates an array containing integers in the range x .. y. Right bound excluded.

  • since 0.17

Let operators on OCaml >= 4.08.0, nothing otherwise

  • since 2.8
val let+ : 'a array -> ( 'a -> 'b ) -> 'b array
val and+ : 'a array -> 'b array -> ('a * 'b) array
val let* : 'a array -> ( 'a -> 'b array ) -> 'b array
val and* : 'a array -> 'b array -> ('a * 'b) array
\ No newline at end of file diff --git a/dev/containers/CCArrayLabels/module-type-MONO_ARRAY/index.html b/dev/containers/CCArrayLabels/module-type-MONO_ARRAY/index.html new file mode 100644 index 00000000..1bb842da --- /dev/null +++ b/dev/containers/CCArrayLabels/module-type-MONO_ARRAY/index.html @@ -0,0 +1,2 @@ + +MONO_ARRAY (containers.CCArrayLabels.MONO_ARRAY)

Module type CCArrayLabels.MONO_ARRAY

type elt
type t
val length : t -> int
val get : t -> int -> elt
val set : t -> int -> elt -> unit
\ No newline at end of file diff --git a/dev/containers/CCCanonical_sexp/Make/argument-1-Sexp/index.html b/dev/containers/CCCanonical_sexp/Make/argument-1-Sexp/index.html new file mode 100644 index 00000000..4ea353c3 --- /dev/null +++ b/dev/containers/CCCanonical_sexp/Make/argument-1-Sexp/index.html @@ -0,0 +1,2 @@ + +Sexp (containers.CCCanonical_sexp.Make.1-Sexp)

Parameter Make.1-Sexp

type t
val atom : string -> t
val list : t list -> t
val match_ : t -> atom:( string -> 'a ) -> list:( t list -> 'a ) -> 'a
\ No newline at end of file diff --git a/dev/containers/CCCanonical_sexp/Make/index.html b/dev/containers/CCCanonical_sexp/Make/index.html new file mode 100644 index 00000000..fcdaf571 --- /dev/null +++ b/dev/containers/CCCanonical_sexp/Make/index.html @@ -0,0 +1,4 @@ + +Make (containers.CCCanonical_sexp.Make)

Module CCCanonical_sexp.Make

Parser and printer

Parameters

module Sexp : SEXP

Signature

type t = Sexp.t
type sexp = t

Re-exports

val atom : string -> t

Make an atom out of this string.

  • since 2.8
val list : t list -> t

Make a Sexpr of this list.

  • since 2.8

Constructors

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

Reverse the list.

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

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

val of_field : string -> t -> t

Used to represent one record field.

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

Represent a record by its named fields.

Printing

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

Print the given iter of expressions to a file.

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

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

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

Raw, direct printing as compact as possible.

Parsing

val parse_string : string -> t CCSexp_intf.or_error

Parse a string.

val parse_string_list : string -> t list CCSexp_intf.or_error

Parse a string into a list of S-exprs.

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

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

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

Parse a channel into a generator of S-expressions.

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

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

val parse_file_list : string -> t list CCSexp_intf.or_error

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

\ No newline at end of file diff --git a/dev/containers/CCChar/Infix/index.html b/dev/containers/CCChar/Infix/index.html new file mode 100644 index 00000000..09c6f294 --- /dev/null +++ b/dev/containers/CCChar/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCChar.Infix)

Module CCChar.Infix

val (=) : t -> t -> bool
  • since 3.3
val (<>) : t -> t -> bool
  • since 3.3
val (<) : t -> t -> bool
  • since 3.3
val (>) : t -> t -> bool
  • since 3.3
val (<=) : t -> t -> bool
  • since 3.3
val (>=) : t -> t -> bool
  • since 3.3
\ No newline at end of file diff --git a/dev/containers/CCEqual/Infix/index.html b/dev/containers/CCEqual/Infix/index.html new file mode 100644 index 00000000..2dbfcb39 --- /dev/null +++ b/dev/containers/CCEqual/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCEqual.Infix)

Module CCEqual.Infix

val (>|=) : 'b t -> ( 'a -> 'b ) -> 'a t

Infix equivalent of map.

\ No newline at end of file diff --git a/dev/containers/CCEqualLabels/Infix/index.html b/dev/containers/CCEqualLabels/Infix/index.html new file mode 100644 index 00000000..020e5e57 --- /dev/null +++ b/dev/containers/CCEqualLabels/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCEqualLabels.Infix)

Module CCEqualLabels.Infix

val (>|=) : 'b t -> ( 'a -> 'b ) -> 'a t

Infix equivalent of map.

\ No newline at end of file diff --git a/dev/containers/CCFloat/Infix/index.html b/dev/containers/CCFloat/Infix/index.html new file mode 100644 index 00000000..bfd8d974 --- /dev/null +++ b/dev/containers/CCFloat/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCFloat.Infix)

Module CCFloat.Infix

val (=) : t -> t -> bool
  • since 0.17
val (<>) : t -> t -> bool
  • since 0.17
val (<) : t -> t -> bool
  • since 0.17
val (>) : t -> t -> bool
  • since 0.17
val (<=) : t -> t -> bool
  • since 0.17
val (>=) : t -> t -> bool
  • since 0.17
val (+) : t -> t -> t

Addition.

  • since 2.1
val (-) : t -> t -> t

Subtraction.

  • since 2.1
val (~-) : t -> t

Unary negation.

  • since 2.1
val (*) : t -> t -> t

Multiplication.

  • since 2.1
val (/) : t -> t -> t

Division.

  • since 2.1
\ No newline at end of file diff --git a/dev/containers/CCFormat/ANSI_codes/index.html b/dev/containers/CCFormat/ANSI_codes/index.html new file mode 100644 index 00000000..ed73ac54 --- /dev/null +++ b/dev/containers/CCFormat/ANSI_codes/index.html @@ -0,0 +1,3 @@ + +ANSI_codes (containers.CCFormat.ANSI_codes)

Module CCFormat.ANSI_codes

ANSI escape codes. This contains lower level functions for them.

type color = [
| `Black
| `Red
| `Yellow
| `Green
| `Blue
| `Magenta
| `Cyan
| `White
]

An ANSI color

type style = [
| `FG of color(*

foreground

*)
| `BG of color(*

background

*)
| `Bold
| `Reset
]

A style. Styles can be composed in a list.

val clear_line : string

clear_line is an escape code to clear the current line. It is very useful for progress bars; for example:

let pp_progress i =
+  Printf.printf "%sprogress at %d%!" ANSI_codes.clear_line i

if called repeatedly this will print successive progress messages on a single line.

val reset : string

The escape code to reset style (colors, bold, etc.)

val string_of_style : style -> string

string_of_style st is an escape code to set the current style to st. It can be printed as is on any output that is a compatible terminal.

val string_of_style_list : style list -> string

string_of_style_list styles is an escape code for multiple styles at once. For example string_of_style_list ANSI_codes.([`FG `Red; `BG `Green; `Bold]) is a very shiny style.

\ No newline at end of file diff --git a/dev/containers/CCFormat/Dump/index.html b/dev/containers/CCFormat/Dump/index.html new file mode 100644 index 00000000..f9762c52 --- /dev/null +++ b/dev/containers/CCFormat/Dump/index.html @@ -0,0 +1,2 @@ + +Dump (containers.CCFormat.Dump)

Module CCFormat.Dump

type 'a t = 'a printer
val unit : unit t
val int : int t
val string : string t
val bool : bool t
val float : float t
val char : char t
val int32 : int32 t
val int64 : int64 t
val nativeint : nativeint t
val list : 'a t -> 'a list t
val array : 'a t -> 'a array t
val option : 'a t -> 'a option t
val pair : 'a t -> 'b t -> ('a * 'b) t
val triple : 'a t -> 'b t -> 'c t -> ('a * 'b * 'c) t
val quad : 'a t -> 'b t -> 'c t -> 'd t -> ('a * 'b * 'c * 'd) t
val result : 'a t -> ( 'a, string ) Stdlib.result t
val result' : 'a t -> 'e t -> ( 'a, 'e ) Stdlib.result t
val to_string : 'a t -> 'a -> string

Alias to CCFormat.to_string.

\ No newline at end of file diff --git a/dev/containers/CCFormat/Infix/index.html b/dev/containers/CCFormat/Infix/index.html new file mode 100644 index 00000000..b2e86e37 --- /dev/null +++ b/dev/containers/CCFormat/Infix/index.html @@ -0,0 +1,2 @@ + +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/CCFun/Infix/index.html b/dev/containers/CCFun/Infix/index.html new file mode 100644 index 00000000..b4fb735c --- /dev/null +++ b/dev/containers/CCFun/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCFun.Infix)

Module CCFun.Infix

val (|>) : 'a -> ( 'a -> 'b ) -> 'b

x |> f is the same as f x. A 'pipe' operator.

val (@@) : ( 'a -> 'b ) -> 'a -> 'b

f @@ x is the same as f x, but right-associative.

  • since 0.5
val (%>) : ( 'a -> 'b ) -> ( 'b -> 'c ) -> 'a -> 'c

(f %> g) x or (%>) f g x is g (f x). Alias to compose.

val (%) : ( 'b -> 'c ) -> ( 'a -> 'b ) -> 'a -> 'c

(f % g) x or (%) f g x is f (g x). Mathematical composition.

\ No newline at end of file diff --git a/dev/containers/CCFun/Monad/argument-1-X/index.html b/dev/containers/CCFun/Monad/argument-1-X/index.html new file mode 100644 index 00000000..89264d19 --- /dev/null +++ b/dev/containers/CCFun/Monad/argument-1-X/index.html @@ -0,0 +1,2 @@ + +X (containers.CCFun.Monad.1-X)

Parameter Monad.1-X

type t
\ No newline at end of file diff --git a/dev/containers/CCFun/Monad/index.html b/dev/containers/CCFun/Monad/index.html new file mode 100644 index 00000000..6133a9d5 --- /dev/null +++ b/dev/containers/CCFun/Monad/index.html @@ -0,0 +1,2 @@ + +Monad (containers.CCFun.Monad)

Module CCFun.Monad

Parameters

module X : sig ... end

Signature

type 'a t = X.t -> 'a
val return : 'a -> 'a t

Monadic return.

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t
val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

Monadic bind.

\ No newline at end of file diff --git a/dev/containers/CCHashtbl/Make/index.html b/dev/containers/CCHashtbl/Make/index.html new file mode 100644 index 00000000..2fa64c3b --- /dev/null +++ b/dev/containers/CCHashtbl/Make/index.html @@ -0,0 +1,22 @@ + +Make (containers.CCHashtbl.Make)

Module CCHashtbl.Make

Parameters

module X : Stdlib.Hashtbl.HashedType

Signature

include Stdlib.Hashtbl.S + with type key = X.t + with type 'a t = 'a Stdlib.Hashtbl.Make(X).t
type key = X.t
type 'a t = 'a Stdlib.Hashtbl.Make(X).t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib__Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option

get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.

val get_or : 'a t -> key -> default:'a -> 'a

get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).

  • since 0.16
val add_list : 'a list t -> key -> 'a -> unit

add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.

  • since 0.16
val incr : ?by:int -> int t -> key -> unit

incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).

  • parameter by

    if specified, the int value is incremented by by rather than 1.

  • since 0.16
val decr : ?by:int -> int t -> key -> unit

decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.

  • since 0.16
val keys : 'a t -> key iter

keys tbl f iterates on keys (similar order as Hashtbl.iter).

val values : 'a t -> 'a iter

values tbl f iterates on values in the table.

val keys_list : _ t -> key list

keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.

  • since 0.8
val values_list : 'a t -> 'a list

values_list t is the list of values in t.

  • since 0.8
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list

Map on a hashtable's items, collect into a list.

val to_iter : 'a t -> (key * 'a) iter

Iterate on bindings in the table.

  • since 2.8
val add_iter : 'a t -> (key * 'a) iter -> unit

Add the corresponding pairs to the table, using Hashtbl.add.

  • since 2.8
val add_iter_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) iter -> + unit

Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit

Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.

  • since 3.0
val add_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) Stdlib.Seq.t -> + unit

Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_iter : (key * 'a) iter -> 'a t

From the given bindings, added in order.

  • since 2.8
val of_iter_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) iter -> 'a t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t

From the given bindings, added in order. Renamed from of_std_seq since 3.0.

  • since 3.0
val of_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + (key * 'a) Stdlib.Seq.t -> + 'a t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_iter_count : int t -> key iter -> unit

add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.

  • since 2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit

add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.

  • since 3.0
val of_iter_count : key iter -> int t

Like add_seq_count, but allocates a new table and returns it.

  • since 2.8
val of_seq_count : key Stdlib.Seq.t -> int t

Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.

  • since 3.0
val to_list : 'a t -> (key * 'a) list

to_list tbl returns the list of (key,value) bindings (order unspecified).

val of_list : (key * 'a) list -> 'a t

of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.

val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t

of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit

update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.

  • since 0.14
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a

get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.

  • since 1.0
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + ?pp_arrow:unit printer -> + key printer -> + 'a printer -> + 'a t printer

pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.

  • since 0.13
\ No newline at end of file diff --git a/dev/containers/CCHashtbl/Poly/index.html b/dev/containers/CCHashtbl/Poly/index.html new file mode 100644 index 00000000..1df34bdd --- /dev/null +++ b/dev/containers/CCHashtbl/Poly/index.html @@ -0,0 +1,30 @@ + +Poly (containers.CCHashtbl.Poly)

Module CCHashtbl.Poly

val get : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a -> 'b option

get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.

val get_or : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b

get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).

  • since 0.16
val keys : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a iter

keys tbl f iterates on keys (similar order as Hashtbl.iter).

val values : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'b iter

values tbl f iterates on values in the table tbl.

val keys_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a list

keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.

  • since 0.8
val values_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'b list

values_list tbl is the list of values in tbl.

  • since 0.8
val map_list : ( 'a -> 'b -> 'c ) -> ( 'a, 'b ) Stdlib.Hashtbl.t -> 'c list

map_list f tbl maps on a tbl's items. Collect into a list.

val incr : ?by:int -> ( 'a, int ) Stdlib.Hashtbl.t -> 'a -> unit

incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).

  • parameter by

    if specified, the int value is incremented by by rather than 1.

  • since 0.16
val decr : ?by:int -> ( 'a, int ) Stdlib.Hashtbl.t -> 'a -> unit

decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.

  • since 0.16
val to_iter : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) iter

Iterate on bindings in the table.

  • since 2.8
val add_list : ( 'a, 'b list ) Stdlib.Hashtbl.t -> 'a -> 'b -> unit

add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.

  • since 0.16
val add_iter : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) iter -> unit

Add the corresponding pairs to the table, using Hashtbl.add.

  • since 2.8
val add_iter_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ( 'a, 'b ) Stdlib.Hashtbl.t -> + ('a * 'b) iter -> + unit

Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_seq : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit

Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.

  • since 3.0
val add_seq_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ( 'a, 'b ) Stdlib.Hashtbl.t -> + ('a * 'b) Stdlib.Seq.t -> + unit

Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_iter : ('a * 'b) iter -> ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order.

  • since 2.8
val of_iter_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) iter -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_seq : ('a * 'b) Stdlib.Seq.t -> ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. Renamed from of_std_seq since 3.0.

  • since 3.0
val of_seq_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) Stdlib.Seq.t -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_iter_count : ( 'a, int ) Stdlib.Hashtbl.t -> 'a iter -> unit

add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.

  • since 2.8
val add_seq_count : ( 'a, int ) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit

add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.

  • since 3.0
val of_iter_count : 'a iter -> ( 'a, int ) Stdlib.Hashtbl.t

Like add_seq_count, but allocates a new table and returns it.

  • since 2.8
val of_seq_count : 'a Stdlib.Seq.t -> ( 'a, int ) Stdlib.Hashtbl.t

Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.

  • since 3.0
val to_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) list

to_list tbl returns the list of (key,value) bindings (order unspecified).

val of_list : ('a * 'b) list -> ( 'a, 'b ) Stdlib.Hashtbl.t

of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.

val of_list_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) list -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val update : + ( 'a, 'b ) Stdlib.Hashtbl.t -> + f:( 'a -> 'b option -> 'b option ) -> + k:'a -> + unit

update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.

  • since 0.14
val get_or_add : ( 'a, 'b ) Stdlib.Hashtbl.t -> f:( 'a -> 'b ) -> k:'a -> 'b

get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.

  • since 1.0
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + ?pp_arrow:unit printer -> + 'a printer -> + 'b printer -> + ( 'a, 'b ) Stdlib.Hashtbl.t printer

pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.

  • since 0.13
\ No newline at end of file diff --git a/dev/containers/CCHashtbl/module-type-S/index.html b/dev/containers/CCHashtbl/module-type-S/index.html new file mode 100644 index 00000000..1038f2b4 --- /dev/null +++ b/dev/containers/CCHashtbl/module-type-S/index.html @@ -0,0 +1,20 @@ + +S (containers.CCHashtbl.S)

Module type CCHashtbl.S

include Stdlib.Hashtbl.S
type key
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib__Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val get : 'a t -> key -> 'a option

get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.

val get_or : 'a t -> key -> default:'a -> 'a

get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).

  • since 0.16
val add_list : 'a list t -> key -> 'a -> unit

add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.

  • since 0.16
val incr : ?by:int -> int t -> key -> unit

incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).

  • parameter by

    if specified, the int value is incremented by by rather than 1.

  • since 0.16
val decr : ?by:int -> int t -> key -> unit

decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.

  • since 0.16
val keys : 'a t -> key iter

keys tbl f iterates on keys (similar order as Hashtbl.iter).

val values : 'a t -> 'a iter

values tbl f iterates on values in the table.

val keys_list : _ t -> key list

keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.

  • since 0.8
val values_list : 'a t -> 'a list

values_list t is the list of values in t.

  • since 0.8
val map_list : ( key -> 'a -> 'b ) -> 'a t -> 'b list

Map on a hashtable's items, collect into a list.

val to_iter : 'a t -> (key * 'a) iter

Iterate on bindings in the table.

  • since 2.8
val add_iter : 'a t -> (key * 'a) iter -> unit

Add the corresponding pairs to the table, using Hashtbl.add.

  • since 2.8
val add_iter_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) iter -> + unit

Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit

Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.

  • since 3.0
val add_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) Stdlib.Seq.t -> + unit

Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_iter : (key * 'a) iter -> 'a t

From the given bindings, added in order.

  • since 2.8
val of_iter_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) iter -> 'a t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t

From the given bindings, added in order. Renamed from of_std_seq since 3.0.

  • since 3.0
val of_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + (key * 'a) Stdlib.Seq.t -> + 'a t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_iter_count : int t -> key iter -> unit

add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.

  • since 2.8
val add_seq_count : int t -> key Stdlib.Seq.t -> unit

add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from of_std_seq_count since 3.0.

  • since 3.0
val of_iter_count : key iter -> int t

Like add_seq_count, but allocates a new table and returns it.

  • since 2.8
val of_seq_count : key Stdlib.Seq.t -> int t

Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.

  • since 3.0
val to_list : 'a t -> (key * 'a) list

to_list tbl returns the list of (key,value) bindings (order unspecified).

val of_list : (key * 'a) list -> 'a t

of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.

val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t

of_list l builds a table from the given list l of bindings k_i -> v_i. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val update : 'a t -> f:( key -> 'a option -> 'a option ) -> k:key -> unit

update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.

  • since 0.14
val get_or_add : 'a t -> f:( key -> 'a ) -> k:key -> 'a

get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.

  • since 1.0
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + ?pp_arrow:unit printer -> + key printer -> + 'a printer -> + 'a t printer

pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.

  • since 0.13
\ No newline at end of file diff --git a/dev/containers/CCHeap/Make/argument-1-E/index.html b/dev/containers/CCHeap/Make/argument-1-E/index.html new file mode 100644 index 00000000..2d25179a --- /dev/null +++ b/dev/containers/CCHeap/Make/argument-1-E/index.html @@ -0,0 +1,2 @@ + +E (containers.CCHeap.Make.1-E)

Parameter Make.1-E

type t
val leq : t -> t -> bool

leq x y shall return true iff x is lower or equal to y.

\ No newline at end of file diff --git a/dev/containers/CCHeap/Make/index.html b/dev/containers/CCHeap/Make/index.html new file mode 100644 index 00000000..d239a259 --- /dev/null +++ b/dev/containers/CCHeap/Make/index.html @@ -0,0 +1,7 @@ + +Make (containers.CCHeap.Make)

Module CCHeap.Make

Parameters

module E : PARTIAL_ORD

Signature

type elt = E.t
type t
val empty : t

empty returns the empty heap.

val is_empty : t -> bool

is_empty h returns true if the heap h is empty.

exception Empty
val merge : t -> t -> t

merge h1 h2 merges the two heaps h1 and h2.

val insert : elt -> t -> t

insert x h inserts an element x into the heap h.

val add : t -> elt -> t

add h x inserts an element x into the heap h.

val filter : ( elt -> bool ) -> t -> t

filter p h filters values, only retaining the ones that satisfy the predicate p. Linear time at least.

val find_min : t -> elt option

find_min h find the minimal element of the heap h.

val find_min_exn : t -> elt

find_min_exn h is like find_min but can fail.

  • raises Empty

    if the heap is empty.

val take : t -> (t * elt) option

take h extracts and returns the minimum element, and the new heap (without this element), or None if the heap h is empty.

val take_exn : t -> t * elt

take_exn h is like take, but can fail.

  • raises Empty

    if the heap is empty.

val delete_one : ( elt -> elt -> bool ) -> elt -> t -> t

delete_one eq x h uses eq to find one occurrence of a value x if it exist in the heap h, and delete it. If h do not contain x then it return h.

  • since 2.0
val delete_all : ( elt -> elt -> bool ) -> elt -> t -> t

delete_all eq x h uses eq to find all x in h and delete them. If h do not contain x then it return h. The difference with filter is that delete_all stops as soon as it enters a subtree whose root is bigger than the element.

  • since 2.0
val iter : ( elt -> unit ) -> t -> unit

iter f h iterates over the heap h invoking f with the current element.

val fold : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a

fold f acc h folds on all values of h.

val size : t -> int

size h is the number of elements in the heap h. Linear complexity.

Conversions

val to_list : t -> elt list

to_list h returns the elements of the heap h, in no particular order.

val to_list_sorted : t -> elt list

to_list_sorted h returns the elements of the heap h in increasing order.

  • since 1.1
val add_list : t -> elt list -> t

add_list h l adds the elements of the list l into the heap h. An element occurring several times will be added that many times to the heap.

  • since 0.16
val of_list : elt list -> t

of_list l is add_list empty l. Complexity: O(n log n).

val add_iter : t -> elt iter -> t

add_iter h iter is like add_list.

  • since 2.8
val add_seq : t -> elt Stdlib.Seq.t -> t

add_seq h seq is like add_list. Renamed from add_std_seq since 3.0.

  • since 3.0
val of_iter : elt iter -> t

of_iter iter builds a heap from a given iter. Complexity: O(n log n).

  • since 2.8
val of_seq : elt Stdlib.Seq.t -> t

of_seq seq builds a heap from a given Seq.t. Complexity: O(n log n). Renamed from of_seq since 3.0.

  • since 3.0
val to_iter : t -> elt iter

to_iter h returns a iter of the elements of the heap h.

  • since 2.8
val to_seq : t -> elt Stdlib.Seq.t

to_seq h returns a Seq.t of the elements of the heap h. Renamed from to_std_seq since 3.0.

  • since 3.0
val to_iter_sorted : t -> elt iter

to_iter_sorted h returns a iter by iterating on the elements of h, in increasing order.

  • since 2.8
val to_seq_sorted : t -> elt Stdlib.Seq.t

to_seq_sorted h returns a Seq.t by iterating on the elements of h, in increasing order. Renamed from to_std_seq_sorted since 3.0.

  • since 3.0
val add_gen : t -> elt gen -> t

add_gen h gen adds the gen gen to the heap h.

  • since 0.16
val of_gen : elt gen -> t

of_gen gen builds a heap from a given gen. Complexity: O(n log n).

val to_gen : t -> elt gen

to_gen h returns a gen of the elements of the heap h.

val to_tree : t -> elt ktree

to_tree h returns a ktree of the elements of the heap h.

val to_string : ?sep:string -> ( elt -> string ) -> t -> string

to_string ?sep f h prints the heap h in a string using sep as a given separator (default ",") between each element (converted to a string using f).

  • since 2.7
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + elt printer -> + t printer

pp ?pp_start ?pp_stop ?pp_sep ppf h prints h on ppf. Each element is formatted with ppf, pp_start is called at the beginning, pp_stop is called at the end, pp_sep is called between each elements. By defaults pp_start and pp_stop does nothing and pp_sep defaults to (fun out -> Format.fprintf out ",@ "). Renamed from print since 2.0

  • since 0.16
\ No newline at end of file diff --git a/dev/containers/CCHeap/Make_from_compare/argument-1-E/index.html b/dev/containers/CCHeap/Make_from_compare/argument-1-E/index.html new file mode 100644 index 00000000..d2f3a329 --- /dev/null +++ b/dev/containers/CCHeap/Make_from_compare/argument-1-E/index.html @@ -0,0 +1,2 @@ + +E (containers.CCHeap.Make_from_compare.1-E)

Parameter Make_from_compare.1-E

type t
val compare : t -> t -> int

compare a b shall return a negative value if a is smaller than b, 0 if a and b are equal or a positive value if a is greater than b

\ No newline at end of file diff --git a/dev/containers/CCHeap/Make_from_compare/index.html b/dev/containers/CCHeap/Make_from_compare/index.html new file mode 100644 index 00000000..21834b00 --- /dev/null +++ b/dev/containers/CCHeap/Make_from_compare/index.html @@ -0,0 +1,7 @@ + +Make_from_compare (containers.CCHeap.Make_from_compare)

Module CCHeap.Make_from_compare

A convenient version of Make that take a TOTAL_ORD instead of a partially ordered module. It allow to directly pass modules that implement compare without implementing leq explicitly

Parameters

module E : TOTAL_ORD

Signature

type elt = E.t
type t
val empty : t

empty returns the empty heap.

val is_empty : t -> bool

is_empty h returns true if the heap h is empty.

exception Empty
val merge : t -> t -> t

merge h1 h2 merges the two heaps h1 and h2.

val insert : elt -> t -> t

insert x h inserts an element x into the heap h.

val add : t -> elt -> t

add h x inserts an element x into the heap h.

val filter : ( elt -> bool ) -> t -> t

filter p h filters values, only retaining the ones that satisfy the predicate p. Linear time at least.

val find_min : t -> elt option

find_min h find the minimal element of the heap h.

val find_min_exn : t -> elt

find_min_exn h is like find_min but can fail.

  • raises Empty

    if the heap is empty.

val take : t -> (t * elt) option

take h extracts and returns the minimum element, and the new heap (without this element), or None if the heap h is empty.

val take_exn : t -> t * elt

take_exn h is like take, but can fail.

  • raises Empty

    if the heap is empty.

val delete_one : ( elt -> elt -> bool ) -> elt -> t -> t

delete_one eq x h uses eq to find one occurrence of a value x if it exist in the heap h, and delete it. If h do not contain x then it return h.

  • since 2.0
val delete_all : ( elt -> elt -> bool ) -> elt -> t -> t

delete_all eq x h uses eq to find all x in h and delete them. If h do not contain x then it return h. The difference with filter is that delete_all stops as soon as it enters a subtree whose root is bigger than the element.

  • since 2.0
val iter : ( elt -> unit ) -> t -> unit

iter f h iterates over the heap h invoking f with the current element.

val fold : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a

fold f acc h folds on all values of h.

val size : t -> int

size h is the number of elements in the heap h. Linear complexity.

Conversions

val to_list : t -> elt list

to_list h returns the elements of the heap h, in no particular order.

val to_list_sorted : t -> elt list

to_list_sorted h returns the elements of the heap h in increasing order.

  • since 1.1
val add_list : t -> elt list -> t

add_list h l adds the elements of the list l into the heap h. An element occurring several times will be added that many times to the heap.

  • since 0.16
val of_list : elt list -> t

of_list l is add_list empty l. Complexity: O(n log n).

val add_iter : t -> elt iter -> t

add_iter h iter is like add_list.

  • since 2.8
val add_seq : t -> elt Stdlib.Seq.t -> t

add_seq h seq is like add_list. Renamed from add_std_seq since 3.0.

  • since 3.0
val of_iter : elt iter -> t

of_iter iter builds a heap from a given iter. Complexity: O(n log n).

  • since 2.8
val of_seq : elt Stdlib.Seq.t -> t

of_seq seq builds a heap from a given Seq.t. Complexity: O(n log n). Renamed from of_seq since 3.0.

  • since 3.0
val to_iter : t -> elt iter

to_iter h returns a iter of the elements of the heap h.

  • since 2.8
val to_seq : t -> elt Stdlib.Seq.t

to_seq h returns a Seq.t of the elements of the heap h. Renamed from to_std_seq since 3.0.

  • since 3.0
val to_iter_sorted : t -> elt iter

to_iter_sorted h returns a iter by iterating on the elements of h, in increasing order.

  • since 2.8
val to_seq_sorted : t -> elt Stdlib.Seq.t

to_seq_sorted h returns a Seq.t by iterating on the elements of h, in increasing order. Renamed from to_std_seq_sorted since 3.0.

  • since 3.0
val add_gen : t -> elt gen -> t

add_gen h gen adds the gen gen to the heap h.

  • since 0.16
val of_gen : elt gen -> t

of_gen gen builds a heap from a given gen. Complexity: O(n log n).

val to_gen : t -> elt gen

to_gen h returns a gen of the elements of the heap h.

val to_tree : t -> elt ktree

to_tree h returns a ktree of the elements of the heap h.

val to_string : ?sep:string -> ( elt -> string ) -> t -> string

to_string ?sep f h prints the heap h in a string using sep as a given separator (default ",") between each element (converted to a string using f).

  • since 2.7
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + elt printer -> + t printer

pp ?pp_start ?pp_stop ?pp_sep ppf h prints h on ppf. Each element is formatted with ppf, pp_start is called at the beginning, pp_stop is called at the end, pp_sep is called between each elements. By defaults pp_start and pp_stop does nothing and pp_sep defaults to (fun out -> Format.fprintf out ",@ "). Renamed from print since 2.0

  • since 0.16
\ No newline at end of file diff --git a/dev/containers/CCHeap/module-type-PARTIAL_ORD/index.html b/dev/containers/CCHeap/module-type-PARTIAL_ORD/index.html new file mode 100644 index 00000000..86fc1e0a --- /dev/null +++ b/dev/containers/CCHeap/module-type-PARTIAL_ORD/index.html @@ -0,0 +1,2 @@ + +PARTIAL_ORD (containers.CCHeap.PARTIAL_ORD)

Module type CCHeap.PARTIAL_ORD

type t
val leq : t -> t -> bool

leq x y shall return true iff x is lower or equal to y.

\ No newline at end of file diff --git a/dev/containers/CCHeap/module-type-S/index.html b/dev/containers/CCHeap/module-type-S/index.html new file mode 100644 index 00000000..db8d7332 --- /dev/null +++ b/dev/containers/CCHeap/module-type-S/index.html @@ -0,0 +1,7 @@ + +S (containers.CCHeap.S)

Module type CCHeap.S

type elt
type t
val empty : t

empty returns the empty heap.

val is_empty : t -> bool

is_empty h returns true if the heap h is empty.

exception Empty
val merge : t -> t -> t

merge h1 h2 merges the two heaps h1 and h2.

val insert : elt -> t -> t

insert x h inserts an element x into the heap h.

val add : t -> elt -> t

add h x inserts an element x into the heap h.

val filter : ( elt -> bool ) -> t -> t

filter p h filters values, only retaining the ones that satisfy the predicate p. Linear time at least.

val find_min : t -> elt option

find_min h find the minimal element of the heap h.

val find_min_exn : t -> elt

find_min_exn h is like find_min but can fail.

  • raises Empty

    if the heap is empty.

val take : t -> (t * elt) option

take h extracts and returns the minimum element, and the new heap (without this element), or None if the heap h is empty.

val take_exn : t -> t * elt

take_exn h is like take, but can fail.

  • raises Empty

    if the heap is empty.

val delete_one : ( elt -> elt -> bool ) -> elt -> t -> t

delete_one eq x h uses eq to find one occurrence of a value x if it exist in the heap h, and delete it. If h do not contain x then it return h.

  • since 2.0
val delete_all : ( elt -> elt -> bool ) -> elt -> t -> t

delete_all eq x h uses eq to find all x in h and delete them. If h do not contain x then it return h. The difference with filter is that delete_all stops as soon as it enters a subtree whose root is bigger than the element.

  • since 2.0
val iter : ( elt -> unit ) -> t -> unit

iter f h iterates over the heap h invoking f with the current element.

val fold : ( 'a -> elt -> 'a ) -> 'a -> t -> 'a

fold f acc h folds on all values of h.

val size : t -> int

size h is the number of elements in the heap h. Linear complexity.

Conversions

val to_list : t -> elt list

to_list h returns the elements of the heap h, in no particular order.

val to_list_sorted : t -> elt list

to_list_sorted h returns the elements of the heap h in increasing order.

  • since 1.1
val add_list : t -> elt list -> t

add_list h l adds the elements of the list l into the heap h. An element occurring several times will be added that many times to the heap.

  • since 0.16
val of_list : elt list -> t

of_list l is add_list empty l. Complexity: O(n log n).

val add_iter : t -> elt iter -> t

add_iter h iter is like add_list.

  • since 2.8
val add_seq : t -> elt Stdlib.Seq.t -> t

add_seq h seq is like add_list. Renamed from add_std_seq since 3.0.

  • since 3.0
val of_iter : elt iter -> t

of_iter iter builds a heap from a given iter. Complexity: O(n log n).

  • since 2.8
val of_seq : elt Stdlib.Seq.t -> t

of_seq seq builds a heap from a given Seq.t. Complexity: O(n log n). Renamed from of_seq since 3.0.

  • since 3.0
val to_iter : t -> elt iter

to_iter h returns a iter of the elements of the heap h.

  • since 2.8
val to_seq : t -> elt Stdlib.Seq.t

to_seq h returns a Seq.t of the elements of the heap h. Renamed from to_std_seq since 3.0.

  • since 3.0
val to_iter_sorted : t -> elt iter

to_iter_sorted h returns a iter by iterating on the elements of h, in increasing order.

  • since 2.8
val to_seq_sorted : t -> elt Stdlib.Seq.t

to_seq_sorted h returns a Seq.t by iterating on the elements of h, in increasing order. Renamed from to_std_seq_sorted since 3.0.

  • since 3.0
val add_gen : t -> elt gen -> t

add_gen h gen adds the gen gen to the heap h.

  • since 0.16
val of_gen : elt gen -> t

of_gen gen builds a heap from a given gen. Complexity: O(n log n).

val to_gen : t -> elt gen

to_gen h returns a gen of the elements of the heap h.

val to_tree : t -> elt ktree

to_tree h returns a ktree of the elements of the heap h.

val to_string : ?sep:string -> ( elt -> string ) -> t -> string

to_string ?sep f h prints the heap h in a string using sep as a given separator (default ",") between each element (converted to a string using f).

  • since 2.7
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + elt printer -> + t printer

pp ?pp_start ?pp_stop ?pp_sep ppf h prints h on ppf. Each element is formatted with ppf, pp_start is called at the beginning, pp_stop is called at the end, pp_sep is called between each elements. By defaults pp_start and pp_stop does nothing and pp_sep defaults to (fun out -> Format.fprintf out ",@ "). Renamed from print since 2.0

  • since 0.16
\ No newline at end of file diff --git a/dev/containers/CCHeap/module-type-TOTAL_ORD/index.html b/dev/containers/CCHeap/module-type-TOTAL_ORD/index.html new file mode 100644 index 00000000..e8fa7409 --- /dev/null +++ b/dev/containers/CCHeap/module-type-TOTAL_ORD/index.html @@ -0,0 +1,2 @@ + +TOTAL_ORD (containers.CCHeap.TOTAL_ORD)

Module type CCHeap.TOTAL_ORD

type t
val compare : t -> t -> int

compare a b shall return a negative value if a is smaller than b, 0 if a and b are equal or a positive value if a is greater than b

\ No newline at end of file diff --git a/dev/containers/CCIO/File/index.html b/dev/containers/CCIO/File/index.html new file mode 100644 index 00000000..1e3099fd --- /dev/null +++ b/dev/containers/CCIO/File/index.html @@ -0,0 +1,7 @@ + +File (containers.CCIO.File)

Module CCIO.File

type t = string

A file should be represented by its absolute path, but currently this is not enforced.

val to_string : t -> string
val make : string -> t

Build a file representation from a path (absolute or relative).

val exists : t -> bool
val is_directory : t -> bool
val remove_exn : t -> unit

remove_exn path tries to remove the file at path from the file system.

  • raises Sys_error

    if there is no file at path or access rights are wrong.

  • since 0.8
val remove : t -> unit or_error

Like remove_exn but with an error monad.

  • since 0.8
val remove_noerr : t -> unit

Like remove_exn but do not raise any exception on failure.

  • since 0.8
val read_dir : ?recurse:bool -> t -> t gen

read_dir d returns a sequence of files and directory contained in the directory d (or an empty stream if d is not a directory).

  • raises Sys_error

    in case of error (e.g. permission denied).

  • parameter recurse

    if true (default false), sub-directories are also explored.

val read_exn : t -> string

Read the content of the given file, or raises some exception.

  • raises Sys_error

    in case of error.

  • since 0.16
val read : t -> string or_error

Read the content of the given file.

  • since 0.16
val append_exn : t -> string -> unit

Append the given string into the given file, possibly raising.

  • raises Sys_error

    in case of error.

  • since 0.16
val append : t -> string -> unit or_error

Append the given string into the given file.

  • since 0.16
val write_exn : t -> string -> unit

Write the given string into the given file, possibly raising.

  • raises Sys_error

    in case of error.

  • since 0.16
val write : t -> string -> unit or_error

Write the given string into the given file.

  • since 0.16
type walk_item = [ `File | `Dir ] * t
val walk : t -> walk_item gen

Like read_dir (with recurse=true), this function walks a directory recursively and yields either files or directories. Is a file anything that doesn't satisfy is_directory (including symlinks, etc.)

  • raises Sys_error

    in case of error (e.g. permission denied) during iteration.

val walk_iter : t -> walk_item iter

Like walk but with an imperative iterator.

  • since 3.6
val walk_l : t -> walk_item list

Like walk but returns a list (therefore it's eager and might take some time on large directories).

  • since 1.1
val walk_seq : t -> walk_item Stdlib.Seq.t

Like walk but returns a Seq

  • since 3.6
val show_walk_item : walk_item -> string
val with_temp : + ?temp_dir:string -> + prefix:string -> + suffix:string -> + ( string -> 'a ) -> + 'a

with_temp ~prefix ~suffix f will call f with the name of a new temporary file (located in temp_dir). After f returns, the file is deleted. Best to be used in combination with with_out. See Filename.temp_file.

  • since 0.17
\ No newline at end of file diff --git a/dev/containers/CCInt/Infix/index.html b/dev/containers/CCInt/Infix/index.html new file mode 100644 index 00000000..dfd23185 --- /dev/null +++ b/dev/containers/CCInt/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCInt.Infix)

Module CCInt.Infix

val (=) : t -> t -> bool
  • since 0.17
val (<>) : t -> t -> bool
  • since 0.17
val (<) : t -> t -> bool
  • since 0.17
val (>) : t -> t -> bool
  • since 0.17
val (<=) : t -> t -> bool
  • since 0.17
val (>=) : t -> t -> bool
  • since 0.17
val (--) : t -> t -> t iter

Alias to range.

  • since 1.2
val (--^) : t -> t -> t iter

Alias to range'.

  • since 1.2
val (+) : t -> t -> t
  • since 2.1
val (-) : t -> t -> t
  • since 2.1
val (~-) : t -> t
  • since 2.1
val (*) : t -> t -> t
  • since 2.1
val (/) : t -> t -> t
  • since 2.1
val (**) : t -> t -> t
  • since 2.4
val (mod) : t -> t -> t
  • since 2.1
val (land) : t -> t -> t
  • since 2.1
val (lor) : t -> t -> t
  • since 2.1
val (lxor) : t -> t -> t
  • since 2.1
val lnot : t -> t
  • since 2.1
val (lsl) : t -> int -> t
  • since 2.1
val (lsr) : t -> int -> t
  • since 2.1
val (asr) : t -> int -> t
  • since 2.1
\ No newline at end of file diff --git a/dev/containers/CCInt32/Infix/index.html b/dev/containers/CCInt32/Infix/index.html new file mode 100644 index 00000000..14cb65cf --- /dev/null +++ b/dev/containers/CCInt32/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCInt32.Infix)

Module CCInt32.Infix

val (+) : t -> t -> t

x + y is the sum of x and y. Addition.

val (-) : t -> t -> t

x - y is the difference of x and y. Subtraction.

val (~-) : t -> t

~- x is the negation of x. Unary negation.

val (*) : t -> t -> t

x * y is the product of x and y. Multiplication.

val (/) : t -> t -> t

x / y is the integer quotient of x and y. Integer division. Raise Division_by_zero if the second argument y is zero. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/).

val (mod) : t -> t -> t

x mod y is the integer remainder of x / y. If y <> zero, the result of x mod y satisfies the following properties: zero <= x mod y < abs y and x = ((x / y) * y) + (x mod y). If y = 0, x mod y raises Division_by_zero.

val (**) : t -> t -> t

Alias to pow

  • since 3.0
val (--) : t -> t -> t iter

Alias to range.

  • since 3.0
val (--^) : t -> t -> t iter

Alias to range'.

  • since 3.0
val (land) : t -> t -> t

x land y is the bitwise logical and of x and y.

val (lor) : t -> t -> t

x lor y is the bitwise logical or of x and y.

val (lxor) : t -> t -> t

x lxor y is the bitwise logical exclusive or of x and y.

val lnot : t -> t

lnot x is the bitwise logical negation of x (the bits of x are inverted).

val (lsl) : t -> int -> t

x lsl y shifts x to the left by y bits, filling in with zeroes. The result is unspecified if y < 0 or y >= 32.

val (lsr) : t -> int -> t

x lsr y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= 32.

val (asr) : t -> int -> t

x asr y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= 32.

val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (<) : t -> t -> bool
\ No newline at end of file diff --git a/dev/containers/CCInt64/Infix/index.html b/dev/containers/CCInt64/Infix/index.html new file mode 100644 index 00000000..ba36228b --- /dev/null +++ b/dev/containers/CCInt64/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCInt64.Infix)

Module CCInt64.Infix

val (+) : t -> t -> t

x + y is the sum of x and y. Addition.

val (-) : t -> t -> t

x - y is the difference of x and y. Subtraction.

val (~-) : t -> t

~- x is the negation of x. Unary negation.

val (*) : t -> t -> t

x * y is the product of x and y. Multiplication.

val (/) : t -> t -> t

x / y is the integer quotient of x and y. Integer division. Raise Division_by_zero if the second argument y is zero. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/).

val (mod) : t -> t -> t

x mod y is the integer remainder of x / y. If y <> zero, the result of x mod y satisfies the following properties: zero <= x mod y < abs y and x = ((x / y) * y) + (x mod y). If y = 0, x mod y raises Division_by_zero.

val (**) : t -> t -> t

Alias to pow

  • since 3.0
val (--) : t -> t -> t iter

Alias to range.

  • since 3.0
val (--^) : t -> t -> t iter

Alias to range'.

  • since 3.0
val (land) : t -> t -> t

x land y is the bitwise logical and of x and y.

val (lor) : t -> t -> t

x lor y is the bitwise logical or of x and y.

val (lxor) : t -> t -> t

x lxor y is the bitwise logical exclusive or of x and y.

val lnot : t -> t

lnot x is the bitwise logical negation of x (the bits of x are inverted).

val (lsl) : t -> int -> t

x lsl y shifts x to the left by y bits, filling in with zeroes. The result is unspecified if y < 0 or y >= 64.

val (lsr) : t -> int -> t

x lsr y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= 64.

val (asr) : t -> int -> t

x asr y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= 64.

val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (<) : t -> t -> bool
\ No newline at end of file diff --git a/dev/containers/CCList/Assoc/index.html b/dev/containers/CCList/Assoc/index.html new file mode 100644 index 00000000..d629f9fc --- /dev/null +++ b/dev/containers/CCList/Assoc/index.html @@ -0,0 +1,7 @@ + +Assoc (containers.CCList.Assoc)

Module CCList.Assoc

type ('a, 'b) t = ('a * 'b) list
val get : eq:( 'a -> 'a -> bool ) -> 'a -> ( 'a, 'b ) t -> 'b option

get ~eq k alist returns Some v if the given key k is present into alist, or None if not present.

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

get_exn ~eq k alist returns v if the element k is present into alist. Like get, but unsafe.

  • raises Not_found

    if the element is not present.

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

set ~eq k v alist adds the binding k, v into the list alist (erase it if already present).

val mem : ?eq:( 'a -> 'a -> bool ) -> 'a -> ( 'a, _ ) t -> bool

mem ?eq k alist returns true iff k is a key in alist.

  • since 0.16
val update : + eq:( 'a -> 'a -> bool ) -> + f:( 'b option -> 'b option ) -> + 'a -> + ( 'a, 'b ) t -> + ( 'a, 'b ) t

update ~eq ~f k alist updates alist on the key k, by calling f (get k alist) and removing k if it returns None, mapping k to v' if it returns Some v'.

  • since 0.16
val remove : eq:( 'a -> 'a -> bool ) -> 'a -> ( 'a, 'b ) t -> ( 'a, 'b ) t

remove ~eq k alist returns the alist without the first pair with key k, if any.

  • since 0.17
val keys : ( 'a, 'b ) t -> 'a list

keys alist returns a list of all keys of alist.

  • since 3.8
val values : ( 'a, 'b ) t -> 'b list

values alist returns a list of all values of alist.

  • since 3.8
val map_values : ( 'b -> 'c ) -> ( 'a, 'b ) t -> ( 'a, 'c ) t

map_values f alist applies function f to all values of alist.

  • since 3.8
\ No newline at end of file diff --git a/dev/containers/CCList/Infix/index.html b/dev/containers/CCList/Infix/index.html new file mode 100644 index 00000000..d7d1c86a --- /dev/null +++ b/dev/containers/CCList/Infix/index.html @@ -0,0 +1,9 @@ + +Infix (containers.CCList.Infix)

Module CCList.Infix

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

l >|= f is the infix version of map with reversed arguments.

val (@) : 'a t -> 'a t -> 'a t

l1 @ l2 concatenates two lists l1 and l2. As append.

val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t

funs <*> l is product (fun f x -> f x) funs l.

val (<$>) : ( 'a -> 'b ) -> 'a t -> 'b t

f <$> l is like map.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

l >>= f is flat_map f l.

val (--) : int -> int -> int t

i -- j is the infix alias for range. Bounds included.

val (--^) : int -> int -> int t

i --^ j is the infix alias for range'. Second bound j excluded.

  • since 0.17
val let+ : 'a t -> ( 'a -> 'b ) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ( 'a -> 'b t ) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
val and& : 'a list -> 'b list -> ('a * 'b) list

(and&) is combine_shortest. It allows to perform a synchronized product between two lists, stopping gently at the shortest. Usable both with let+ and let*.

# let f xs ys zs =
+    let+ x = xs
+    and& y = ys
+    and& z = zs in
+    x + y + z;;
+val f : int list -> int list -> int list -> int list = <fun>
+# f [1;2] [5;6;7] [10;10];;
+- : int list = [16; 18]
  • since 3.1
\ No newline at end of file diff --git a/dev/containers/CCList/Ref/index.html b/dev/containers/CCList/Ref/index.html new file mode 100644 index 00000000..babbd068 --- /dev/null +++ b/dev/containers/CCList/Ref/index.html @@ -0,0 +1,2 @@ + +Ref (containers.CCList.Ref)

Module CCList.Ref

type 'a t = 'a list Stdlib.ref
val push : 'a t -> 'a -> unit

push rlist e adds an element e at the head of rlist.

val pop : 'a t -> 'a option

pop rlist removes and returns Some e (the first element of rlist) or None if the rlist is empty

val pop_exn : 'a t -> 'a

pop_exn rlist removes and returns the first element of rlist. Unsafe version of pop.

  • raises Failure

    if the list is empty.

val create : unit -> 'a t

create () creates a new empty reference list.

val clear : _ t -> unit

clear rlist removes all elements of rlist.

val lift : ( 'a list -> 'b ) -> 'a t -> 'b

lift f rlist applies a list function f to the content of rlist.

val push_list : 'a t -> 'a list -> unit

push_list rlist l adds elements of the list l at the beginning of the list ref rlist. Elements at the end of the list l will be at the beginning of the list ref rlist.

\ No newline at end of file diff --git a/dev/containers/CCList/Traverse/argument-1-M/index.html b/dev/containers/CCList/Traverse/argument-1-M/index.html new file mode 100644 index 00000000..221d9328 --- /dev/null +++ b/dev/containers/CCList/Traverse/argument-1-M/index.html @@ -0,0 +1,2 @@ + +M (containers.CCList.Traverse.1-M)

Parameter Traverse.1-M

type 'a t
val return : 'a -> 'a t

return is the Monadic return.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

(>>=) is the Monadic bind.

\ No newline at end of file diff --git a/dev/containers/CCList/Traverse/index.html b/dev/containers/CCList/Traverse/index.html new file mode 100644 index 00000000..b4cea588 --- /dev/null +++ b/dev/containers/CCList/Traverse/index.html @@ -0,0 +1,2 @@ + +Traverse (containers.CCList.Traverse)

Module CCList.Traverse

Monadic Traverse

This allows the traversal of a 'a t list where _ t is also a monad.

For example, a 'a option list will be traversed by extracting a value from each option, returning Some [x1;…;x_n]; but if one of the option is None then the whole result is None.

Another example is with result: ('a, 'err) result list can be transformed into ('a list, 'err) result by returning the first error, or Ok [x1; …; xn] if all the elements were successful.

This describes the behavior of sequence_m; map_m is a combination of map and sequence_m; map_m_par is like map_m but useful for some pseudo monads like Lwt.

Parameters

module M : MONAD

Signature

val sequence_m : 'a M.t t -> 'a t M.t

Traverse the list of monadic values using M.(>>=), re-combining elements with (::). See the documentation of the Traverse functor itself.

val fold_m : ( 'b -> 'a -> 'b M.t ) -> 'b -> 'a t -> 'b M.t

Fold a function with a monadic effect through a list.

val map_m : ( 'a -> 'b M.t ) -> 'a t -> 'b t M.t

Combination of map and sequence_m.

val map_m_par : ( 'a -> 'b M.t ) -> 'a t -> 'b t M.t

map_m_par f (x :: l) is like map_m but f x and f l are evaluated "in parallel" before combining their result (for instance in Lwt).

Basically, when encoutering x :: tl, this computes f x and map_m_par f tl, and only then is M.(>>=) used to combine the two results into a new list.

\ No newline at end of file diff --git a/dev/containers/CCList/module-type-MONAD/index.html b/dev/containers/CCList/module-type-MONAD/index.html new file mode 100644 index 00000000..1af44d41 --- /dev/null +++ b/dev/containers/CCList/module-type-MONAD/index.html @@ -0,0 +1,2 @@ + +MONAD (containers.CCList.MONAD)

Module type CCList.MONAD

Monadic Operations

type 'a t
val return : 'a -> 'a t

return is the Monadic return.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

(>>=) is the Monadic bind.

\ No newline at end of file diff --git a/dev/containers/CCListLabels/Assoc/index.html b/dev/containers/CCListLabels/Assoc/index.html new file mode 100644 index 00000000..4d635e72 --- /dev/null +++ b/dev/containers/CCListLabels/Assoc/index.html @@ -0,0 +1,7 @@ + +Assoc (containers.CCListLabels.Assoc)

Module CCListLabels.Assoc

type ('a, 'b) t = ('a * 'b) list
val get : eq:( 'a -> 'a -> bool ) -> 'a -> ( 'a, 'b ) t -> 'b option

get ~eq k alist returns Some v if the given key k is present into alist, or None if not present.

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

get_exn ~eq k alist returns v if the element k is present into alist. Like get, but unsafe.

  • raises Not_found

    if the element is not present.

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

set ~eq k v alist adds the binding k, v into the list alist (erase it if already present).

val mem : ?eq:( 'a -> 'a -> bool ) -> 'a -> ( 'a, _ ) t -> bool

mem ?eq k alist returns true iff k is a key in alist.

  • since 0.16
val update : + eq:( 'a -> 'a -> bool ) -> + f:( 'b option -> 'b option ) -> + 'a -> + ( 'a, 'b ) t -> + ( 'a, 'b ) t

update ~eq ~f k alist updates alist on the key k, by calling f (get alist k) and removing k if it returns None, mapping k to v' if it returns Some v'.

  • since 0.16
val remove : eq:( 'a -> 'a -> bool ) -> 'a -> ( 'a, 'b ) t -> ( 'a, 'b ) t

remove ~eq k alist returns the alist without the first pair with key k, if any.

  • since 0.17
val keys : ( 'a, 'b ) t -> 'a list

keys alist returns a list of all keys of alist.

  • since 3.8
val values : ( 'a, 'b ) t -> 'b list

values alist returns a list of all values of alist.

  • since 3.8
val map_values : ( 'b -> 'c ) -> ( 'a, 'b ) t -> ( 'a, 'c ) t

map_values f alist applies function f to all values of alist.

  • since 3.8
\ No newline at end of file diff --git a/dev/containers/CCListLabels/Infix/index.html b/dev/containers/CCListLabels/Infix/index.html new file mode 100644 index 00000000..b0829335 --- /dev/null +++ b/dev/containers/CCListLabels/Infix/index.html @@ -0,0 +1,9 @@ + +Infix (containers.CCListLabels.Infix)

Module CCListLabels.Infix

val (>|=) : 'a CCList.t -> ( 'a -> 'b ) -> 'b CCList.t

l >|= f is the infix version of map with reversed arguments.

val (@) : 'a CCList.t -> 'a CCList.t -> 'a CCList.t

l1 @ l2 concatenates two lists l1 and l2. As append.

val (<*>) : ( 'a -> 'b ) CCList.t -> 'a CCList.t -> 'b CCList.t

funs <*> l is product (fun f x -> f x) funs l.

val (<$>) : ( 'a -> 'b ) -> 'a CCList.t -> 'b CCList.t

f <$> l is like map.

val (>>=) : 'a CCList.t -> ( 'a -> 'b CCList.t ) -> 'b CCList.t

l >>= f is flat_map f l.

val (--) : int -> int -> int CCList.t

i -- j is the infix alias for range. Bounds included.

val (--^) : int -> int -> int CCList.t

i --^ j is the infix alias for range'. Second bound j excluded.

  • since 0.17
val let+ : 'a CCList.t -> ( 'a -> 'b ) -> 'b CCList.t
val and+ : 'a CCList.t -> 'b CCList.t -> ('a * 'b) CCList.t
val let* : 'a CCList.t -> ( 'a -> 'b CCList.t ) -> 'b CCList.t
val and* : 'a CCList.t -> 'b CCList.t -> ('a * 'b) CCList.t
val and& : 'a list -> 'b list -> ('a * 'b) list

(and&) is combine_shortest. It allows to perform a synchronized product between two lists, stopping gently at the shortest. Usable both with let+ and let*.

# let f xs ys zs =
+    let+ x = xs
+    and& y = ys
+    and& z = zs in
+    x + y + z;;
+val f : int list -> int list -> int list -> int list = <fun>
+# f [1;2] [5;6;7] [10;10];;
+- : int list = [16; 18]
  • since 3.1
\ No newline at end of file diff --git a/dev/containers/CCListLabels/Ref/index.html b/dev/containers/CCListLabels/Ref/index.html new file mode 100644 index 00000000..7a90a2ae --- /dev/null +++ b/dev/containers/CCListLabels/Ref/index.html @@ -0,0 +1,2 @@ + +Ref (containers.CCListLabels.Ref)

Module CCListLabels.Ref

type 'a t = 'a list Stdlib.ref
val push : 'a t -> 'a -> unit

push rlist e adds an element e at the head of rlist.

val pop : 'a t -> 'a option

pop rlist removes and returns Some e (the first element of rlist) or None if the rlist is empty

val pop_exn : 'a t -> 'a

pop_exn rlist removes and returns the first element of rlist. Unsafe version of pop.

  • raises Failure

    if the list is empty.

val create : unit -> 'a t

create () creates a new empty reference list.

val clear : _ t -> unit

clear rlist removes all elements of rlist.

val lift : ( 'a list -> 'b ) -> 'a t -> 'b

lift f rlist applies a list function f to the content of rlist.

val push_list : 'a t -> 'a list -> unit

push_list rlist l adds elements of the list l at the beginning of the list ref rlist. Elements at the end of the list l will be at the beginning of the list ref rlist.

\ No newline at end of file diff --git a/dev/containers/CCListLabels/Traverse/argument-1-M/index.html b/dev/containers/CCListLabels/Traverse/argument-1-M/index.html new file mode 100644 index 00000000..1d017ac3 --- /dev/null +++ b/dev/containers/CCListLabels/Traverse/argument-1-M/index.html @@ -0,0 +1,2 @@ + +M (containers.CCListLabels.Traverse.1-M)

Parameter Traverse.1-M

type 'a t
val return : 'a -> 'a t

return is the Monadic return.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

(>>=) is the Monadic bind.

\ No newline at end of file diff --git a/dev/containers/CCListLabels/Traverse/index.html b/dev/containers/CCListLabels/Traverse/index.html new file mode 100644 index 00000000..ad83b38e --- /dev/null +++ b/dev/containers/CCListLabels/Traverse/index.html @@ -0,0 +1,2 @@ + +Traverse (containers.CCListLabels.Traverse)

Module CCListLabels.Traverse

Parameters

module M : MONAD

Signature

val sequence_m : 'a M.t t -> 'a t M.t
val fold_m : f:( 'b -> 'a -> 'b M.t ) -> init:'b -> 'a t -> 'b M.t
val map_m : f:( 'a -> 'b M.t ) -> 'a t -> 'b t M.t
val map_m_par : f:( 'a -> 'b M.t ) -> 'a t -> 'b t M.t

map_m_par ~f (x :: l) is like map_m but f x and f l are evaluated "in parallel" before combining their result (for instance in Lwt).

\ No newline at end of file diff --git a/dev/containers/CCListLabels/module-type-MONAD/index.html b/dev/containers/CCListLabels/module-type-MONAD/index.html new file mode 100644 index 00000000..82a5abdb --- /dev/null +++ b/dev/containers/CCListLabels/module-type-MONAD/index.html @@ -0,0 +1,2 @@ + +MONAD (containers.CCListLabels.MONAD)

Module type CCListLabels.MONAD

Monadic Operations

type 'a t
val return : 'a -> 'a t

return is the Monadic return.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

(>>=) is the Monadic bind.

\ No newline at end of file diff --git a/dev/containers/CCMap/Make/index.html b/dev/containers/CCMap/Make/index.html new file mode 100644 index 00000000..8aba485a --- /dev/null +++ b/dev/containers/CCMap/Make/index.html @@ -0,0 +1,34 @@ + +Make (containers.CCMap.Make)

Module CCMap.Make

Parameters

module O : Stdlib.Map.OrderedType

Signature

include Stdlib.Map.S + with type 'a t = 'a Stdlib.Map.Make(O).t + with type key = O.t
type key = O.t
type 'a t = 'a Stdlib.Map.Make(O).t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge : + ( key -> 'a option -> 'b option -> 'c option ) -> + 'a t -> + 'b t -> + 'c t
val union : ( key -> 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t
val compare : ( 'a -> 'a -> int ) -> 'a t -> 'a t -> int
val equal : ( 'a -> 'a -> bool ) -> 'a t -> 'a t -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val for_all : ( key -> 'a -> bool ) -> 'a t -> bool
val exists : ( key -> 'a -> bool ) -> 'a t -> bool
val filter : ( key -> 'a -> bool ) -> 'a t -> 'a t
val filter_map : ( key -> 'a -> 'b option ) -> 'a t -> 'b t
val partition : ( key -> 'a -> bool ) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_last : ( key -> bool ) -> 'a t -> key * 'a
val find_last_opt : ( key -> bool ) -> 'a t -> (key * 'a) option
val map : ( 'a -> 'b ) -> 'a t -> 'b t
val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t
val get : key -> 'a t -> 'a option

get k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.

val get_or : key -> 'a t -> default:'a -> 'a

get_or k m ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in m).

  • since 0.16
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

update k f m calls f (Some v) if find k m = v, otherwise it calls f None. In any case, if the result is None k is removed from m, and if the result is Some v' then add k v' m is returned.

val choose_opt : 'a t -> (key * 'a) option

choose_opt m returns one binding of the given map m, or None if m is empty. Safe version of choose.

  • since 1.5
val min_binding_opt : 'a t -> (key * 'a) option

min_binding_opt m returns the smallest binding of the given map m, or None if m is empty. Safe version of min_binding.

  • since 1.5
val max_binding_opt : 'a t -> (key * 'a) option

max_binding_opt m returns the largest binding of the given map m, or None if m is empty. Safe version of max_binding.

  • since 1.5
val find_opt : key -> 'a t -> 'a option

find_opt k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.

  • since 1.5
val find_first : ( key -> bool ) -> 'a t -> key * 'a

find_first f m where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists. See Map.S.find_first.

  • since 1.5
val find_first_opt : ( key -> bool ) -> 'a t -> (key * 'a) option

find_first_opt f m where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists. Safe version of find_first.

  • since 1.5
val merge_safe : + f:( key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option ) -> + 'a t -> + 'b t -> + 'c t

merge_safe ~f a b merges the maps a and b together.

  • since 0.17
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t

add_seq m seq adds the given Seq.t of bindings to the map m. Like add_list. Renamed from add_std_seq since 3.0.

  • since 3.0
val add_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) Stdlib.Seq.t -> + 'a t

add_seq ~f m l adds the given seq l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t

of_seq seq builds a map from the given Seq.t of bindings. Like of_list. Renamed from of_std_seq since 3.0.

  • since 3.0
val of_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + (key * 'a) Stdlib.Seq.t -> + 'a t

of_seq_with ~f l builds a map from the given seq l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val add_iter : 'a t -> (key * 'a) iter -> 'a t

add_iter m iter adds the given iter of bindings to the map m. Like add_list.

  • since 2.8
val add_iter_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) iter -> + 'a t

add_iter ~f m l adds the given iter l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val of_iter : (key * 'a) iter -> 'a t

of_iter iter builds a map from the given iter of bindings. Like of_list.

  • since 2.8
val of_iter_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) iter -> 'a t

of_iter_with ~f l builds a map from the given iter l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the iter than v2.

  • since 3.3
val to_iter : 'a t -> (key * 'a) iter

to_iter m iterates on the whole map m, creating an iter of bindings. Like to_list.

  • since 2.8
val of_list : (key * 'a) list -> 'a t

of_list l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, only its last binding will be present in the result.

val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t

of_list_with ~f l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the list than v2.

  • since 3.3
val add_list : 'a t -> (key * 'a) list -> 'a t

add_list m l adds the given list l of bindings to the map m.

  • since 0.14
val add_list_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) list -> + 'a t

add_list ~f m l adds the given list l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val keys : _ t -> key iter

keys m iterates on the keys of m only, creating an iter of keys.

  • since 0.15
val values : 'a t -> 'a iter

values m iterates on the values of m only, creating an iter of values.

  • since 0.15
val to_list : 'a t -> (key * 'a) list

to_list m builds a list of the bindings of the given map m. The order is unspecified.

val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_arrow:unit printer -> + ?pp_sep:unit printer -> + key printer -> + 'a printer -> + 'a t printer

pp ?pp_start ?pp_stop ?pp_arrow ?pp_sep pp_key pp_v m pretty-prints the contents of the map.

\ No newline at end of file diff --git a/dev/containers/CCMap/module-type-S/index.html b/dev/containers/CCMap/module-type-S/index.html new file mode 100644 index 00000000..6c84b19a --- /dev/null +++ b/dev/containers/CCMap/module-type-S/index.html @@ -0,0 +1,32 @@ + +S (containers.CCMap.S)

Module type CCMap.S

include Stdlib.Map.S
type key
type !+'a t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge : + ( key -> 'a option -> 'b option -> 'c option ) -> + 'a t -> + 'b t -> + 'c t
val union : ( key -> 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t
val compare : ( 'a -> 'a -> int ) -> 'a t -> 'a t -> int
val equal : ( 'a -> 'a -> bool ) -> 'a t -> 'a t -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val for_all : ( key -> 'a -> bool ) -> 'a t -> bool
val exists : ( key -> 'a -> bool ) -> 'a t -> bool
val filter : ( key -> 'a -> bool ) -> 'a t -> 'a t
val filter_map : ( key -> 'a -> 'b option ) -> 'a t -> 'b t
val partition : ( key -> 'a -> bool ) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val max_binding : 'a t -> key * 'a
val choose : 'a t -> key * 'a
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_last : ( key -> bool ) -> 'a t -> key * 'a
val find_last_opt : ( key -> bool ) -> 'a t -> (key * 'a) option
val map : ( 'a -> 'b ) -> 'a t -> 'b t
val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t
val get : key -> 'a t -> 'a option

get k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.

val get_or : key -> 'a t -> default:'a -> 'a

get_or k m ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in m).

  • since 0.16
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t

update k f m calls f (Some v) if find k m = v, otherwise it calls f None. In any case, if the result is None k is removed from m, and if the result is Some v' then add k v' m is returned.

val choose_opt : 'a t -> (key * 'a) option

choose_opt m returns one binding of the given map m, or None if m is empty. Safe version of choose.

  • since 1.5
val min_binding_opt : 'a t -> (key * 'a) option

min_binding_opt m returns the smallest binding of the given map m, or None if m is empty. Safe version of min_binding.

  • since 1.5
val max_binding_opt : 'a t -> (key * 'a) option

max_binding_opt m returns the largest binding of the given map m, or None if m is empty. Safe version of max_binding.

  • since 1.5
val find_opt : key -> 'a t -> 'a option

find_opt k m returns Some v if the current binding of k in m is v, or None if the key k is not present. Safe version of find.

  • since 1.5
val find_first : ( key -> bool ) -> 'a t -> key * 'a

find_first f m where f is a monotonically increasing function, returns the binding of m with the lowest key k such that f k, or raises Not_found if no such key exists. See Map.S.find_first.

  • since 1.5
val find_first_opt : ( key -> bool ) -> 'a t -> (key * 'a) option

find_first_opt f m where f is a monotonically increasing function, returns an option containing the binding of m with the lowest key k such that f k, or None if no such key exists. Safe version of find_first.

  • since 1.5
val merge_safe : + f:( key -> [ `Left of 'a | `Right of 'b | `Both of 'a * 'b ] -> 'c option ) -> + 'a t -> + 'b t -> + 'c t

merge_safe ~f a b merges the maps a and b together.

  • since 0.17
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> 'a t

add_seq m seq adds the given Seq.t of bindings to the map m. Like add_list. Renamed from add_std_seq since 3.0.

  • since 3.0
val add_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) Stdlib.Seq.t -> + 'a t

add_seq ~f m l adds the given seq l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t

of_seq seq builds a map from the given Seq.t of bindings. Like of_list. Renamed from of_std_seq since 3.0.

  • since 3.0
val of_seq_with : + f:( key -> 'a -> 'a -> 'a ) -> + (key * 'a) Stdlib.Seq.t -> + 'a t

of_seq_with ~f l builds a map from the given seq l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val add_iter : 'a t -> (key * 'a) iter -> 'a t

add_iter m iter adds the given iter of bindings to the map m. Like add_list.

  • since 2.8
val add_iter_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) iter -> + 'a t

add_iter ~f m l adds the given iter l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val of_iter : (key * 'a) iter -> 'a t

of_iter iter builds a map from the given iter of bindings. Like of_list.

  • since 2.8
val of_iter_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) iter -> 'a t

of_iter_with ~f l builds a map from the given iter l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the iter than v2.

  • since 3.3
val to_iter : 'a t -> (key * 'a) iter

to_iter m iterates on the whole map m, creating an iter of bindings. Like to_list.

  • since 2.8
val of_list : (key * 'a) list -> 'a t

of_list l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, only its last binding will be present in the result.

val of_list_with : f:( key -> 'a -> 'a -> 'a ) -> (key * 'a) list -> 'a t

of_list_with ~f l builds a map from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the list than v2.

  • since 3.3
val add_list : 'a t -> (key * 'a) list -> 'a t

add_list m l adds the given list l of bindings to the map m.

  • since 0.14
val add_list_with : + f:( key -> 'a -> 'a -> 'a ) -> + 'a t -> + (key * 'a) list -> + 'a t

add_list ~f m l adds the given list l of bindings to the map m, using f to combine values that have the same key. If a key occurs several times, all its bindings are combined using the function f, with f key v1 v2 being called with v1 occurring later in the seq than v2.

  • since 3.3
val keys : _ t -> key iter

keys m iterates on the keys of m only, creating an iter of keys.

  • since 0.15
val values : 'a t -> 'a iter

values m iterates on the values of m only, creating an iter of values.

  • since 0.15
val to_list : 'a t -> (key * 'a) list

to_list m builds a list of the bindings of the given map m. The order is unspecified.

val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_arrow:unit printer -> + ?pp_sep:unit printer -> + key printer -> + 'a printer -> + 'a t printer

pp ?pp_start ?pp_stop ?pp_arrow ?pp_sep pp_key pp_v m pretty-prints the contents of the map.

\ No newline at end of file diff --git a/dev/containers/CCNativeint/Infix/index.html b/dev/containers/CCNativeint/Infix/index.html new file mode 100644 index 00000000..1463e75a --- /dev/null +++ b/dev/containers/CCNativeint/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCNativeint.Infix)

Module CCNativeint.Infix

val (+) : t -> t -> t

x + y is the sum of x and y. Addition.

val (-) : t -> t -> t

x - y is the difference of x and y. Subtraction.

val (~-) : t -> t

~- x is the negation of x. Unary negation.

val (*) : t -> t -> t

x * y is the product of x and y. Multiplication.

val (/) : t -> t -> t

x / y is the integer quotient of x and y. Integer division. Raise Division_by_zero if the second argument y is zero. This division rounds the real quotient of its arguments towards zero, as specified for Stdlib.(/).

val (mod) : t -> t -> t

x mod y is the integer remainder of x / y. If y <> zero, the result of x mod y satisfies the following properties: zero <= x mod y < abs y and x = ((x / y) * y) + (x mod y). If y = 0, x mod y raises Division_by_zero.

val (**) : t -> t -> t

Alias to pow

  • since 3.0
val (--) : t -> t -> t iter

Alias to range.

  • since 3.0
val (--^) : t -> t -> t iter

Alias to range'.

  • since 3.0
val (land) : t -> t -> t

x land y is the bitwise logical and of x and y.

val (lor) : t -> t -> t

x lor y is the bitwise logical or of x and y.

val (lxor) : t -> t -> t

x lxor y is the bitwise logical exclusive or of x and y.

val lnot : t -> t

lnot x is the bitwise logical negation of x (the bits of x are inverted).

val (lsl) : t -> int -> t

x lsl y shifts x to the left by y bits. The result is unspecified if y < 0 or y >= bitsize, where bitsize is 32 on a 32-bit platform and 64 on a 64-bit platform.

val (lsr) : t -> int -> t

x lsr y shifts x to the right by y bits. This is a logical shift: zeroes are inserted in the vacated bits regardless of the sign of x. The result is unspecified if y < 0 or y >= bitsize.

val (asr) : t -> int -> t

x asr y shifts x to the right by y bits. This is an arithmetic shift: the sign bit of x is replicated and inserted in the vacated bits. The result is unspecified if y < 0 or y >= bitsize.

val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<=) : t -> t -> bool
val (<) : t -> t -> bool
\ No newline at end of file diff --git a/dev/containers/CCOpt/Infix/index.html b/dev/containers/CCOpt/Infix/index.html new file mode 100644 index 00000000..70c7e2f7 --- /dev/null +++ b/dev/containers/CCOpt/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCOpt.Infix)

Module CCOpt.Infix

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

o >|= f is map f o.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

o >>= f is the monadic bind.

val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t

f <*> o returns Some (f x) if o is Some x and None if o is None.

val (<$>) : ( 'a -> 'b ) -> 'a t -> 'b t

f <$> o is like map f o.

val (<+>) : 'a t -> 'a t -> 'a t

o1 <+> o2 is o1 if o1 is Some _, o2 if o1 is None.

Let operators on OCaml >= 4.08.0, nothing otherwise

  • since 2.8
val let+ : 'a t -> ( 'a -> 'b ) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ( 'a -> 'b t ) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
\ No newline at end of file diff --git a/dev/containers/CCOption/Infix/index.html b/dev/containers/CCOption/Infix/index.html new file mode 100644 index 00000000..f91f967e --- /dev/null +++ b/dev/containers/CCOption/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCOption.Infix)

Module CCOption.Infix

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

o >|= f is map f o.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

o >>= f is the monadic bind.

val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t

f <*> o returns Some (f x) if o is Some x and None if o is None.

val (<$>) : ( 'a -> 'b ) -> 'a t -> 'b t

f <$> o is like map f o.

val (<+>) : 'a t -> 'a t -> 'a t

o1 <+> o2 is o1 if o1 is Some _, o2 if o1 is None.

Let operators on OCaml >= 4.08.0, nothing otherwise

  • since 2.8
val let+ : 'a t -> ( 'a -> 'b ) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ( 'a -> 'b t ) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
\ No newline at end of file diff --git a/dev/containers/CCOrd/Infix/index.html b/dev/containers/CCOrd/Infix/index.html new file mode 100644 index 00000000..b86156b7 --- /dev/null +++ b/dev/containers/CCOrd/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCOrd.Infix)

Module CCOrd.Infix

val (<?>) : int -> ('a t * 'a * 'a) -> int

c1 <?> (ord, x, y) returns the same as c1 if c1 is not 0; otherwise it uses ord to compare the two values x and y, of type 'a.

val (>|=) : 'b t -> ( 'a -> 'b ) -> 'a t

Infix equivalent of map.

\ No newline at end of file diff --git a/dev/containers/CCParse/Debug_/index.html b/dev/containers/CCParse/Debug_/index.html new file mode 100644 index 00000000..22417ad7 --- /dev/null +++ b/dev/containers/CCParse/Debug_/index.html @@ -0,0 +1,2 @@ + +Debug_ (containers.CCParse.Debug_)

Module CCParse.Debug_

Debugging utils. EXPERIMENTAL

val trace_fail : string -> 'a t -> 'a t

trace_fail name p behaves like p, but prints the error message of p on stderr whenever p fails.

  • parameter name

    used as a prefix of all trace messages.

val trace_success : string -> print:( 'a -> string ) -> 'a t -> 'a t

trace_success name ~print p behaves like p, but prints successful runs of p using print.

val trace_success_or_fail : string -> print:( 'a -> string ) -> 'a t -> 'a t

Trace both error or success

\ No newline at end of file diff --git a/dev/containers/CCParse/Error/index.html b/dev/containers/CCParse/Error/index.html new file mode 100644 index 00000000..678a5b6a --- /dev/null +++ b/dev/containers/CCParse/Error/index.html @@ -0,0 +1,2 @@ + +Error (containers.CCParse.Error)

Module CCParse.Error

Errors

type t

A parse error.

  • since 3.6
val position : t -> position

Returns position of the error

val line_and_column : t -> int * int

Line and column numbers of the error position.

val msg : t -> string
val to_string : t -> string

Prints the error

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

Pretty prints the error

\ No newline at end of file diff --git a/dev/containers/CCParse/Infix/index.html b/dev/containers/CCParse/Infix/index.html new file mode 100644 index 00000000..68e8842c --- /dev/null +++ b/dev/containers/CCParse/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCParse.Infix)

Module CCParse.Infix

val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t

Alias to map. p >|= f parses an item x using p, and returns f x.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

Alias to bind. p >>= f results in a new parser which behaves as p then, in case of success, applies f to the result.

val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t

Applicative.

val (<*) : 'a t -> _ t -> 'a t

a <* b parses a into x, parses b and ignores its result, and returns x.

val (*>) : _ t -> 'a t -> 'a t

a *> b parses a, then parses b into x, and returns x. The result of a is ignored.

val (<|>) : 'a t -> 'a t -> 'a t

Alias to or_.

a <|> b tries to parse a, and if a fails without consuming any input, backtracks and tries to parse b, otherwise it fails as a.

val (<?>) : 'a t -> string -> 'a t

a <?> msg behaves like a, but if a fails, a <?> msg fails with msg instead. Useful as the last choice in a series of <|>. For example: a <|> b <|> c <?> "expected one of a, b, c".

val (|||) : 'a t -> 'b t -> ('a * 'b) t

Alias to both. a ||| b parses a, then b, then returns the pair of their results.

  • since 3.6

Let operators on OCaml >= 4.08.0, nothing otherwise

  • since 2.8
val let+ : 'a t -> ( 'a -> 'b ) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ( 'a -> 'b t ) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
\ No newline at end of file diff --git a/dev/containers/CCParse/Position/index.html b/dev/containers/CCParse/Position/index.html new file mode 100644 index 00000000..d640b4c2 --- /dev/null +++ b/dev/containers/CCParse/Position/index.html @@ -0,0 +1,2 @@ + +Position (containers.CCParse.Position)

Module CCParse.Position

Positions in input

type t = position
val line : t -> int

Line number, 0 based

val column : t -> int

Column number, 0 based

val line_and_column : t -> int * int

Line and column number

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

Unspecified pretty-printed version of the position.

\ No newline at end of file diff --git a/dev/containers/CCParse/Slice/index.html b/dev/containers/CCParse/Slice/index.html new file mode 100644 index 00000000..741bef66 --- /dev/null +++ b/dev/containers/CCParse/Slice/index.html @@ -0,0 +1,2 @@ + +Slice (containers.CCParse.Slice)

Module CCParse.Slice

Functions on slices.

type t = slice
val is_empty : t -> bool

Is the slice empty?

val length : t -> int

Length of the slice

val to_string : t -> string

Convert the slice into a string. Linear time and memory in length slice

\ No newline at end of file diff --git a/dev/containers/CCParse/U/index.html b/dev/containers/CCParse/U/index.html new file mode 100644 index 00000000..42939e1c --- /dev/null +++ b/dev/containers/CCParse/U/index.html @@ -0,0 +1,15 @@ + +U (containers.CCParse.U)

Module CCParse.U

Utils

This is useful to parse OCaml-like values in a simple way. All the parsers are whitespace-insensitive (they skip whitespace).

val list : ?start:string -> ?stop:string -> ?sep:string -> 'a t -> 'a list t

list p parses a list of p, with the OCaml conventions for start token "[", stop token "]" and separator ";". Whitespace between items are skipped.

val int : int t

Parse an int in decimal representation.

val in_paren : 'a t -> 'a t

in_paren p parses an opening "(",p , and then ")".

  • since 3.6
val in_parens_opt : 'a t -> 'a t

in_parens_opt p parses p in an arbitrary number of nested parenthesis (possibly 0).

  • since 3.6
val option : 'a t -> 'a option t

option p parses "Some <x>" into Some x if p parses "<x>" into x, and parses "None" into None.

  • since 3.6
val hexa_int : int t

Parse an int int hexadecimal format. Accepts an optional 0x prefix, and ignores capitalization.

  • since 3.6
val word : string t

Non empty string of alpha num, start with alpha.

val bool : bool t

Accepts "true" or "false"

  • since 3.6
val pair : + ?start:string -> + ?stop:string -> + ?sep:string -> + 'a t -> + 'b t -> + ('a * 'b) t

Parse a pair using OCaml syntactic conventions. The default is "(a, b)".

val triple : + ?start:string -> + ?stop:string -> + ?sep:string -> + 'a t -> + 'b t -> + 'c t -> + ('a * 'b * 'c) t

Parse a triple using OCaml syntactic conventions. The default is "(a, b, c)".

\ No newline at end of file diff --git a/dev/containers/CCResult/Infix/index.html b/dev/containers/CCResult/Infix/index.html new file mode 100644 index 00000000..f7694ecc --- /dev/null +++ b/dev/containers/CCResult/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCResult.Infix)

Module CCResult.Infix

val (<$>) : ( 'a -> 'b ) -> ( 'a, 'err ) t -> ( 'b, 'err ) t

Infix version of map.

  • since 3.0
val (>|=) : ( 'a, 'err ) t -> ( 'a -> 'b ) -> ( 'b, 'err ) t

Infix version of map with reversed arguments.

val (>>=) : ( 'a, 'err ) t -> ( 'a -> ( 'b, 'err ) t ) -> ( 'b, 'err ) t

Monadic composition. e >>= f proceeds as f x if e is Ok x or returns e if e is an Error.

val (<*>) : ( 'a -> 'b, 'err ) t -> ( 'a, 'err ) t -> ( 'b, 'err ) t

a <*> b evaluates a and b, and, in case of success, returns Ok (a b). Otherwise, it fails, and the error of a is chosen over the error of b if both fail.

val let+ : ( 'a, 'e ) t -> ( 'a -> 'b ) -> ( 'b, 'e ) t
  • since 2.8
val and+ : ( 'a, 'e ) t -> ( 'b, 'e ) t -> ( 'a * 'b, 'e ) t
  • since 2.8
val let* : ( 'a, 'e ) t -> ( 'a -> ( 'b, 'e ) t ) -> ( 'b, 'e ) t
  • since 2.8
val and* : ( 'a, 'e ) t -> ( 'b, 'e ) t -> ( 'a * 'b, 'e ) t
  • since 2.8
\ No newline at end of file diff --git a/dev/containers/CCResult/Traverse/argument-1-M/index.html b/dev/containers/CCResult/Traverse/argument-1-M/index.html new file mode 100644 index 00000000..433e09f4 --- /dev/null +++ b/dev/containers/CCResult/Traverse/argument-1-M/index.html @@ -0,0 +1,2 @@ + +M (containers.CCResult.Traverse.1-M)

Parameter Traverse.1-M

type 'a t
val return : 'a -> 'a t

Monadic return.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

Monadic bind.

\ No newline at end of file diff --git a/dev/containers/CCResult/Traverse/index.html b/dev/containers/CCResult/Traverse/index.html new file mode 100644 index 00000000..c1c93ac4 --- /dev/null +++ b/dev/containers/CCResult/Traverse/index.html @@ -0,0 +1,2 @@ + +Traverse (containers.CCResult.Traverse)

Module CCResult.Traverse

Parameters

module M : MONAD

Signature

val sequence_m : ( 'a M.t, 'err ) t -> ( 'a, 'err ) t M.t
val fold_m : ( 'b -> 'a -> 'b M.t ) -> 'b -> ( 'a, 'err ) t -> 'b M.t
val map_m : ( 'a -> 'b M.t ) -> ( 'a, 'err ) t -> ( 'b, 'err ) t M.t
val retry_m : int -> ( unit -> ( 'a, 'err ) t M.t ) -> ( 'a, 'err list ) t M.t
\ No newline at end of file diff --git a/dev/containers/CCResult/module-type-MONAD/index.html b/dev/containers/CCResult/module-type-MONAD/index.html new file mode 100644 index 00000000..6e362612 --- /dev/null +++ b/dev/containers/CCResult/module-type-MONAD/index.html @@ -0,0 +1,2 @@ + +MONAD (containers.CCResult.MONAD)

Module type CCResult.MONAD

Monadic Operations

type 'a t
val return : 'a -> 'a t

Monadic return.

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t

Monadic bind.

\ No newline at end of file diff --git a/dev/containers/CCSeq/Infix/index.html b/dev/containers/CCSeq/Infix/index.html new file mode 100644 index 00000000..1a2855d9 --- /dev/null +++ b/dev/containers/CCSeq/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCSeq.Infix)

Module CCSeq.Infix

val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t
val (>|=) : 'a t -> ( 'a -> 'b ) -> 'b t
val (<*>) : ( 'a -> 'b ) t -> 'a t -> 'b t
val (>>-) : 'a t -> ( 'a -> 'b t ) -> 'b t
val (<.>) : ( 'a -> 'b ) t -> 'a t -> 'b t
val (--) : int -> int -> int t
val (--^) : int -> int -> int t
\ No newline at end of file diff --git a/dev/containers/CCSeq/Traverse/argument-1-M/index.html b/dev/containers/CCSeq/Traverse/argument-1-M/index.html new file mode 100644 index 00000000..c1c52b62 --- /dev/null +++ b/dev/containers/CCSeq/Traverse/argument-1-M/index.html @@ -0,0 +1,2 @@ + +M (containers.CCSeq.Traverse.1-M)

Parameter Traverse.1-M

type 'a t
val return : 'a -> 'a t
val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t
\ No newline at end of file diff --git a/dev/containers/CCSeq/Traverse/index.html b/dev/containers/CCSeq/Traverse/index.html new file mode 100644 index 00000000..2e0aa270 --- /dev/null +++ b/dev/containers/CCSeq/Traverse/index.html @@ -0,0 +1,2 @@ + +Traverse (containers.CCSeq.Traverse)

Module CCSeq.Traverse

Parameters

module M : MONAD

Signature

val sequence_m : 'a M.t t -> 'a t M.t
val fold_m : ( 'b -> 'a -> 'b M.t ) -> 'b -> 'a t -> 'b M.t
val map_m : ( 'a -> 'b M.t ) -> 'a t -> 'b t M.t
\ No newline at end of file diff --git a/dev/containers/CCSeq/module-type-MONAD/index.html b/dev/containers/CCSeq/module-type-MONAD/index.html new file mode 100644 index 00000000..43fbfc4f --- /dev/null +++ b/dev/containers/CCSeq/module-type-MONAD/index.html @@ -0,0 +1,2 @@ + +MONAD (containers.CCSeq.MONAD)

Module type CCSeq.MONAD

Monadic Operations

type 'a t
val return : 'a -> 'a t
val (>>=) : 'a t -> ( 'a -> 'b t ) -> 'b t
\ No newline at end of file diff --git a/dev/containers/CCSet/Make/index.html b/dev/containers/CCSet/Make/index.html new file mode 100644 index 00000000..eccf0044 --- /dev/null +++ b/dev/containers/CCSet/Make/index.html @@ -0,0 +1,13 @@ + +Make (containers.CCSet.Make)

Module CCSet.Make

Parameters

module O : Stdlib.Set.OrderedType

Signature

include Stdlib.Set.S with type t = Stdlib.Set.Make(O).t with type elt = O.t
type elt = O.t
type t = Stdlib.Set.Make(O).t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : ( elt -> unit ) -> t -> unit
val map : ( elt -> elt ) -> t -> t
val fold : ( elt -> 'a -> 'a ) -> t -> 'a -> 'a
val for_all : ( elt -> bool ) -> t -> bool
val exists : ( elt -> bool ) -> t -> bool
val filter : ( elt -> bool ) -> t -> t
val filter_map : ( elt -> elt option ) -> t -> t
val partition : ( elt -> bool ) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Stdlib.Seq.t
val to_seq : t -> elt Stdlib.Seq.t
val to_rev_seq : t -> elt Stdlib.Seq.t
val min_elt_opt : t -> elt option

Safe version of min_elt.

  • since 1.5
val max_elt_opt : t -> elt option

Safe version of max_elt.

  • since 1.5
val choose_opt : t -> elt option

Safe version of choose.

  • since 1.5
val find_opt : elt -> t -> elt option

Safe version of find.

  • since 1.5
val find_first : ( elt -> bool ) -> t -> elt

Find minimum element satisfying predicate.

  • since 1.5
val find_first_opt : ( elt -> bool ) -> t -> elt option

Safe version of find_first.

  • since 1.5
val find_last : ( elt -> bool ) -> t -> elt

Find maximum element satisfying predicate.

  • since 1.5
val find_last_opt : ( elt -> bool ) -> t -> elt option

Safe version of find_last.

  • since 1.5
val of_iter : elt iter -> t

Build a set from the given iter of elements.

  • since 2.8
val of_seq : elt Stdlib.Seq.t -> t

Build a set from the given seq of elements.

  • since 3.0
val add_iter : t -> elt iter -> t
  • since 2.8
val add_seq : elt Stdlib.Seq.t -> t -> t
  • since 3.0
val to_iter : t -> elt iter

to_iter t converts the set t to a iter of the elements.

  • since 2.8
val add_list : t -> elt list -> t
  • since 0.14
val to_list : t -> elt list

to_list t converts the set t to a list of the elements.

val to_string : + ?start:string -> + ?stop:string -> + ?sep:string -> + ( elt -> string ) -> + t -> + string

Print the set in a string

  • since 2.7
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + elt printer -> + t printer

Print the set.

\ No newline at end of file diff --git a/dev/containers/CCSet/module-type-S/index.html b/dev/containers/CCSet/module-type-S/index.html new file mode 100644 index 00000000..023f3ccf --- /dev/null +++ b/dev/containers/CCSet/module-type-S/index.html @@ -0,0 +1,13 @@ + +S (containers.CCSet.S)

Module type CCSet.S

include Stdlib.Set.S
type elt
type t
val empty : t
val is_empty : t -> bool
val mem : elt -> t -> bool
val add : elt -> t -> t
val singleton : elt -> t
val remove : elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val disjoint : t -> t -> bool
val diff : t -> t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val subset : t -> t -> bool
val iter : ( elt -> unit ) -> t -> unit
val map : ( elt -> elt ) -> t -> t
val fold : ( elt -> 'a -> 'a ) -> t -> 'a -> 'a
val for_all : ( elt -> bool ) -> t -> bool
val exists : ( elt -> bool ) -> t -> bool
val filter : ( elt -> bool ) -> t -> t
val filter_map : ( elt -> elt option ) -> t -> t
val partition : ( elt -> bool ) -> t -> t * t
val cardinal : t -> int
val elements : t -> elt list
val min_elt : t -> elt
val max_elt : t -> elt
val choose : t -> elt
val split : elt -> t -> t * bool * t
val find : elt -> t -> elt
val of_list : elt list -> t
val to_seq_from : elt -> t -> elt Stdlib.Seq.t
val to_seq : t -> elt Stdlib.Seq.t
val to_rev_seq : t -> elt Stdlib.Seq.t
val min_elt_opt : t -> elt option

Safe version of min_elt.

  • since 1.5
val max_elt_opt : t -> elt option

Safe version of max_elt.

  • since 1.5
val choose_opt : t -> elt option

Safe version of choose.

  • since 1.5
val find_opt : elt -> t -> elt option

Safe version of find.

  • since 1.5
val find_first : ( elt -> bool ) -> t -> elt

Find minimum element satisfying predicate.

  • since 1.5
val find_first_opt : ( elt -> bool ) -> t -> elt option

Safe version of find_first.

  • since 1.5
val find_last : ( elt -> bool ) -> t -> elt

Find maximum element satisfying predicate.

  • since 1.5
val find_last_opt : ( elt -> bool ) -> t -> elt option

Safe version of find_last.

  • since 1.5
val of_iter : elt iter -> t

Build a set from the given iter of elements.

  • since 2.8
val of_seq : elt Stdlib.Seq.t -> t

Build a set from the given seq of elements.

  • since 3.0
val add_iter : t -> elt iter -> t
  • since 2.8
val add_seq : elt Stdlib.Seq.t -> t -> t
  • since 3.0
val to_iter : t -> elt iter

to_iter t converts the set t to a iter of the elements.

  • since 2.8
val add_list : t -> elt list -> t
  • since 0.14
val to_list : t -> elt list

to_list t converts the set t to a list of the elements.

val to_string : + ?start:string -> + ?stop:string -> + ?sep:string -> + ( elt -> string ) -> + t -> + string

Print the set in a string

  • since 2.7
val pp : + ?pp_start:unit printer -> + ?pp_stop:unit printer -> + ?pp_sep:unit printer -> + elt printer -> + t printer

Print the set.

\ No newline at end of file diff --git a/dev/containers/CCSexp/Decoder/index.html b/dev/containers/CCSexp/Decoder/index.html new file mode 100644 index 00000000..78a0c0f0 --- /dev/null +++ b/dev/containers/CCSexp/Decoder/index.html @@ -0,0 +1,2 @@ + +Decoder (containers.CCSexp.Decoder)

Module CCSexp.Decoder

type t

Decoder

val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result

Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.

val to_list : t -> sexp list CCSexp_intf.or_error

Read all the values from this decoder.

  • since 2.8
val last_loc : t -> loc option

Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.

  • since 3.3
\ No newline at end of file diff --git a/dev/containers/CCSexp/Make/Decoder/index.html b/dev/containers/CCSexp/Make/Decoder/index.html new file mode 100644 index 00000000..4baa65bf --- /dev/null +++ b/dev/containers/CCSexp/Make/Decoder/index.html @@ -0,0 +1,2 @@ + +Decoder (containers.CCSexp.Make.Decoder)

Module Make.Decoder

type t

Decoder

val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result

Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.

val to_list : t -> sexp list CCSexp_intf.or_error

Read all the values from this decoder.

  • since 2.8
val last_loc : t -> loc option

Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.

  • since 3.3
\ No newline at end of file diff --git a/dev/containers/CCSexp/Make/argument-1-Sexp/index.html b/dev/containers/CCSexp/Make/argument-1-Sexp/index.html new file mode 100644 index 00000000..79b01c27 --- /dev/null +++ b/dev/containers/CCSexp/Make/argument-1-Sexp/index.html @@ -0,0 +1,2 @@ + +Sexp (containers.CCSexp.Make.1-Sexp)

Parameter Make.1-Sexp

include CCSexp_intf.BASIC_SEXP
type t
val atom : string -> t
val list : t list -> t
val match_ : t -> atom:( string -> 'a ) -> list:( t list -> 'a ) -> 'a
type loc
val make_loc : ( (int * int) -> (int * int) -> string -> loc ) option

If provided, builds a location from a pair of (line,column) positions, and a (possibly dummy) filename

val atom_with_loc : loc:loc -> string -> t
val list_with_loc : loc:loc -> t list -> t
\ No newline at end of file diff --git a/dev/containers/CCSexp/Make/index.html b/dev/containers/CCSexp/Make/index.html new file mode 100644 index 00000000..c6d25fa6 --- /dev/null +++ b/dev/containers/CCSexp/Make/index.html @@ -0,0 +1,4 @@ + +Make (containers.CCSexp.Make)

Module CCSexp.Make

Functorized operations

This builds a parser and printer for S-expressions represented as in the Sexp argument.

Parameters

module Sexp : SEXP

Signature

include CCSexp_intf.S0 with type t = Sexp.t
type t = Sexp.t
type sexp = t

Re-exports

val atom : string -> t

Make an atom out of this string.

  • since 2.8
val list : t list -> t

Make a Sexpr of this list.

  • since 2.8

Constructors

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

Reverse the list.

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

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

val of_field : string -> t -> t

Used to represent one record field.

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

Represent a record by its named fields.

Printing

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

Print the given iter of expressions to a file.

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

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

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

Raw, direct printing as compact as possible.

Parsing

val parse_string : string -> t CCSexp_intf.or_error

Parse a string.

val parse_string_list : string -> t list CCSexp_intf.or_error

Parse a string into a list of S-exprs.

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

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

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

Parse a channel into a generator of S-expressions.

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

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

val parse_file_list : string -> t list CCSexp_intf.or_error

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

type loc = Sexp.loc

Locations for the S-expressions.

  • since 3.3

Parsing

type 'a parse_result =
| Yield of 'a
| Fail of string
| End

A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.

module Decoder : sig ... end
\ No newline at end of file diff --git a/dev/containers/CCSexp_intf/module-type-BASIC_SEXP/index.html b/dev/containers/CCSexp_intf/module-type-BASIC_SEXP/index.html new file mode 100644 index 00000000..258a805f --- /dev/null +++ b/dev/containers/CCSexp_intf/module-type-BASIC_SEXP/index.html @@ -0,0 +1,2 @@ + +BASIC_SEXP (containers.CCSexp_intf.BASIC_SEXP)

Module type CCSexp_intf.BASIC_SEXP

Abstract representation of S-expressions

type t
val atom : string -> t
val list : t list -> t
val match_ : t -> atom:( string -> 'a ) -> list:( t list -> 'a ) -> 'a
\ No newline at end of file diff --git a/dev/containers/CCSexp_intf/module-type-S/Decoder/index.html b/dev/containers/CCSexp_intf/module-type-S/Decoder/index.html new file mode 100644 index 00000000..ad280bc6 --- /dev/null +++ b/dev/containers/CCSexp_intf/module-type-S/Decoder/index.html @@ -0,0 +1,2 @@ + +Decoder (containers.CCSexp_intf.S.Decoder)

Module S.Decoder

type t

Decoder

val of_lexbuf : Stdlib.Lexing.lexbuf -> t
val next : t -> sexp parse_result

Parse the next S-expression or return an error if the input isn't long enough or isn't a proper S-expression.

val to_list : t -> sexp list or_error

Read all the values from this decoder.

  • since 2.8
val last_loc : t -> loc option

Last location for the decoder. In particular, after calling next, this gives the location of the last token used in the result, which is useful in case of error.

  • since 3.3
\ No newline at end of file diff --git a/dev/containers/CCSexp_intf/module-type-S/index.html b/dev/containers/CCSexp_intf/module-type-S/index.html new file mode 100644 index 00000000..1586ffe6 --- /dev/null +++ b/dev/containers/CCSexp_intf/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers.CCSexp_intf.S)

Module type CCSexp_intf.S

Operations over S-expressions (extended)

include S0
type t
type sexp = t

Re-exports

val atom : string -> t

Make an atom out of this string.

  • since 2.8
val list : t list -> t

Make a Sexpr of this list.

  • since 2.8

Constructors

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

Reverse the list.

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

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

val of_field : string -> t -> t

Used to represent one record field.

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

Represent a record by its named fields.

Printing

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

Print the given iter of expressions to a file.

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

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

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

Raw, direct printing as compact as possible.

Parsing

val parse_string : string -> t or_error

Parse a string.

val parse_string_list : string -> t list or_error

Parse a string into a list of S-exprs.

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

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

val parse_chan_gen : Stdlib.in_channel -> t or_error gen

Parse a channel into a generator of S-expressions.

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

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

val parse_file_list : string -> t list or_error

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

type loc

Locations for the S-expressions.

  • since 3.3

Parsing

type 'a parse_result =
| Yield of 'a
| Fail of string
| End

A parser of 'a can return Yield x when it parsed a value, or Fail e when a parse error was encountered, or End if the input was empty.

module Decoder : sig ... end
\ No newline at end of file diff --git a/dev/containers/CCSexp_intf/module-type-S0/index.html b/dev/containers/CCSexp_intf/module-type-S0/index.html new file mode 100644 index 00000000..a27c8047 --- /dev/null +++ b/dev/containers/CCSexp_intf/module-type-S0/index.html @@ -0,0 +1,2 @@ + +S0 (containers.CCSexp_intf.S0)

Module type CCSexp_intf.S0

Operations over S-expressions

type t
type sexp = t

Re-exports

val atom : string -> t

Make an atom out of this string.

  • since 2.8
val list : t list -> t

Make a Sexpr of this list.

  • since 2.8

Constructors

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

Reverse the list.

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

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

val of_field : string -> t -> t

Used to represent one record field.

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

Represent a record by its named fields.

Printing

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

Print the given iter of expressions to a file.

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

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

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

Raw, direct printing as compact as possible.

Parsing

val parse_string : string -> t or_error

Parse a string.

val parse_string_list : string -> t list or_error

Parse a string into a list of S-exprs.

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

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

val parse_chan_gen : Stdlib.in_channel -> t or_error gen

Parse a channel into a generator of S-expressions.

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

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

val parse_file_list : string -> t list or_error

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

\ No newline at end of file diff --git a/dev/containers/CCSexp_intf/module-type-SEXP/index.html b/dev/containers/CCSexp_intf/module-type-SEXP/index.html new file mode 100644 index 00000000..856860f4 --- /dev/null +++ b/dev/containers/CCSexp_intf/module-type-SEXP/index.html @@ -0,0 +1,2 @@ + +SEXP (containers.CCSexp_intf.SEXP)

Module type CCSexp_intf.SEXP

Abstract representation of S-expressions (extended)

include BASIC_SEXP
type t
val atom : string -> t
val list : t list -> t
val match_ : t -> atom:( string -> 'a ) -> list:( t list -> 'a ) -> 'a
type loc
val make_loc : ( (int * int) -> (int * int) -> string -> loc ) option

If provided, builds a location from a pair of (line,column) positions, and a (possibly dummy) filename

val atom_with_loc : loc:loc -> string -> t
val list_with_loc : loc:loc -> t list -> t
\ No newline at end of file diff --git a/dev/containers/CCShims_syntax/module-type-LET/index.html b/dev/containers/CCShims_syntax/module-type-LET/index.html new file mode 100644 index 00000000..9e9a43c4 --- /dev/null +++ b/dev/containers/CCShims_syntax/module-type-LET/index.html @@ -0,0 +1,2 @@ + +LET (containers.CCShims_syntax.LET)

Module type CCShims_syntax.LET

Let operators on OCaml >= 4.08.0, nothing otherwise

type 'a t
val let+ : 'a t -> ( 'a -> 'b ) -> 'b t
val and+ : 'a t -> 'b t -> ('a * 'b) t
val let* : 'a t -> ( 'a -> 'b t ) -> 'b t
val and* : 'a t -> 'b t -> ('a * 'b) t
\ No newline at end of file diff --git a/dev/containers/CCString/Find/index.html b/dev/containers/CCString/Find/index.html new file mode 100644 index 00000000..0495186f --- /dev/null +++ b/dev/containers/CCString/Find/index.html @@ -0,0 +1,2 @@ + +Find (containers.CCString.Find)

Module CCString.Find

type _ pattern
val compile : string -> [ `Direct ] pattern
val rcompile : string -> [ `Reverse ] pattern
val find : ?start:int -> pattern:[ `Direct ] pattern -> string -> int

find ~start ~pattern s searches for pattern in the string s, left-to-right.

  • returns

    the offset of the first match, -1 otherwise.

  • parameter start

    offset in string at which we start.

val rfind : ?start:int -> pattern:[ `Reverse ] pattern -> string -> int

rfind ~start ~pattern s searches for pattern in the string s, right-to-left.

  • returns

    the offset of the start of the first match from the right, -1 otherwise.

  • parameter start

    right-offset in string at which we start.

\ No newline at end of file diff --git a/dev/containers/CCString/Infix/index.html b/dev/containers/CCString/Infix/index.html new file mode 100644 index 00000000..37ac3cfe --- /dev/null +++ b/dev/containers/CCString/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCString.Infix)

Module CCString.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/CCString/Split/index.html b/dev/containers/CCString/Split/index.html new file mode 100644 index 00000000..f56dc8bb --- /dev/null +++ b/dev/containers/CCString/Split/index.html @@ -0,0 +1,18 @@ + +Split (containers.CCString.Split)

Module CCString.Split

type drop_if_empty = {
first : bool;
last : bool;
}

Specification of what to do with empty blocks, as in split ~by:"-" "-a-b-".

  • {first=false; last=false} will return ""; "a"; "b"; ""
  • {first=true; last=false} will return "a"; "b" ""
  • {first=false; last=true} will return ""; "a"; "b"
  • {first=true; last=true} will return "a"; "b"

The default value of all remaining functions is Drop_none.

  • since 1.5
val no_drop : drop_if_empty

no_drop does not drop any group, even empty and on borders.

  • since 1.5
val list_ : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) list

list_ ~drop ~by s splits the given string s along the given separator by. Should only be used with very small separators, otherwise use Containers_string.KMP.

  • returns

    a list of slices (s,index,length) that are separated by by. String.sub can then be used to actually extract a string from the slice.

  • raises Failure

    if by = "".

val gen : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) gen

gen ~drop ~by s splits the given string s along the given separator by. Returns a gen of slices.

val iter : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) iter

iter ~drop ~by s splits the given string s along the given separator by. Returns an iter of slices.

  • since 2.8
val seq : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) Stdlib.Seq.t

seq ~drop ~by s splits the given string s along the given separator by. Returns a Seq.t of slices. Renamed from std_seq since 3.0.

  • since 3.0
Copying functions

Those split functions actually copy the substrings, which can be more convenient but less efficient in general.

val list_cpy : ?drop:drop_if_empty -> by:string -> string -> string list

list_cpy ~drop ~by s splits the given string s along the given separator by. Returns a list of strings.

val gen_cpy : ?drop:drop_if_empty -> by:string -> string -> string gen

gen_cpy ~drop ~by s splits the given string s along the given separator by. Returns a gen of strings.

val iter_cpy : ?drop:drop_if_empty -> by:string -> string -> string iter

iter_cpy ~drop ~by s splits the given string s along the given separator by. Returns an iter of strings.

  • since 2.8
val seq_cpy : ?drop:drop_if_empty -> by:string -> string -> string Stdlib.Seq.t

seq_cpy ~drop ~by s splits the given string s along the given separator by. Returns a Seq.t of strings. Renamed from std_seq_cpy since 3.0.

  • since 3.0
val left : by:string -> string -> (string * string) option

left ~by s splits on the first occurrence of by from the leftmost part of the string s.

  • since 0.12
val left_exn : by:string -> string -> string * string

left_exn ~by s splits on the first occurrence of by from the leftmost part of the string s.

  • raises Not_found

    if by is not part of the string s.

  • since 0.16
val right : by:string -> string -> (string * string) option

right ~by s splits on the first occurrence of by from the rightmost part of the string s.

  • since 0.12
val right_exn : by:string -> string -> string * string

right_exn ~by s splits on the first occurrence of by from the rightmost part of the string s.

  • raises Not_found

    if by is not part of the string s.

  • since 0.16
\ No newline at end of file diff --git a/dev/containers/CCStringLabels/Find/index.html b/dev/containers/CCStringLabels/Find/index.html new file mode 100644 index 00000000..c557c26b --- /dev/null +++ b/dev/containers/CCStringLabels/Find/index.html @@ -0,0 +1,2 @@ + +Find (containers.CCStringLabels.Find)

Module CCStringLabels.Find

type _ pattern
val compile : string -> [ `Direct ] pattern
val rcompile : string -> [ `Reverse ] pattern
val find : ?start:int -> pattern:[ `Direct ] pattern -> string -> int

find ?start ~pattern s searches for pattern in the string s, left-to-right.

  • returns

    the offset of the first match, -1 otherwise.

  • parameter start

    offset in string at which we start.

val rfind : ?start:int -> pattern:[ `Reverse ] pattern -> string -> int

rfind ?start ~pattern s searches for pattern in the string s, right-to-left.

  • returns

    the offset of the start of the first match from the right, -1 otherwise.

  • parameter start

    right-offset in string at which we start.

\ No newline at end of file diff --git a/dev/containers/CCStringLabels/Infix/index.html b/dev/containers/CCStringLabels/Infix/index.html new file mode 100644 index 00000000..d8067fdc --- /dev/null +++ b/dev/containers/CCStringLabels/Infix/index.html @@ -0,0 +1,2 @@ + +Infix (containers.CCStringLabels.Infix)

Module CCStringLabels.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/Split/index.html b/dev/containers/CCStringLabels/Split/index.html new file mode 100644 index 00000000..bd231816 --- /dev/null +++ b/dev/containers/CCStringLabels/Split/index.html @@ -0,0 +1,18 @@ + +Split (containers.CCStringLabels.Split)

Module CCStringLabels.Split

type drop_if_empty = {
first : bool;
last : bool;
}

Specification of what to do with empty blocks, as in split ~by:"-" "-a-b-".

  • {first=false; last=false} will return ""; "a"; "b"; ""
  • {first=true; last=false} will return "a"; "b" ""
  • {first=false; last=true} will return ""; "a"; "b"
  • {first=true; last=true} will return "a"; "b"

The default value of all remaining functions is Drop_none.

  • since 1.5
val no_drop : drop_if_empty

no_drop does not drop any group, even empty and on borders.

  • since 1.5
val list_ : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) list

list_ ?drop ~by s splits the given string s along the given separator by. Should only be used with very small separators, otherwise use Containers_string.KMP.

  • returns

    a list of slices (s,index,length) that are separated by by. String.sub can then be used to actually extract a string from the slice.

  • raises Failure

    if by = "".

val gen : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) gen

gen ?drop ~by s splits the given string s along the given separator by. Returns a gen of slices.

val iter : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) iter

iter ?drop ~by s splits the given string s along the given separator by. Returns an iter of slices.

  • since 2.8
val seq : + ?drop:drop_if_empty -> + by:string -> + string -> + (string * int * int) Stdlib.Seq.t

seq ?drop ~by s splits the given string s along the given separator by. Returns a Seq.t of slices. Renamed from std_seq since 3.0.

  • since 3.0
Copying functions

Those split functions actually copy the substrings, which can be more convenient but less efficient in general.

val list_cpy : ?drop:drop_if_empty -> by:string -> string -> string list

list_cpy ?drop ~by s splits the given string s along the given separator by. Returns a list of strings.

val gen_cpy : ?drop:drop_if_empty -> by:string -> string -> string gen

gen_cpy ?drop ~by s splits the given string s along the given separator by. Returns a gen of strings.

val iter_cpy : ?drop:drop_if_empty -> by:string -> string -> string iter

iter_cpy ?drop ~by s splits the given string s along the given separator by. Returns an iter of strings.

  • since 2.8
val seq_cpy : ?drop:drop_if_empty -> by:string -> string -> string Stdlib.Seq.t

seq_cpy ?drop ~by s splits the given string s along the given separator by. Returns a Seq.t of strings. Renamed from std_seq_cpy since 3.0.

  • since 3.0
val left : by:string -> string -> (string * string) option

left ~by s splits on the first occurrence of by from the leftmost part of the string s.

  • since 0.12
val left_exn : by:string -> string -> string * string

left_exn ~by s splits on the first occurrence of by from the leftmost part of the string s.

  • raises Not_found

    if by is not part of the string s.

  • since 0.16
val right : by:string -> string -> (string * string) option

right ~by s splits on the first occurrence of by from the rightmost part of the string s.

  • since 0.12
val right_exn : by:string -> string -> string * string

right_exn ~by s splits on the first occurrence of by from the rightmost part of the string s.

  • raises Not_found

    if by is not part of the string s.

  • since 0.16
\ No newline at end of file diff --git a/dev/containers/CCUnix/Infix/index.html b/dev/containers/CCUnix/Infix/index.html new file mode 100644 index 00000000..a9824809 --- /dev/null +++ b/dev/containers/CCUnix/Infix/index.html @@ -0,0 +1,4 @@ + +Infix (containers.CCUnix.Infix)

Module CCUnix.Infix

val (?|) : ( 'a, Stdlib.Buffer.t, unit, call_result ) Stdlib.format4 -> 'a

Infix version of call.

  • since 0.11
val (?|&) : + ( 'a, Stdlib.Buffer.t, unit, async_call_result ) Stdlib.format4 -> + 'a

Infix version of async_call.

  • since 0.11
\ No newline at end of file diff --git a/dev/containers/Containers/Hashtbl/Make/index.html b/dev/containers/Containers/Hashtbl/Make/index.html new file mode 100644 index 00000000..68082fcf --- /dev/null +++ b/dev/containers/Containers/Hashtbl/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers.Containers.Hashtbl.Make)

Module Hashtbl.Make

Parameters

module H : Stdlib__Hashtbl.HashedType

Signature

type key = H.t
type !'a t = 'a Stdlib__Hashtbl.Make(H).t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib__Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/Containers/Hashtbl/MakeSeeded/index.html b/dev/containers/Containers/Hashtbl/MakeSeeded/index.html new file mode 100644 index 00000000..3ce331c5 --- /dev/null +++ b/dev/containers/Containers/Hashtbl/MakeSeeded/index.html @@ -0,0 +1,2 @@ + +MakeSeeded (containers.Containers.Hashtbl.MakeSeeded)

Module Hashtbl.MakeSeeded

Parameters

module H : SeededHashedType

Signature

type key = H.t
type !'a t = 'a Stdlib__Hashtbl.MakeSeeded(H).t
val create : ?random:bool -> int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/Containers/Hashtbl/index.html b/dev/containers/Containers/Hashtbl/index.html new file mode 100644 index 00000000..c6205a8d --- /dev/null +++ b/dev/containers/Containers/Hashtbl/index.html @@ -0,0 +1,33 @@ + +Hashtbl (containers.Containers.Hashtbl)

Module Containers.Hashtbl

include module type of Stdlib.Hashtbl + with type statistics = Stdlib.Hashtbl.statistics + and module Make = Stdlib.Hashtbl.Make + and type ('a, 'b) t = ( 'a, 'b ) Stdlib.Hashtbl.t
type (!'a0, !'b0) t = ( 'a, 'b ) Stdlib.Hashtbl.t
val create : ?random:bool -> int -> ( 'a, 'b ) t
val clear : ( 'a, 'b ) t -> unit
val reset : ( 'a, 'b ) t -> unit
val copy : ( 'a, 'b ) t -> ( 'a, 'b ) t
val add : ( 'a, 'b ) t -> 'a -> 'b -> unit
val find : ( 'a, 'b ) t -> 'a -> 'b
val find_opt : ( 'a, 'b ) t -> 'a -> 'b option
val find_all : ( 'a, 'b ) t -> 'a -> 'b list
val mem : ( 'a, 'b ) t -> 'a -> bool
val remove : ( 'a, 'b ) t -> 'a -> unit
val replace : ( 'a, 'b ) t -> 'a -> 'b -> unit
val iter : ( 'a -> 'b -> unit ) -> ( 'a, 'b ) t -> unit
val filter_map_inplace : ( 'a -> 'b -> 'b option ) -> ( 'a, 'b ) t -> unit
val fold : ( 'a -> 'b -> 'c -> 'c ) -> ( 'a, 'b ) t -> 'c -> 'c
val length : ( 'a, 'b ) t -> int
val randomize : unit -> unit
val is_randomized : unit -> bool
val rebuild : ?random:bool -> ( 'a, 'b ) t -> ( 'a, 'b ) t
type statistics = Stdlib.Hashtbl.statistics = {
num_bindings : int;
num_buckets : int;
max_bucket_length : int;
bucket_histogram : int array;
}
val stats : ( 'a, 'b ) t -> statistics
val to_seq : ( 'a, 'b ) t -> ('a * 'b) Stdlib.Seq.t
val to_seq_keys : ( 'a, 'b ) t -> 'a Stdlib.Seq.t
val to_seq_values : ( 'a, 'b ) t -> 'b Stdlib.Seq.t
val replace_seq : ( 'a, 'b ) t -> ('a * 'b) Stdlib.Seq.t -> unit
module type HashedType = sig ... end
module type S = sig ... end
module Make (H : Stdlib__Hashtbl.HashedType) : sig ... end
module type SeededHashedType = sig ... end
module type SeededS = sig ... end
module MakeSeeded (H : SeededHashedType) : sig ... end
val hash : 'a -> int
val seeded_hash : int -> 'a -> int
val hash_param : int -> int -> 'a -> int
val seeded_hash_param : int -> int -> int -> 'a -> int
include module type of struct include CCHashtbl.Poly end
val get : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a -> 'b option

get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.

val get_or : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b

get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).

  • since 0.16
val keys : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter

keys tbl f iterates on keys (similar order as Hashtbl.iter).

val values : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'b CCHashtbl.iter

values tbl f iterates on values in the table tbl.

val keys_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a list

keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.

  • since 0.8
val values_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'b list

values_list tbl is the list of values in tbl.

  • since 0.8
val map_list : ( 'a -> 'b -> 'c ) -> ( 'a, 'b ) Stdlib.Hashtbl.t -> 'c list

map_list f tbl maps on a tbl's items. Collect into a list.

val incr : ?by:int -> ( 'a, int ) Stdlib.Hashtbl.t -> 'a -> unit

incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).

  • parameter by

    if specified, the int value is incremented by by rather than 1.

  • since 0.16
val decr : ?by:int -> ( 'a, int ) Stdlib.Hashtbl.t -> 'a -> unit

decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.

  • since 0.16
val to_iter : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter

Iterate on bindings in the table.

  • since 2.8
val add_list : ( 'a, 'b list ) Stdlib.Hashtbl.t -> 'a -> 'b -> unit

add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.

  • since 0.16
val add_iter : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit

Add the corresponding pairs to the table, using Hashtbl.add.

  • since 2.8
val add_iter_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ( 'a, 'b ) Stdlib.Hashtbl.t -> + ('a * 'b) CCHashtbl.iter -> + unit

Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_seq : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit

Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.

  • since 3.0
val add_seq_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ( 'a, 'b ) Stdlib.Hashtbl.t -> + ('a * 'b) Stdlib.Seq.t -> + unit

Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_iter : ('a * 'b) CCHashtbl.iter -> ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order.

  • since 2.8
val of_iter_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) CCHashtbl.iter -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_seq : ('a * 'b) Stdlib.Seq.t -> ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. Renamed from of_std_seq since 3.0.

  • since 3.0
val of_seq_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) Stdlib.Seq.t -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_iter_count : ( 'a, int ) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter -> unit

add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.

  • since 2.8
val add_seq_count : ( 'a, int ) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit

add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.

  • since 3.0
val of_iter_count : 'a CCHashtbl.iter -> ( 'a, int ) Stdlib.Hashtbl.t

Like add_seq_count, but allocates a new table and returns it.

  • since 2.8
val of_seq_count : 'a Stdlib.Seq.t -> ( 'a, int ) Stdlib.Hashtbl.t

Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.

  • since 3.0
val to_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) list

to_list tbl returns the list of (key,value) bindings (order unspecified).

val of_list : ('a * 'b) list -> ( 'a, 'b ) Stdlib.Hashtbl.t

of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.

val of_list_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) list -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val update : + ( 'a, 'b ) Stdlib.Hashtbl.t -> + f:( 'a -> 'b option -> 'b option ) -> + k:'a -> + unit

update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.

  • since 0.14
val get_or_add : ( 'a, 'b ) Stdlib.Hashtbl.t -> f:( 'a -> 'b ) -> k:'a -> 'b

get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.

  • since 1.0
val pp : + ?pp_start:unit CCHashtbl.printer -> + ?pp_stop:unit CCHashtbl.printer -> + ?pp_sep:unit CCHashtbl.printer -> + ?pp_arrow:unit CCHashtbl.printer -> + 'a CCHashtbl.printer -> + 'b CCHashtbl.printer -> + ( 'a, 'b ) Stdlib.Hashtbl.t CCHashtbl.printer

pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.

  • since 0.13
module type S' = CCHashtbl.S
module Make' = CCHashtbl.Make
\ No newline at end of file diff --git a/dev/containers/Containers/Hashtbl/module-type-HashedType/index.html b/dev/containers/Containers/Hashtbl/module-type-HashedType/index.html new file mode 100644 index 00000000..7882dbde --- /dev/null +++ b/dev/containers/Containers/Hashtbl/module-type-HashedType/index.html @@ -0,0 +1,2 @@ + +HashedType (containers.Containers.Hashtbl.HashedType)

Module type Hashtbl.HashedType

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file diff --git a/dev/containers/Containers/Hashtbl/module-type-S/index.html b/dev/containers/Containers/Hashtbl/module-type-S/index.html new file mode 100644 index 00000000..8c4974be --- /dev/null +++ b/dev/containers/Containers/Hashtbl/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers.Containers.Hashtbl.S)

Module type Hashtbl.S

type key
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/Containers/Hashtbl/module-type-SeededHashedType/index.html b/dev/containers/Containers/Hashtbl/module-type-SeededHashedType/index.html new file mode 100644 index 00000000..7e00f800 --- /dev/null +++ b/dev/containers/Containers/Hashtbl/module-type-SeededHashedType/index.html @@ -0,0 +1,2 @@ + +SeededHashedType (containers.Containers.Hashtbl.SeededHashedType)

Module type Hashtbl.SeededHashedType

type t
val equal : t -> t -> bool
val hash : int -> t -> int
\ No newline at end of file diff --git a/dev/containers/Containers/Hashtbl/module-type-SeededS/index.html b/dev/containers/Containers/Hashtbl/module-type-SeededS/index.html new file mode 100644 index 00000000..63ac40b3 --- /dev/null +++ b/dev/containers/Containers/Hashtbl/module-type-SeededS/index.html @@ -0,0 +1,2 @@ + +SeededS (containers.Containers.Hashtbl.SeededS)

Module type Hashtbl.SeededS

type key
type !'a t
val create : ?random:bool -> int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/ContainersLabels/Hashtbl/Make/index.html b/dev/containers/ContainersLabels/Hashtbl/Make/index.html new file mode 100644 index 00000000..04823a7b --- /dev/null +++ b/dev/containers/ContainersLabels/Hashtbl/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers.ContainersLabels.Hashtbl.Make)

Module Hashtbl.Make

Parameters

module H : Stdlib__Hashtbl.HashedType

Signature

type key = H.t
type !'a t = 'a Stdlib__Hashtbl.Make(H).t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> Stdlib__Hashtbl.statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/ContainersLabels/Hashtbl/MakeSeeded/index.html b/dev/containers/ContainersLabels/Hashtbl/MakeSeeded/index.html new file mode 100644 index 00000000..42691ae8 --- /dev/null +++ b/dev/containers/ContainersLabels/Hashtbl/MakeSeeded/index.html @@ -0,0 +1,2 @@ + +MakeSeeded (containers.ContainersLabels.Hashtbl.MakeSeeded)

Module Hashtbl.MakeSeeded

Parameters

module H : SeededHashedType

Signature

type key = H.t
type !'a t = 'a Stdlib__Hashtbl.MakeSeeded(H).t
val create : ?random:bool -> int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/ContainersLabels/Hashtbl/index.html b/dev/containers/ContainersLabels/Hashtbl/index.html new file mode 100644 index 00000000..12eaa84f --- /dev/null +++ b/dev/containers/ContainersLabels/Hashtbl/index.html @@ -0,0 +1,33 @@ + +Hashtbl (containers.ContainersLabels.Hashtbl)

Module ContainersLabels.Hashtbl

include module type of Stdlib.Hashtbl + with type statistics = Stdlib.Hashtbl.statistics + and module Make = Stdlib.Hashtbl.Make + and type ('a, 'b) t = ( 'a, 'b ) Stdlib.Hashtbl.t
type (!'a0, !'b0) t = ( 'a, 'b ) Stdlib.Hashtbl.t
val create : ?random:bool -> int -> ( 'a, 'b ) t
val clear : ( 'a, 'b ) t -> unit
val reset : ( 'a, 'b ) t -> unit
val copy : ( 'a, 'b ) t -> ( 'a, 'b ) t
val add : ( 'a, 'b ) t -> 'a -> 'b -> unit
val find : ( 'a, 'b ) t -> 'a -> 'b
val find_opt : ( 'a, 'b ) t -> 'a -> 'b option
val find_all : ( 'a, 'b ) t -> 'a -> 'b list
val mem : ( 'a, 'b ) t -> 'a -> bool
val remove : ( 'a, 'b ) t -> 'a -> unit
val replace : ( 'a, 'b ) t -> 'a -> 'b -> unit
val iter : ( 'a -> 'b -> unit ) -> ( 'a, 'b ) t -> unit
val filter_map_inplace : ( 'a -> 'b -> 'b option ) -> ( 'a, 'b ) t -> unit
val fold : ( 'a -> 'b -> 'c -> 'c ) -> ( 'a, 'b ) t -> 'c -> 'c
val length : ( 'a, 'b ) t -> int
val randomize : unit -> unit
val is_randomized : unit -> bool
val rebuild : ?random:bool -> ( 'a, 'b ) t -> ( 'a, 'b ) t
type statistics = Stdlib.Hashtbl.statistics = {
num_bindings : int;
num_buckets : int;
max_bucket_length : int;
bucket_histogram : int array;
}
val stats : ( 'a, 'b ) t -> statistics
val to_seq : ( 'a, 'b ) t -> ('a * 'b) Stdlib.Seq.t
val to_seq_keys : ( 'a, 'b ) t -> 'a Stdlib.Seq.t
val to_seq_values : ( 'a, 'b ) t -> 'b Stdlib.Seq.t
val replace_seq : ( 'a, 'b ) t -> ('a * 'b) Stdlib.Seq.t -> unit
module type HashedType = sig ... end
module type S = sig ... end
module Make (H : Stdlib__Hashtbl.HashedType) : sig ... end
module type SeededHashedType = sig ... end
module type SeededS = sig ... end
module MakeSeeded (H : SeededHashedType) : sig ... end
val hash : 'a -> int
val seeded_hash : int -> 'a -> int
val hash_param : int -> int -> 'a -> int
val seeded_hash_param : int -> int -> int -> 'a -> int
include module type of struct include CCHashtbl.Poly end
val get : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a -> 'b option

get tbl k finds a binding for the key k if present, or returns None if no value is found. Safe version of Hashtbl.find.

val get_or : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a -> default:'b -> 'b

get_or tbl k ~default returns the value associated to k if present, and returns default otherwise (if k doesn't belong in tbl).

  • since 0.16
val keys : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter

keys tbl f iterates on keys (similar order as Hashtbl.iter).

val values : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'b CCHashtbl.iter

values tbl f iterates on values in the table tbl.

val keys_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'a list

keys_list tbl is the list of keys in tbl. If the key is in the Hashtable multiple times, all occurrences will be returned.

  • since 0.8
val values_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> 'b list

values_list tbl is the list of values in tbl.

  • since 0.8
val map_list : ( 'a -> 'b -> 'c ) -> ( 'a, 'b ) Stdlib.Hashtbl.t -> 'c list

map_list f tbl maps on a tbl's items. Collect into a list.

val incr : ?by:int -> ( 'a, int ) Stdlib.Hashtbl.t -> 'a -> unit

incr ?by tbl x increments or initializes the counter associated with x. If get tbl x = None, then after update, get tbl x = Some 1; otherwise, if get tbl x = Some n, now get tbl x = Some (n+1).

  • parameter by

    if specified, the int value is incremented by by rather than 1.

  • since 0.16
val decr : ?by:int -> ( 'a, int ) Stdlib.Hashtbl.t -> 'a -> unit

decr ?by tbl x is like incr but subtract 1 (or the value of by). If the value reaches 0, the key is removed from the table. This does nothing if the key is not already present in the table.

  • since 0.16
val to_iter : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter

Iterate on bindings in the table.

  • since 2.8
val add_list : ( 'a, 'b list ) Stdlib.Hashtbl.t -> 'a -> 'b -> unit

add_list tbl x y adds y to the list x is bound to. If x is not bound, it becomes bound to y.

  • since 0.16
val add_iter : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) CCHashtbl.iter -> unit

Add the corresponding pairs to the table, using Hashtbl.add.

  • since 2.8
val add_iter_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ( 'a, 'b ) Stdlib.Hashtbl.t -> + ('a * 'b) CCHashtbl.iter -> + unit

Add the corresponding pairs to the table, using Hashtbl.add. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_seq : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) Stdlib.Seq.t -> unit

Add the corresponding pairs to the table, using Hashtbl.add. Renamed from add_std_seq since 3.0.

  • since 3.0
val add_seq_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ( 'a, 'b ) Stdlib.Hashtbl.t -> + ('a * 'b) Stdlib.Seq.t -> + unit

Add the corresponding pairs to the table. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_iter : ('a * 'b) CCHashtbl.iter -> ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order.

  • since 2.8
val of_iter_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) CCHashtbl.iter -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val of_seq : ('a * 'b) Stdlib.Seq.t -> ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. Renamed from of_std_seq since 3.0.

  • since 3.0
val of_seq_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) Stdlib.Seq.t -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val add_iter_count : ( 'a, int ) Stdlib.Hashtbl.t -> 'a CCHashtbl.iter -> unit

add_iter_count tbl i increments the count of each element of i by calling incr. This is useful for counting how many times each element of i occurs.

  • since 2.8
val add_seq_count : ( 'a, int ) Stdlib.Hashtbl.t -> 'a Stdlib.Seq.t -> unit

add_seq_count tbl seq increments the count of each element of seq by calling incr. This is useful for counting how many times each element of seq occurs. Renamed from add_std_seq_count since 3.0.

  • since 3.0
val of_iter_count : 'a CCHashtbl.iter -> ( 'a, int ) Stdlib.Hashtbl.t

Like add_seq_count, but allocates a new table and returns it.

  • since 2.8
val of_seq_count : 'a Stdlib.Seq.t -> ( 'a, int ) Stdlib.Hashtbl.t

Like add_seq_count, but allocates a new table and returns it. Renamed from of_std_seq_count since 3.0.

  • since 3.0
val to_list : ( 'a, 'b ) Stdlib.Hashtbl.t -> ('a * 'b) list

to_list tbl returns the list of (key,value) bindings (order unspecified).

val of_list : ('a * 'b) list -> ( 'a, 'b ) Stdlib.Hashtbl.t

of_list l builds a table from the given list l of bindings k_i -> v_i, added in order using add. If a key occurs several times, it will be added several times, and the visible binding will be the last one.

val of_list_with : + f:( 'a -> 'b -> 'b -> 'b ) -> + ('a * 'b) list -> + ( 'a, 'b ) Stdlib.Hashtbl.t

From the given bindings, added in order. If a key occurs multiple times in the input, the values are combined using f in an unspecified order.

  • since 3.3
val update : + ( 'a, 'b ) Stdlib.Hashtbl.t -> + f:( 'a -> 'b option -> 'b option ) -> + k:'a -> + unit

update tbl ~f ~k updates key k by calling f k (Some v) if k was mapped to v, or f k None otherwise; if the call returns None then k is removed/stays removed, if the call returns Some v' then the binding k -> v' is inserted using Hashtbl.replace.

  • since 0.14
val get_or_add : ( 'a, 'b ) Stdlib.Hashtbl.t -> f:( 'a -> 'b ) -> k:'a -> 'b

get_or_add tbl ~k ~f finds and returns the binding of k in tbl, if it exists. If it does not exist, then f k is called to obtain a new binding v; k -> v is added to tbl and v is returned.

  • since 1.0
val pp : + ?pp_start:unit CCHashtbl.printer -> + ?pp_stop:unit CCHashtbl.printer -> + ?pp_sep:unit CCHashtbl.printer -> + ?pp_arrow:unit CCHashtbl.printer -> + 'a CCHashtbl.printer -> + 'b CCHashtbl.printer -> + ( 'a, 'b ) Stdlib.Hashtbl.t CCHashtbl.printer

pp ~pp_start ~pp_stop ~pp_sep ~pp arrow pp_k pp_v returns a table printer given a pp_k printer for individual key and a pp_v printer for individual value. pp_start and pp_stop control the opening and closing delimiters, by default print nothing. pp_sep control the separator between binding. pp_arrow control the arrow between the key and value. Renamed from print since 2.0.

  • since 0.13
module type S' = CCHashtbl.S
module Make' = CCHashtbl.Make
\ No newline at end of file diff --git a/dev/containers/ContainersLabels/Hashtbl/module-type-HashedType/index.html b/dev/containers/ContainersLabels/Hashtbl/module-type-HashedType/index.html new file mode 100644 index 00000000..9cc71f79 --- /dev/null +++ b/dev/containers/ContainersLabels/Hashtbl/module-type-HashedType/index.html @@ -0,0 +1,2 @@ + +HashedType (containers.ContainersLabels.Hashtbl.HashedType)

Module type Hashtbl.HashedType

type t
val equal : t -> t -> bool
val hash : t -> int
\ No newline at end of file diff --git a/dev/containers/ContainersLabels/Hashtbl/module-type-S/index.html b/dev/containers/ContainersLabels/Hashtbl/module-type-S/index.html new file mode 100644 index 00000000..8be31674 --- /dev/null +++ b/dev/containers/ContainersLabels/Hashtbl/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers.ContainersLabels.Hashtbl.S)

Module type Hashtbl.S

type key
type !'a t
val create : int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/ContainersLabels/Hashtbl/module-type-SeededHashedType/index.html b/dev/containers/ContainersLabels/Hashtbl/module-type-SeededHashedType/index.html new file mode 100644 index 00000000..4b18572d --- /dev/null +++ b/dev/containers/ContainersLabels/Hashtbl/module-type-SeededHashedType/index.html @@ -0,0 +1,2 @@ + +SeededHashedType (containers.ContainersLabels.Hashtbl.SeededHashedType)

Module type Hashtbl.SeededHashedType

type t
val equal : t -> t -> bool
val hash : int -> t -> int
\ No newline at end of file diff --git a/dev/containers/ContainersLabels/Hashtbl/module-type-SeededS/index.html b/dev/containers/ContainersLabels/Hashtbl/module-type-SeededS/index.html new file mode 100644 index 00000000..cb229858 --- /dev/null +++ b/dev/containers/ContainersLabels/Hashtbl/module-type-SeededS/index.html @@ -0,0 +1,2 @@ + +SeededS (containers.ContainersLabels.Hashtbl.SeededS)

Module type Hashtbl.SeededS

type key
type !'a t
val create : ?random:bool -> int -> 'a t
val clear : 'a t -> unit
val reset : 'a t -> unit
val copy : 'a t -> 'a t
val add : 'a t -> key -> 'a -> unit
val remove : 'a t -> key -> unit
val find : 'a t -> key -> 'a
val find_opt : 'a t -> key -> 'a option
val find_all : 'a t -> key -> 'a list
val replace : 'a t -> key -> 'a -> unit
val mem : 'a t -> key -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val filter_map_inplace : ( key -> 'a -> 'a option ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val length : 'a t -> int
val stats : 'a t -> statistics
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_keys : 'a t -> key Stdlib.Seq.t
val to_seq_values : 'a t -> 'a Stdlib.Seq.t
val add_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val replace_seq : 'a t -> (key * 'a) Stdlib.Seq.t -> unit
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/Containers_bencode/Decode/index.html b/dev/containers/Containers_bencode/Decode/index.html new file mode 100644 index 00000000..f298edca --- /dev/null +++ b/dev/containers/Containers_bencode/Decode/index.html @@ -0,0 +1,2 @@ + +Decode (containers.Containers_bencode.Decode)

Module Containers_bencode.Decode

Decoding

val of_string : string -> t option
val of_string_exn : string -> t

Parse string.

  • raises Failure

    if the string is not valid bencode.

\ No newline at end of file diff --git a/dev/containers/Containers_bencode/Encode/index.html b/dev/containers/Containers_bencode/Encode/index.html new file mode 100644 index 00000000..8dd91509 --- /dev/null +++ b/dev/containers/Containers_bencode/Encode/index.html @@ -0,0 +1,2 @@ + +Encode (containers.Containers_bencode.Encode)

Module Containers_bencode.Encode

Encoding

val to_string : t -> string
val to_buffer : Stdlib.Buffer.t -> t -> unit
val to_chan : Stdlib.out_channel -> t -> unit
val to_fmt : Stdlib.Format.formatter -> t -> unit
\ No newline at end of file diff --git a/dev/containers/Containers_bencode/Str_map/index.html b/dev/containers/Containers_bencode/Str_map/index.html new file mode 100644 index 00000000..c60c62be --- /dev/null +++ b/dev/containers/Containers_bencode/Str_map/index.html @@ -0,0 +1,6 @@ + +Str_map (containers.Containers_bencode.Str_map)

Module Containers_bencode.Str_map

type key = Stdlib.String.t
type !'a t = 'a Stdlib__Map.Make(Stdlib.String).t
val empty : 'a t
val is_empty : 'a t -> bool
val mem : key -> 'a t -> bool
val add : key -> 'a -> 'a t -> 'a t
val update : key -> ( 'a option -> 'a option ) -> 'a t -> 'a t
val singleton : key -> 'a -> 'a t
val remove : key -> 'a t -> 'a t
val merge : + ( key -> 'a option -> 'b option -> 'c option ) -> + 'a t -> + 'b t -> + 'c t
val union : ( key -> 'a -> 'a -> 'a option ) -> 'a t -> 'a t -> 'a t
val compare : ( 'a -> 'a -> int ) -> 'a t -> 'a t -> int
val equal : ( 'a -> 'a -> bool ) -> 'a t -> 'a t -> bool
val iter : ( key -> 'a -> unit ) -> 'a t -> unit
val fold : ( key -> 'a -> 'b -> 'b ) -> 'a t -> 'b -> 'b
val for_all : ( key -> 'a -> bool ) -> 'a t -> bool
val exists : ( key -> 'a -> bool ) -> 'a t -> bool
val filter : ( key -> 'a -> bool ) -> 'a t -> 'a t
val filter_map : ( key -> 'a -> 'b option ) -> 'a t -> 'b t
val partition : ( key -> 'a -> bool ) -> 'a t -> 'a t * 'a t
val cardinal : 'a t -> int
val bindings : 'a t -> (key * 'a) list
val min_binding : 'a t -> key * 'a
val min_binding_opt : 'a t -> (key * 'a) option
val max_binding : 'a t -> key * 'a
val max_binding_opt : 'a t -> (key * 'a) option
val choose : 'a t -> key * 'a
val choose_opt : 'a t -> (key * 'a) option
val split : key -> 'a t -> 'a t * 'a option * 'a t
val find : key -> 'a t -> 'a
val find_opt : key -> 'a t -> 'a option
val find_first : ( key -> bool ) -> 'a t -> key * 'a
val find_first_opt : ( key -> bool ) -> 'a t -> (key * 'a) option
val find_last : ( key -> bool ) -> 'a t -> key * 'a
val find_last_opt : ( key -> bool ) -> 'a t -> (key * 'a) option
val map : ( 'a -> 'b ) -> 'a t -> 'b t
val mapi : ( key -> 'a -> 'b ) -> 'a t -> 'b t
val to_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_rev_seq : 'a t -> (key * 'a) Stdlib.Seq.t
val to_seq_from : key -> 'a t -> (key * 'a) Stdlib.Seq.t
val add_seq : (key * 'a) Stdlib.Seq.t -> 'a t -> 'a t
val of_seq : (key * 'a) Stdlib.Seq.t -> 'a t
\ No newline at end of file diff --git a/dev/containers/Containers_codegen/Bitfield/index.html b/dev/containers/Containers_codegen/Bitfield/index.html new file mode 100644 index 00000000..8fb94337 --- /dev/null +++ b/dev/containers/Containers_codegen/Bitfield/index.html @@ -0,0 +1,2 @@ + +Bitfield (containers.Containers_codegen.Bitfield)

Module Containers_codegen.Bitfield

Generate efficient bitfields that fit in an integer

type t
val make : ?emit_failure_if_too_wide:bool -> name:string -> unit -> t

Make a new bitfield with the given name.

  • parameter name

    the name of the generated type

  • parameter emit_failure_if_too_wide

    if true, generated code includes a runtime assertion that Sys.int_size is wide enough to support this type

val field_bit : t -> string -> unit

field_bit ty name adds a field of size 1 to the bitfield ty, with name name. The generate code will provide get/set for a boolean.

val field_int : t -> width:int -> string -> unit

field_int ty name ~width adds a field of size width to the bitfield with name name. The accessors will be for integers of width bits, and the setter might assert that the provided integer fits.

val total_width : t -> int

Total width in bits of the given bitfield.

val gen_mli : t -> code

Generate code for the type signature for the given bitfield

val gen_ml : t -> code

Generate code for the implementation for the given bitfield

\ No newline at end of file diff --git a/dev/containers/Containers_codegen/Code/index.html b/dev/containers/Containers_codegen/Code/index.html new file mode 100644 index 00000000..7fb791b7 --- /dev/null +++ b/dev/containers/Containers_codegen/Code/index.html @@ -0,0 +1,2 @@ + +Code (containers.Containers_codegen.Code)

Module Containers_codegen.Code

Representation of OCaml code

type t = code
val pp : t Fmt.printer
val to_string : t -> string
val mk_pp : unit Fmt.printer -> t
val mk_str : string -> t
val in_struct : string -> t list -> t
val in_sig : string -> t list -> t
\ No newline at end of file diff --git a/dev/containers/Containers_scc/.dummy b/dev/containers/Containers_scc/.dummy new file mode 100644 index 00000000..e69de29b diff --git a/dev/containers/Containers_scc/Make/argument-1-A/index.html b/dev/containers/Containers_scc/Make/argument-1-A/index.html new file mode 100644 index 00000000..3cd6c8a4 --- /dev/null +++ b/dev/containers/Containers_scc/Make/argument-1-A/index.html @@ -0,0 +1,2 @@ + +A (containers.Containers_scc.Make.1-A)

Parameter Make.1-A

type t
type node
val children : t -> node -> node iter
module Node_tbl : Stdlib.Hashtbl.S with type key = node
\ No newline at end of file diff --git a/dev/containers/Containers_scc/Make/index.html b/dev/containers/Containers_scc/Make/index.html new file mode 100644 index 00000000..693a8d67 --- /dev/null +++ b/dev/containers/Containers_scc/Make/index.html @@ -0,0 +1,2 @@ + +Make (containers.Containers_scc.Make)

Module Containers_scc.Make

Parameters

module A : ARG

Signature

module A = A
val scc : A.t -> A.node list -> A.node list list
\ No newline at end of file diff --git a/dev/containers/Containers_scc/index.html b/dev/containers/Containers_scc/index.html new file mode 100644 index 00000000..191094f6 --- /dev/null +++ b/dev/containers/Containers_scc/index.html @@ -0,0 +1,8 @@ + +Containers_scc (containers.Containers_scc)

Module Containers_scc

type 'a iter = ( 'a -> unit ) -> unit
module type ARG = sig ... end
module type S = sig ... end
module Make (A : ARG) : S with module A = A
val scc : + tbl:(module Stdlib.Hashtbl.S with type key = 'node) -> + graph:'graph -> + children:( 'graph -> 'node -> 'node iter ) -> + nodes:'node list -> + unit -> + 'node list list
\ No newline at end of file diff --git a/dev/containers/Containers_scc/module-type-ARG/index.html b/dev/containers/Containers_scc/module-type-ARG/index.html new file mode 100644 index 00000000..19fd1610 --- /dev/null +++ b/dev/containers/Containers_scc/module-type-ARG/index.html @@ -0,0 +1,2 @@ + +ARG (containers.Containers_scc.ARG)

Module type Containers_scc.ARG

type t
type node
val children : t -> node -> node iter
module Node_tbl : Stdlib.Hashtbl.S with type key = node
\ No newline at end of file diff --git a/dev/containers/Containers_scc/module-type-S/A/index.html b/dev/containers/Containers_scc/module-type-S/A/index.html new file mode 100644 index 00000000..762e8cb8 --- /dev/null +++ b/dev/containers/Containers_scc/module-type-S/A/index.html @@ -0,0 +1,2 @@ + +A (containers.Containers_scc.S.A)

Module S.A

type t
type node
val children : t -> node -> node iter
module Node_tbl : Stdlib.Hashtbl.S with type key = node
\ No newline at end of file diff --git a/dev/containers/Containers_scc/module-type-S/index.html b/dev/containers/Containers_scc/module-type-S/index.html new file mode 100644 index 00000000..1f4387e6 --- /dev/null +++ b/dev/containers/Containers_scc/module-type-S/index.html @@ -0,0 +1,2 @@ + +S (containers.Containers_scc.S)

Module type Containers_scc.S

module A : ARG
val scc : A.t -> A.node list -> A.node list list
\ No newline at end of file diff --git a/dev/containers/index.html b/dev/containers/index.html index e57835cf..14610192 100644 --- a/dev/containers/index.html +++ b/dev/containers/index.html @@ -1,2 +1,2 @@ -index (containers.index)

containers index

Library containers

This library exposes the following toplevel modules:

Library containers.bencode

The entry point of this library is the module: Containers_bencode.

Library containers.cbor

The entry point of this library is the module: Containers_cbor.

Library containers.codegen

The entry point of this library is the module: Containers_codegen.

Library containers.monomorphic

The entry point of this library is the module: CCMonomorphic.

Library containers.top

The entry point of this library is the module: Containers_top.

Library containers.unix

The entry point of this library is the module: CCUnix.

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

containers index

Library containers

This library exposes the following toplevel modules:

Library containers.bencode

The entry point of this library is the module: Containers_bencode.

Library containers.cbor

The entry point of this library is the module: Containers_cbor.

Library containers.codegen

The entry point of this library is the module: Containers_codegen.

Library containers.monomorphic

The entry point of this library is the module: CCMonomorphic.

Library containers.scc

The entry point of this library is the module: Containers_scc.

Library containers.top

The entry point of this library is the module: Containers_top.

Library containers.unix

The entry point of this library is the module: CCUnix.

\ No newline at end of file