Module btreeset

.contains — true iff the element is in the set. Real body: linear scan over the backing Vec with structural equality (same tactic as hashset-contains). Argument order matches HashSet.contains (elem Self -> Bool) rather than the original stub's inverted order. Real O(log n) balanced-tree lookup arrives with the tree runtime.

.difference — elements in the first set but not the second. First set is deeper on the stack, second is on top.

.first returns Some with the smallest element or None if empty. O(log n).

.insert adds an element, returning the updated set and a Bool indicating whether the element was newly added (true = new, false = already present). O(log n). (Ord elem elem) constraint is implicit on the dispatch once the real body lands.

.intersection — elements in both sets, deduplicated. Iteration order follows the first set (matches std BTreeSet::intersection). Real O(min(n,m) * log(max(n,m))) arrives with the tree runtime.

.is-disjoint — true iff the two sets share no elements. Two empty sets are considered disjoint.

True iff the set contains zero elements.

.is-subset — true iff every element of the first set (deeper) is also in the second. The empty set is a subset of every set; every set is a subset of itself.

.is-superset — swap-argument dual of .is-subset.

.last returns Some with the largest element or None if empty. O(log n).

Number of elements in O(1).

.range — elements in the half-open interval [start, end) in ascending order. O(log n + k) where k is the number of elements yielded. Spec specifies (Seq elem _) but Seq is a trait alias; the stub returns (Vec elem) until a shared lazy-sequence concrete type exists.

.range-from — elements >= start in ascending order. O(log n + k). Returns (Vec elem) per the range stub caveat.

.range-to — elements < end in ascending order. O(log n + k). Returns (Vec elem) per the range stub caveat.

.remove deletes an element, returning the updated set and a Bool indicating whether the element was previously present. O(log n).

.retain — keep elements for which the predicate returns true. Returns a new BTreeSet containing only the retained elements.

.symmetric-difference — elements in exactly one of the two sets. First-set-only elements surface before second-set-only elements (matches std iteration order).

.to-vec — produce a (Vec elem) with the same elements. Runtime identity cast — the backing cell is already a Vec. Spec mandates ascending-order iteration once the balanced tree maintains it; until then elements surface in insertion order. Callers MUST NOT depend on ordering yet.

.union — all elements in either set, deduplicated. Real body: linear-scan concatenation via values_equal (same tactic as btreeset-contains). Result preserves the BTreeSet uniqueness invariant. Real O(n + m) via balanced-tree merge arrives with the tree runtime. Iteration order is insertion-order for now (first set's elements, then second set's new elements).