#### graphlib

Generic Graph library
IN THIS PACKAGE
Module . . . .
`type t = edge`
`type node = node`
`type graph = t`
`type label = G.E.label`
`val create : node -> node -> label -> t`

`create x y l` creates an edge connecting nodes `x` and `y` labeled with a a given label `l`

`val label : t -> label`

`label e` returns a label of an edge `e`

`val src : t -> node`

`src e` returns a source of an edge `e`

`val dst : t -> node`

`dst e` returns a destination of an edge `e`

`val mem : t -> graph -> bool`

`mem e g` is true if `e` ∈ E.

`val insert : t -> graph -> graph`

`insert e g` returns a graph `g'` with a set of edges extended with edge `e`. If `src e` or `dst e` wasn't in the set of nodes `N`, then it is extended as well, so that axioms of graph are preserved.

Postconditions:

`          - E(g') = E(g) ∪ {e}.`
`val update : t -> label -> graph -> graph`

`update e l g` if edge `e` exists in graph `g` then return a new graph `g'` in which edge `e` is associated with label `l`. Otherwise return `g` unchanged.

Postcondition:

```          - E(g) ⊆ E(g')
- N(g) ⊆ N(g')
- e ∉ E(g) → e ∉ E(g').
- e ∈ E(g) → ε(g')e = l.```
`val remove : t -> graph -> graph`

`remove e g` returns a graph `g'` that doesn't contain edge `e`.

Postconditions:

`          - E(g') = E(g) \ {e}.`
`include Regular.Std.Opaque.S with type t := t`
`include Core_kernel.Comparable.S with type t := t`
`include Base.Comparable.S with type t := t`
`include Base.Comparisons.S with type t := t`
`include Base.Comparisons.Infix with type t := t`
`val (>=) : t -> t -> bool`
`val (<=) : t -> t -> bool`
`val (=) : t -> t -> bool`
`val (>) : t -> t -> bool`
`val (<) : t -> t -> bool`
`val (<>) : t -> t -> bool`
`val equal : t -> t -> bool`
`val min : t -> t -> t`
`val max : t -> t -> t`
`val ascending : t -> t -> int`

`ascending` is identical to `compare`. `descending x y = ascending y x`. These are intended to be mnemonic when used like `List.sort ~compare:ascending` and ```List.sort ~cmp:descending```, since they cause the list to be sorted in ascending or descending order, respectively.

`val descending : t -> t -> int`
`val between : t -> low:t -> high:t -> bool`

`between t ~low ~high` means `low <= t <= high`

`val clamp_exn : t -> min:t -> max:t -> t`

`clamp_exn t ~min ~max` returns `t'`, the closest value to `t` such that `between t' ~low:min ~high:max` is true.

Raises if `not (min <= max)`.

`val clamp : t -> min:t -> max:t -> t Base.Or_error.t`
`include Base.Comparator.S with type t := t`
`type comparator_witness`
`val comparator : ( t, comparator_witness ) Base.Comparator.comparator`
`val validate_lbound : min:t Base.Maybe_bound.t -> t Base.Validate.check`
`val validate_ubound : max:t Base.Maybe_bound.t -> t Base.Validate.check`
```val validate_bound : min:t Base.Maybe_bound.t -> max:t Base.Maybe_bound.t -> t Base.Validate.check```
```module Replace_polymorphic_compare : Base.Comparable.Polymorphic_compare with type t := t```
```module Map : Core_kernel.Map.S with type Key.t = t with type Key.comparator_witness = comparator_witness```
```module Set : Core_kernel.Set.S with type Elt.t = t with type Elt.comparator_witness = comparator_witness```
`include Core_kernel.Hashable.S with type t := t`
`include Core_kernel.Hashable.Common with type t := t`
`val compare : t -> t -> Base.Int.t`
`val hash_fold_t : Base.Hash.state -> t -> Base.Hash.state`
`val hash : t -> Base.Hash.hash_value`
`val hashable : t Core_kernel.Hashtbl.Hashable.t`
`module Table : Core_kernel.Hashtbl.S with type key = t`
`module Hash_set : Core_kernel.Hash_set.S with type elt = t`
`module Hash_queue : Core_kernel.Hash_queue.S with type key = t`