set

Totally ordered sets

type t<elt> = set<elt>

The type Set.t<elt> is an alias for set<elt>.

let empty: <elt>t<elt>

The value Set.empty denotes the empty set. In some contexts, it is useful to annotate it with its type, for example: (Set.empty as set<int>).

let update: <elt>(_: elt) => (_: bool) => (_: t<elt>) => t<elt>

The call Set.update(elt, true, set) is a copy of the set set containing the element elt. The call Set.update(elt, false, set) is a copy of the set set where the element elt is absent.

let add: <elt>(_: elt) => (_: t<elt>) => t<elt>

The call Set.add(elt, set) is a set containing all the elements of the set set, plus the element elt.

let remove: <elt>(_: elt) => (_: t<elt>) => t<elt>

The call Set.remove(elt, set) is a copy of the set set without the element elt.

let literal: <elt>(_: list<elt>) => t<elt>

The call Set.literal(list([e1, ..., en])) is a set containing exactly the elements in the list. Note: The list must be literal, not an expression (compile-time list of values).

let of_list: <elt>(_: list<elt>) => t<elt>

The call Set.of_list(elements) is a set containing exactly the elements in the list elements. Note: Use Set.literal instead if using a literal list. Note: Use literal instead if using a literal list.

let size: <elt>(_: t<elt>) => nat

The call Set.size(set) is the number of elements of the set set.

let cardinal: <elt>(_: t<elt>) => nat

The call Set.cardinal(set) is the number of elements of the set set.

let mem: <elt>(_: elt) => (_: t<elt>) => bool

The call Set.mem(elt, set) is true if, and only if, the element elt belongs to the set set.

let fold: <elt, acc>(_: (_: [acc, elt]) => acc) => (_: t<elt>) => (_: acc) => acc

The call Set.fold(f, set, init) is f(... (f (f (init, e1), e2), ...), en), where e1, e2, ..., en are the elements of the set set in increasing order.

let fold_desc: <elt, acc>(_: (_: [elt, acc]) => acc) => (_: t<elt>) => (_: acc) => acc

The call Set.fold(f, set, init) is f(... (f (init, en), ...), e1), where e1, e2, ..., en are the elements of the set set in increasing order.

let filter_map: <old, new>(_: (_: old) => option<new>) => (_: t<old>) => t<new>

The call Set.filter_map(f, set) is a set made by calling f (the filter) on each element of the set set: if f returns None(), the element is skipped in the result, otherwise, if it is Some(e), then e is kept.

let iter: <elt>(_: (_: elt) => unit) => (_: t<elt>) => unit

The call Set.iter(f, set) applies f to all the elements of the set set in increasing order.

let map: <old, new>(_: (_: old) => new) => (_: t<old>) => t<new>

The call Set.map(f, set) evaluates in a set whose elements have been obtained by applying f to the elements of the set set.