#### electrod

Formal analysis for the Electrod formal pivot language
IN THIS PACKAGE
Module . .
`include Set.S with type elt = t`
`type elt = t`

The type of the set elements.

`type t`

The type of sets.

`val empty : t`

The empty set.

`val is_empty : t -> bool`

Test whether a set is empty or not.

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

`mem x s` tests whether `x` belongs to the set `s`.

`val add : elt -> t -> t`

`add x s` returns a set containing all elements of `s`, plus `x`. If `x` was already in `s`, `s` is returned unchanged (the result of the function is then physically equal to `s`).

• before 4.03

Physical equality was not ensured.

`val singleton : elt -> t`

`singleton x` returns the one-element set containing only `x`.

`val remove : elt -> t -> t`

`remove x s` returns a set containing all elements of `s`, except `x`. If `x` was not in `s`, `s` is returned unchanged (the result of the function is then physically equal to `s`).

• before 4.03

Physical equality was not ensured.

`val union : t -> t -> t`

Set union.

`val inter : t -> t -> t`

Set intersection.

`val disjoint : t -> t -> bool`

Test if two sets are disjoint.

• since 4.08.0
`val diff : t -> t -> t`

Set difference: `diff s1 s2` contains the elements of `s1` that are not in `s2`.

`val compare : t -> t -> int`

Total ordering between sets. Can be used as the ordering function for doing sets of sets.

`val equal : t -> t -> bool`

`equal s1 s2` tests whether the sets `s1` and `s2` are equal, that is, contain equal elements.

`val subset : t -> t -> bool`

`subset s1 s2` tests whether the set `s1` is a subset of the set `s2`.

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

`iter f s` applies `f` in turn to all elements of `s`. The elements of `s` are presented to `f` in increasing order with respect to the ordering over the type of the elements.

`val map : ( elt -> elt ) -> t -> t`

`map f s` is the set whose elements are `f a0`,`f a1`... ```f aN```, where `a0`,`a1`...`aN` are the elements of `s`.

The elements are passed to `f` in increasing order with respect to the ordering over the type of the elements.

If no element of `s` is changed by `f`, `s` is returned unchanged. (If each output of `f` is physically equal to its input, the returned set is physically equal to `s`.)

• since 4.04.0
`val fold : ( elt -> 'a -> 'a ) -> t -> 'a -> 'a`

`fold f s init` computes `(f xN ... (f x2 (f x1 init))...)`, where `x1 ... xN` are the elements of `s`, in increasing order.

`val for_all : ( elt -> bool ) -> t -> bool`

`for_all f s` checks if all elements of the set satisfy the predicate `f`.

`val exists : ( elt -> bool ) -> t -> bool`

`exists f s` checks if at least one element of the set satisfies the predicate `f`.

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

`filter f s` returns the set of all elements in `s` that satisfy predicate `f`. If `f` satisfies every element in `s`, `s` is returned unchanged (the result of the function is then physically equal to `s`).

• before 4.03

Physical equality was not ensured.

`val filter_map : ( elt -> elt option ) -> t -> t`

`filter_map f s` returns the set of all `v` such that `f x = Some v` for some element `x` of `s`.

For example,

``filter_map (fun n -> if n mod 2 = 0 then Some (n / 2) else None) s``

is the set of halves of the even elements of `s`.

If no element of `s` is changed or dropped by `f` (if `f x = Some x` for each element `x`), then `s` is returned unchanged: the result of the function is then physically equal to `s`.

• since 4.11.0
`val partition : ( elt -> bool ) -> t -> t * t`

`partition f s` returns a pair of sets `(s1, s2)`, where `s1` is the set of all the elements of `s` that satisfy the predicate `f`, and `s2` is the set of all the elements of `s` that do not satisfy `f`.

`val cardinal : t -> int`

Return the number of elements of a set.

`val elements : t -> elt list`

Return the list of all elements of the given set. The returned list is sorted in increasing order with respect to the ordering `Ord.compare`, where `Ord` is the argument given to `Stdlib.Set.Make`.

`val min_elt : t -> elt`

Return the smallest element of the given set (with respect to the `Ord.compare` ordering), or raise `Not_found` if the set is empty.

`val max_elt : t -> elt`

Same as `min_elt`, but returns the largest element of the given set.

`val choose : t -> elt`

Return one element of the given set, or raise `Not_found` if the set is empty. Which element is chosen is unspecified, but equal elements will be chosen for equal sets.

`val split : elt -> t -> t * bool * t`

`split x s` returns a triple `(l, present, r)`, where `l` is the set of elements of `s` that are strictly less than `x`; `r` is the set of elements of `s` that are strictly greater than `x`; `present` is `false` if `s` contains no element equal to `x`, or `true` if `s` contains an element equal to `x`.

`val find : elt -> t -> elt`

`find x s` returns the element of `s` equal to `x` (according to `Ord.compare`), or raise `Not_found` if no such element exists.

• since 4.01.0

## Iterators

`val to_seq_from : elt -> t -> elt Seq.t`

`to_seq_from x s` iterates on a subset of the elements of `s` in ascending order, from `x` or above.

• since 4.07
`val to_rev_seq : t -> elt Seq.t`

Iterate on the whole set, in descending order

• since 4.12
`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 CCSet.iter -> t`

Build a set from the given `iter` of elements.

• since 2.8
`val add_iter : t -> elt CCSet.iter -> t`
• since 2.8
`val to_iter : t -> elt CCSet.iter`

`to_iter t` converts the set `t` to a `iter` of the elements.

• since 2.8
`val of_seq : elt CCSet.sequence -> t`
`val add_seq : t -> elt CCSet.sequence -> t`
`val to_seq : t -> elt CCSet.sequence`
`val of_list : elt list -> t`

Build a set from the given list of elements, added in order using `add`.

`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 : ?start:string -> ?stop:string -> ?sep:string -> elt CCSet.printer -> t CCSet.printer```

Print the set.