MoreLabels.Set.Make(3)

📦
version 5.5.0 · 19 versions
, in arch rolling

💖 MoreLabels.Set.Make(3) 💖

okay bestie, welcome to the MoreLabels.Set.Make page from the OCaml library manual. this one is lowkey a functor era and it's giving "make your own set type" energy. let's go 🫶

✨ NAME ✨

MoreLabels.Set.Make — bestie, it's a functor that builds you an implementation of the set structure, and it just needs a totally ordered type to do it. that's it. that's the whole vibe. 💅

🦋 Module 🦋

Module MoreLabels.Set.Make

🌸 Documentation 🌸

Module Make
 : (Ord : OrderedType) -> sig end

so, Make is a functor building an implementation of the set structure given a totally ordered type. fr fr, that's the entire deal.

Parameters:

  • "Ord" — which is MoreLabels.Set.OrderedType. that's your totally-ordered-type plug-in, iykyk 🎀

🎀 Sets 🎀

  • type elt — the type of the set elements.
  • type t — the type of sets. your actual set type, iconic.
  • val empty : t — the empty set. the blank canvas. the "no thoughts head empty" of sets 🫧
  • 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 — and the result of the function is then physically equal to s. slay, no wasted allocation 💅
Before 4.03: physical equality was not ensured. so like, old OCaml said "maybe", and we don't stan that anymore 💀
  • val singleton : elt -> t — singleton x returns the one-element set containing only x. main character energy, it's all about them ✨
  • 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 — result physically equal to s, in that case. so we're not allocating for nothing 🎀
Before 4.03: physical equality was not ensured. same lore as before 🫠
  • val union : t -> t -> t — set union. combine the friend groups 💖
  • val inter : t -> t -> t — set intersection. only the mutuals 💅
  • val disjoint : t -> t -> bool — test if two sets are disjoint. like, do they share zero elements? yes/no. Since 4.08
  • val diff : t -> t -> t — set difference: diff s1 s2 contains the elements of s1 that are not in s2. the "unfollowed back" of sets 😭
  • val cardinal : t -> int — return the number of elements of a set. the headcount 🧮

🌈 Elements 🌈

  • 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 MoreLabels.Set.Make. sorted, bestie, always sorted ✨
  • 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. the littlest guy 🥺
  • val min_elt_opt : t -> elt option — return the smallest element of the given set (with respect to the Ord.compare ordering), or None if the set is empty. same thing but the polite option version 🎀 Since 4.05
  • val max_elt : t -> elt — same as MoreLabels.Set.S.min_elt, but returns the largest element of the given set. big boss energy 👑
  • val max_elt_opt : t -> elt option — same as MoreLabels.Set.S.min_elt_opt, but returns the largest element of the given set. Since 4.05
  • 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. so it's a mystery pick, but a consistent mystery pick, and we respect that 🎲 — ngl, "unspecified which one" is highkey important, so don't go depending on it being a particular element, ok?
  • val choose_opt : t -> elt option — return one element of the given set, or None if the set is empty. which element is chosen is unspecified, but equal elements will be chosen for equal sets. Since 4.05

🦋 Searching 🦋

  • 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. note bestie: it gives you back the element in the set, not the one you passed in 👀 Since 4.01
  • val find_opt : elt -> t -> elt option — find_opt x s returns the element of s equal to x (according to Ord.compare), or None if no such element exists. Since 4.05
  • val find_first : f:(elt -> bool) -> t -> elt — find_first ~f s, where f is a monotonically increasing function, returns the lowest element e of s such that f e, or raises Not_found if no such element exists.

for example, find_first (fun e -> Ord.compare e x >= 0) s will return the first element e of s where Ord.compare e x >= 0 (intuitively: e >= x), or raise Not_found if x is greater than any element of s. it's giving lower bound, and we're obsessed 💜 Since 4.05

  • val find_first_opt : f:(elt -> bool) -> t -> elt option — find_first_opt ~f s, where f is a monotonically increasing function, returns an option containing the lowest element e of s such that f e, or None if no such element exists. Since 4.05
  • val find_last : f:(elt -> bool) -> t -> elt — find_last ~f s, where f is a monotonically decreasing function, returns the highest element e of s such that f e, or raises Not_found if no such element exists. yeah it's decreasing here, don't mix them up bestie, that's a whole trap 🙈 Since 4.05
  • val find_last_opt : f:(elt -> bool) -> t -> elt option — find_last_opt ~f s, where f is a monotonically decreasing function, returns an option containing the highest element e of s such that f e, or None if no such element exists. Since 4.05

⭐ Traversing ⭐

  • val iter : f:(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. in order, always 💫
  • val fold : f:(elt -> 'acc -> 'acc) -> t -> init:'acc -> 'acc — fold ~f s ~init computes (f xN ... (f x2 (f x1 init))...), where x1 ... xN are the elements of s, in increasing order. the way that nesting goes, it's honestly art 🎨

🧚 Transforming 🧚

  • val map : f:(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.) zero-waste glow-up ✨ Since 4.04

  • val filter : f:(elt -> bool) -> t -> t — filter ~f s returns the set of all elements in s that satisfy predicate f. if every element in s satisfies f, s is returned unchanged (the result of the function is then physically equal to s). nothing dropped, nothing reallocated 💅
Before 4.03: physical equality was not ensured. yeah yeah, same note 😌
  • val filter_map : f:(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. halve the evens, yeet the odds, iconic behaviour tbh ✂️

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

  • val partition : f:(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. two friend groups, no drama 🌸
  • 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. three-for-one, we love a triple 🎁

💜 Predicates and comparisons 💜

  • val is_empty : t -> bool — test whether a set is empty or not. vibe check on the emptiness 🫧
  • val is_singleton : t -> bool — test whether a set has exactly one element or not. solo-set check 🎤 Since 5.5
  • val mem : elt -> t -> bool — mem x s tests whether x belongs to the set s. are they in the group chat? 👀
  • val equal : t -> t -> bool — equal s1 s2 tests whether the sets s1 and s2 are equal, that is, contain equal elements.
  • val compare : t -> t -> int — total ordering between sets. can be used as the ordering function for doing sets of sets. yes bestie, sets of sets, it's recursion all the way down 🌀
  • val subset : t -> t -> bool — subset s1 s2 tests whether the set s1 is a subset of the set s2.
  • val for_all : f:(elt -> bool) -> t -> bool — for_all ~f s checks if all elements of the set satisfy the predicate f. every single one, no exceptions ✋
  • val exists : f:(elt -> bool) -> t -> bool — exists ~f s checks if at least one element of the set satisfies the predicate f. just one is enough, we're not picky 🍓

🔥 Converting 🔥

  • val to_list : t -> elt list — to_list s is MoreLabels.Set.S.elements s. that's it, that's the whole function, it's a rebrand 💅 Since 5.1
  • val of_list : elt list -> t — of_list l creates a set from a list of elements. this is usually more efficient than folding add over the list, except perhaps for lists with many duplicated elements. so use it, unless your list is like 90% dupes 🫠 Since 4.02
  • 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_seq : t -> elt Seq.t — iterate on the whole set, in ascending order. ⬆️ Since 4.07
  • val to_rev_seq : t -> elt Seq.t — iterate on the whole set, in descending order. ⬇️ Since 4.12
  • val add_seq : elt Seq.t -> t -> t — add the given elements to the set, in order. Since 4.07
  • val of_seq : elt Seq.t -> t — build a set from the given elements. Since 4.07

and that's the whole page, bestie!! 🎀 you ate that. tysm for reading, ily, and remember: sorted, specified, and slaying 💖

sign-off szn: this lil doc was generated by OCamldoc, dated 2026-06-22, for the page MoreLabels.Set.Make(3). bye bestie, go build a set 🦋✨
📦 where this page comes from