module Nativeint:S
with type elt = nativeint
type
elt
type
t
val empty : t
val is_empty : t -> bool
val singleton : elt -> t
singleton x
returns the one-element set containing only x
.val mem : elt -> t -> bool
mem x s
tests whether x
belongs to the set s
.val find : elt -> t -> elt
find x s
returns the element in s that tests equal to x
under its comparison function.Not_found
if no element is equalval 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.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.val update : elt -> elt -> t -> t
update x y s
replace x
by y
in s
.
update
is faster when x
compares equal to y
according
to the comparison function used by your set.Not_found
if x
is not in s
.val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val sym_diff : t -> t -> t
sym_diff s t
returns the set of all elements in s
or t
but not both. This is the same as diff (union s t) (inter s
t)
.val compare : t -> t -> int
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 disjoint : t -> t -> bool
disjoint s1 s2
tests whether the sets s1
and s2
contain no shared
elements. (i.e. inter s1 s2
is empty.)val compare_subset : t -> t -> int
subset
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 at_rank_exn : int -> t -> elt
at_rank_exn i s
returns element at rank i
in s
, that is
the i
-th element in increasing order
(the 0
-th element being the smallest element of s
).Not_found
if s = empty
.Invalid_argument
error_message if i < 0 || i >= cardinal s
val map : (elt -> elt) -> t -> t
map f x
creates a new set with elements f a0
,
f a1
... f aN
, where a0
,a1
..aN
are the
values contained in x
val filter : (elt -> bool) -> t -> t
filter p s
returns the set of all elements in s
that satisfy predicate p
.val filter_map : (elt -> elt option) -> t -> t
filter_map f m
combines the features of filter
and
map
. It calls calls f a0
, f a1
, f aN
where a0
,a1
..aN
are the elements of m
and returns the set of pairs bi
such as f ai = Some bi
(when f
returns None
, the
corresponding element of m
is discarded).val fold : (elt -> 'a -> 'a) -> t -> 'a -> 'a
fold f s a
computes (f xN ... (f x1 (f x0 a))...)
,
where x0
,x1
..xN
are the elements of s
, in increasing order.val for_all : (elt -> bool) -> t -> bool
for_all p s
checks if all elements of the set
satisfy the predicate p
.val exists : (elt -> bool) -> t -> bool
exists p s
checks if at least one element of
the set satisfies the predicate p
.val partition : (elt -> bool) -> t -> t * t
partition p s
returns a pair of sets (s1, s2)
, where
s1
is the set of all the elements of s
that satisfy the
predicate p
, and s2
is the set of all the elements of
s
that do not satisfy p
.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 split_opt : elt -> t -> t * elt option * t
split_opt x s
returns a triple (l, maybe_v, 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
;
maybe_v
is None
if s
contains no element equal to x
,
or Some v
if s
contains an element v
that compares equal to x
.val split_lt : elt -> t -> t * t
split_lt x s
returns a pair of sets (l, r)
, such that
l
is the subset of s
with elements < x
;
r
is the subset of s
with elements >= x
.val split_le : elt -> t -> t * t
split_le x s
returns a pair of sets (l, r)
, such that
l
is the subset of s
with elements <= x
;
r
is the subset of s
with elements > x
.val cardinal : t -> int
val elements : t -> elt list
Ord.compare
, where Ord
is the argument
given to Set.Make
.val to_list : t -> elt list
elements
.val to_array : t -> elt array
to_list
but with an array instead of a list.val min_elt : t -> elt
Ord.compare
ordering).Not_found
if the set is empty.val pop_min : t -> elt * t
let mini = min_elt s in (mini, remove mini s)
Since 2.4
Raises Not_found
if the set is empty.
val pop_max : t -> elt * t
let maxi = max_elt s in (maxi, remove maxi s)
Since 2.4
Raises Not_found
if the set is empty.
val max_elt : t -> elt
Set.S.min_elt
, but returns the largest element of the
given set.val choose : t -> elt
Not_found
if the set is empty.val any : t -> elt
Not_found
if the set is empty.val pop : t -> elt * t
Not_found
if given an empty setval enum : t -> elt BatEnum.t
Ord.compare
, where Ord
is the argument
given to Set.Make
.val backwards : t -> elt BatEnum.t
Ord.compare
, where Ord
is the argument
given to Set.Make
.val of_enum : elt BatEnum.t -> t
val of_list : elt list -> t
val of_array : elt array -> t
val print : ?first:string ->
?last:string ->
?sep:string ->
('a BatInnerIO.output -> elt -> unit) ->
'a BatInnerIO.output -> t -> unit
module Infix:sig
..end
Set
with functions
behaving slightly differently but having the same name. This is by design:
the functions meant to override the corresponding functions of Set
.module Exceptionless:sig
..end
Set
without exceptions.
module Labels:sig
..end
Set
with labels.