sorted_vec_map/
sorted_vec_set.rs

1// Copyright 2026 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use crate::SortedVecMap;
6use crate::sorted_vec_map::{Iter as MapIter, Keys};
7use std::borrow::Borrow;
8use std::collections::BTreeSet;
9use std::fmt::Debug;
10use std::ops::{Bound, RangeBounds};
11
12/// An ordered set built on a `SortedVecMap`.
13///
14/// `SortedVecSet` provides a memory-efficient alternative to `BTreeSet` by wrapping
15/// `SortedVecMap<T, ()>`.
16///
17/// # Complexity
18///
19/// | Operation | Time Complexity | Space Complexity |
20/// |---|---|---|
21/// | `new` / `with_capacity` | `O(1)` | `O(1)` |
22/// | `contains` / `get` | `O(log N)` | `O(1)` |
23/// | `insert` | `O(N)` | `O(1)` amortized |
24/// | `remove` | `O(N)` | `O(1)` |
25/// | `union` / `difference` | `O(N + M)` | `O(1)` |
26///
27/// # When to use
28///
29/// - Similar to `SortedVecMap`, it is ideal for read-heavy, memory-constrained sets.
30#[derive(Eq, PartialEq, PartialOrd, Ord, Hash, Clone)]
31pub struct SortedVecSet<T> {
32    map: SortedVecMap<T, ()>,
33}
34
35impl<T> SortedVecSet<T> {
36    /// Returns a new builder for `SortedVecSet`.
37    pub fn builder() -> SortedVecSetBuilder<T> {
38        SortedVecSetBuilder::new()
39    }
40
41    /// Returns a new builder for `SortedVecSet` with at least the specified capacity.
42    pub fn builder_with_capacity(capacity: usize) -> SortedVecSetBuilder<T> {
43        SortedVecSetBuilder::with_capacity(capacity)
44    }
45
46    /// Constructs a new, empty `SortedVecSet`.
47    pub fn new() -> Self {
48        Self { map: SortedVecMap::new() }
49    }
50
51    /// Returns the number of elements the set can hold without reallocating.
52    pub fn capacity(&self) -> usize {
53        self.map.capacity()
54    }
55
56    /// Constructs a new, empty `SortedVecSet` with at least the specified capacity.
57    pub fn with_capacity(capacity: usize) -> Self {
58        Self { map: SortedVecMap::with_capacity(capacity) }
59    }
60
61    /// Reserves capacity for at least `additional` more elements in the `SortedVecSet`.
62    pub fn reserve(&mut self, additional: usize) {
63        self.map.reserve(additional);
64    }
65
66    /// Shrinks the capacity of the set as much as possible.
67    pub fn shrink_to_fit(&mut self) {
68        self.map.shrink_to_fit();
69    }
70
71    /// Returns the number of elements in the set.
72    pub fn len(&self) -> usize {
73        self.map.len()
74    }
75
76    /// Returns true if there are no elements in the set.
77    pub fn is_empty(&self) -> bool {
78        self.map.is_empty()
79    }
80
81    /// Returns true if the set contains the given value.
82    ///
83    /// Complexity: `O(log n)` time.
84    pub fn contains<Q>(&self, value: &Q) -> bool
85    where
86        T: Borrow<Q> + Ord,
87        Q: Ord + ?Sized,
88    {
89        self.map.contains_key(value)
90    }
91
92    /// Returns a reference to the value in the set, if any, that is equal to the given value.
93    ///
94    /// Complexity: `O(log n)` time.
95    pub fn get<Q>(&self, value: &Q) -> Option<&T>
96    where
97        T: Borrow<Q> + Ord,
98        Q: Ord + ?Sized,
99    {
100        self.map.range((Bound::Included(value), Bound::Included(value))).next().map(|(k, _v)| k)
101    }
102
103    /// Inserts a value into the set. Returns true if the value was not already present.
104    ///
105    /// Complexity: `O(log n)` search time, plus `O(n)` time to insert the element if it is not present.
106    pub fn insert(&mut self, value: T) -> bool
107    where
108        T: Ord,
109    {
110        self.map.insert(value, ()).is_none()
111    }
112
113    /// Removes a value from the set. Returns true if the value was present.
114    ///
115    /// Complexity: `O(log n)` search time, plus `O(n)` time to remove the element if it is present.
116    pub fn remove<Q>(&mut self, value: &Q) -> bool
117    where
118        T: Borrow<Q> + Ord,
119        Q: Ord + ?Sized,
120    {
121        self.map.remove(value).is_some()
122    }
123
124    /// Returns an iterator over the elements of the set, in sorted order.
125    pub fn iter(&self) -> Iter<'_, T> {
126        Iter { inner: self.map.keys() }
127    }
128
129    /// Constructs a double-ended iterator over a sub-range of elements in the set.
130    ///
131    /// Complexity: `O(log n)` to find the start and end of the range.
132    pub fn range<Q, R>(&self, range: R) -> Range<'_, T>
133    where
134        T: Borrow<Q> + Ord,
135        Q: Ord + ?Sized,
136        R: RangeBounds<Q>,
137    {
138        Range { inner: self.map.range(range) }
139    }
140
141    /// Returns an iterator yielding elements from both sets in sorted order, without duplicates.
142    ///
143    /// Complexity: `O(N + M)` where N is the number of elements in `self` and M is the number of elements in `other`.
144    pub fn union<'a>(&'a self, other: &'a Self) -> Union<'a, T>
145    where
146        T: Ord,
147    {
148        let mut iter1 = self.iter();
149        let mut iter2 = other.iter();
150        Union { next1: iter1.next(), next2: iter2.next(), iter1, iter2 }
151    }
152
153    /// Returns an iterator yielding elements in `self` that are not in `other`.
154    ///
155    /// Complexity: `O(N + M)` where N is the number of elements in `self` and M is the number of elements in `other`.
156    pub fn difference<'a>(&'a self, other: &'a Self) -> Difference<'a, T>
157    where
158        T: Ord,
159    {
160        let mut iter1 = self.iter();
161        let mut iter2 = other.iter();
162        Difference { next1: iter1.next(), next2: iter2.next(), iter1, iter2 }
163    }
164}
165
166impl<T: Debug> Debug for SortedVecSet<T> {
167    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
168        f.debug_set().entries(self.iter()).finish()
169    }
170}
171
172impl<T> Default for SortedVecSet<T> {
173    fn default() -> Self {
174        Self::new()
175    }
176}
177
178impl<T> From<SortedVecSet<T>> for Vec<T> {
179    fn from(set: SortedVecSet<T>) -> Self {
180        set.into_iter().collect()
181    }
182}
183
184impl<T: Ord> From<Vec<T>> for SortedVecSet<T> {
185    fn from(vec: Vec<T>) -> Self {
186        Self::from_iter(vec)
187    }
188}
189
190impl<T: Ord, const N: usize> From<[T; N]> for SortedVecSet<T> {
191    fn from(arr: [T; N]) -> Self {
192        Self::from_iter(arr)
193    }
194}
195
196impl<T: Ord> From<BTreeSet<T>> for SortedVecSet<T> {
197    fn from(set: BTreeSet<T>) -> Self {
198        Self::from_iter(set)
199    }
200}
201
202/// An iterator over the items of a `SortedVecSet`.
203pub struct Iter<'a, T> {
204    inner: Keys<'a, T, ()>,
205}
206
207impl<'a, T> Iterator for Iter<'a, T> {
208    type Item = &'a T;
209
210    fn next(&mut self) -> Option<Self::Item> {
211        self.inner.next()
212    }
213}
214
215/// An owning iterator over the items of a `SortedVecSet`.
216pub struct IntoIter<T> {
217    inner: std::vec::IntoIter<(T, ())>,
218}
219
220impl<T> Iterator for IntoIter<T> {
221    type Item = T;
222
223    fn next(&mut self) -> Option<Self::Item> {
224        self.inner.next().map(|(k, _v)| k)
225    }
226}
227
228impl<T> IntoIterator for SortedVecSet<T> {
229    type Item = T;
230    type IntoIter = IntoIter<T>;
231
232    fn into_iter(self) -> Self::IntoIter {
233        IntoIter { inner: self.map.into_iter() }
234    }
235}
236
237impl<'a, T> IntoIterator for &'a SortedVecSet<T> {
238    type Item = &'a T;
239    type IntoIter = Iter<'a, T>;
240
241    fn into_iter(self) -> Self::IntoIter {
242        self.iter()
243    }
244}
245
246impl<T: Ord> FromIterator<T> for SortedVecSet<T> {
247    /// Constructs a `SortedVecSet` from an iterator.
248    ///
249    /// Complexity: `O(n log n)` where n is the number of elements in the iterator,
250    /// or `O(n)` if the elements are already sorted.
251    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
252        SortedVecSetBuilder::from_iter(iter).build()
253    }
254}
255
256impl<T: Ord> Extend<T> for SortedVecSet<T> {
257    /// Extends the set with the contents of an iterator.
258    ///
259    /// Complexity: `O(n log n)` where n is the total number of elements, or `O(n)` if the
260    /// iterator yields elements in sorted order and they are all greater than the existing
261    /// elements.
262    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
263        self.map.extend(iter.into_iter().map(|v| (v, ())));
264    }
265}
266
267/// An iterator over a sub-range of items in a `SortedVecSet`.
268pub struct Range<'a, T> {
269    inner: MapIter<'a, T, ()>,
270}
271
272impl<'a, T> Iterator for Range<'a, T> {
273    type Item = &'a T;
274
275    fn next(&mut self) -> Option<Self::Item> {
276        self.inner.next().map(|(k, _v)| k)
277    }
278}
279
280impl<'a, T> DoubleEndedIterator for Range<'a, T> {
281    fn next_back(&mut self) -> Option<Self::Item> {
282        self.inner.next_back().map(|(k, _v)| k)
283    }
284}
285
286/// An iterator yielding elements from the union of two sets.
287pub struct Union<'a, T> {
288    iter1: Iter<'a, T>,
289    iter2: Iter<'a, T>,
290    next1: Option<&'a T>,
291    next2: Option<&'a T>,
292}
293
294impl<'a, T: Ord> Iterator for Union<'a, T> {
295    type Item = &'a T;
296
297    fn next(&mut self) -> Option<Self::Item> {
298        match (self.next1, self.next2) {
299            (Some(v1), Some(v2)) => match v1.cmp(v2) {
300                std::cmp::Ordering::Less => {
301                    let res = v1;
302                    self.next1 = self.iter1.next();
303                    Some(res)
304                }
305                std::cmp::Ordering::Equal => {
306                    let res = v1;
307                    self.next1 = self.iter1.next();
308                    self.next2 = self.iter2.next();
309                    Some(res)
310                }
311                std::cmp::Ordering::Greater => {
312                    let res = v2;
313                    self.next2 = self.iter2.next();
314                    Some(res)
315                }
316            },
317            (Some(v1), None) => {
318                let res = v1;
319                self.next1 = self.iter1.next();
320                Some(res)
321            }
322            (None, Some(v2)) => {
323                let res = v2;
324                self.next2 = self.iter2.next();
325                Some(res)
326            }
327            (None, None) => None,
328        }
329    }
330}
331
332/// An iterator yielding elements in one set that are not in another.
333pub struct Difference<'a, T> {
334    iter1: Iter<'a, T>,
335    iter2: Iter<'a, T>,
336    next1: Option<&'a T>,
337    next2: Option<&'a T>,
338}
339
340impl<'a, T: Ord> Iterator for Difference<'a, T> {
341    type Item = &'a T;
342
343    fn next(&mut self) -> Option<Self::Item> {
344        loop {
345            match (self.next1, self.next2) {
346                (Some(v1), Some(v2)) => match v1.cmp(v2) {
347                    std::cmp::Ordering::Less => {
348                        let res = v1;
349                        self.next1 = self.iter1.next();
350                        return Some(res);
351                    }
352                    std::cmp::Ordering::Equal => {
353                        self.next1 = self.iter1.next();
354                        self.next2 = self.iter2.next();
355                    }
356                    std::cmp::Ordering::Greater => {
357                        self.next2 = self.iter2.next();
358                    }
359                },
360                (Some(v1), None) => {
361                    let res = v1;
362                    self.next1 = self.iter1.next();
363                    return Some(res);
364                }
365                (None, _) => return None,
366            }
367        }
368    }
369}
370
371impl<T: serde::Serialize> serde::Serialize for SortedVecSet<T> {
372    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
373    where
374        S: serde::Serializer,
375    {
376        serializer.collect_seq(self.iter())
377    }
378}
379
380impl<'de, T> serde::Deserialize<'de> for SortedVecSet<T>
381where
382    T: Ord + serde::Deserialize<'de>,
383{
384    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
385    where
386        D: serde::Deserializer<'de>,
387    {
388        struct Visitor<T> {
389            _marker: std::marker::PhantomData<SortedVecSet<T>>,
390        }
391        impl<'de, T> serde::de::Visitor<'de> for Visitor<T>
392        where
393            T: Ord + serde::Deserialize<'de>,
394        {
395            type Value = SortedVecSet<T>;
396            fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
397                formatter.write_str("a sequence")
398            }
399            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
400            where
401                A: serde::de::SeqAccess<'de>,
402            {
403                let mut builder = match seq.size_hint() {
404                    Some(hint) => SortedVecSetBuilder::with_capacity(hint),
405                    None => SortedVecSetBuilder::new(),
406                };
407                while let Some(value) = seq.next_element()? {
408                    builder.insert(value);
409                }
410                Ok(builder.build())
411            }
412        }
413        deserializer.deserialize_seq(Visitor { _marker: std::marker::PhantomData })
414    }
415}
416
417/// A builder for `SortedVecSet`.
418pub struct SortedVecSetBuilder<T> {
419    map_builder: crate::sorted_vec_map::SortedVecMapBuilder<T, ()>,
420}
421
422impl<T> SortedVecSetBuilder<T> {
423    /// Creates a new, empty builder.
424    pub fn new() -> Self {
425        Self { map_builder: crate::sorted_vec_map::SortedVecMapBuilder::new() }
426    }
427
428    /// Creates a new builder with at least the specified capacity.
429    pub fn with_capacity(capacity: usize) -> Self {
430        Self { map_builder: crate::sorted_vec_map::SortedVecMapBuilder::with_capacity(capacity) }
431    }
432
433    /// Adds a value to the set.
434    ///
435    /// Complexity: `O(1)` time (amortized).
436    pub fn insert(&mut self, value: T) -> &mut Self
437    where
438        T: Ord,
439    {
440        self.map_builder.insert(value, ());
441        self
442    }
443
444    /// Builds the `SortedVecSet`.
445    ///
446    /// Complexity: `O(n)` time if already sorted, `O(n log n)` otherwise, where n is the number of
447    /// elements.
448    pub fn build(self) -> SortedVecSet<T>
449    where
450        T: Ord,
451    {
452        SortedVecSet { map: self.map_builder.build() }
453    }
454}
455
456impl<T: Ord> Extend<T> for SortedVecSetBuilder<T> {
457    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
458        self.map_builder.extend(iter.into_iter().map(|v| (v, ())));
459    }
460}
461
462impl<T: Ord> FromIterator<T> for SortedVecSetBuilder<T> {
463    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
464        let mut builder = Self::new();
465        builder.extend(iter);
466        builder
467    }
468}
469
470#[cfg(test)]
471mod tests {
472    use super::*;
473    use test_case::test_case;
474
475    #[test_case(0 => 0; "empty_set")]
476    #[test_case(10 => 10; "with_some_capacity")]
477    fn test_with_capacity(cap: usize) -> usize {
478        let set: SortedVecSet<i32> = SortedVecSet::with_capacity(cap);
479        set.capacity()
480    }
481
482    #[test_case(vec![], 1 => false; "empty_set")]
483    #[test_case(vec![1], 1 => true; "contains_element")]
484    #[test_case(vec![0, 1], 0 => true; "contains_first")]
485    #[test_case(vec![0, 1, 2], 3 => false; "does_not_contain")]
486    fn test_contains(initial: Vec<i32>, lookup: i32) -> bool {
487        let set: SortedVecSet<i32> = initial.into();
488        set.contains(&lookup)
489    }
490
491    #[test_case(vec![], 1 => None; "empty_set_get")]
492    #[test_case(vec![1], 1 => Some(1); "get_element")]
493    #[test_case(vec![0, 1], 0 => Some(0); "get_first")]
494    #[test_case(vec![0, 1, 2], 3 => None; "get_missing")]
495    fn test_get(initial: Vec<i32>, lookup: i32) -> Option<i32> {
496        let set: SortedVecSet<i32> = initial.into();
497        set.get(&lookup).copied()
498    }
499
500    #[test_case(vec![], 50 => (true, vec![50]); "insert_empty")]
501    #[test_case(vec![50], 47 => (true, vec![47, 50]); "insert_lesser")]
502    #[test_case(vec![47, 50], 48 => (true, vec![47, 48, 50]); "insert_middle")]
503    #[test_case(vec![47, 48, 50], 48 => (false, vec![47, 48, 50]); "insert_duplicate")]
504    fn test_insert(initial: Vec<i32>, value: i32) -> (bool, Vec<i32>) {
505        let mut set: SortedVecSet<i32> = initial.into();
506        let inserted = set.insert(value);
507        (inserted, set.into())
508    }
509
510    #[test_case(vec![], 1 => (false, vec![]); "remove_empty")]
511    #[test_case(vec![1], 1 => (true, vec![]); "remove_only_element")]
512    #[test_case(vec![0, 1], 0 => (true, vec![1]); "remove_first")]
513    #[test_case(vec![0, 1], 1 => (true, vec![0]); "remove_last")]
514    #[test_case(vec![0, 1], 2 => (false, vec![0, 1]); "remove_missing")]
515    fn test_remove(initial: Vec<i32>, to_remove: i32) -> (bool, Vec<i32>) {
516        let mut set: SortedVecSet<i32> = initial.into();
517        let ret = set.remove(&to_remove);
518        (ret, set.into())
519    }
520
521    #[test_case(vec![50, 47, 48, 50, 47], vec![47, 48, 50]; "duplicates_and_unsorted")]
522    #[test_case(vec![], vec![]; "empty")]
523    #[test_case(vec![1, 2, 3], vec![1, 2, 3]; "already_sorted")]
524    fn test_from_iter(input: Vec<i32>, expected: Vec<i32>) {
525        let set: SortedVecSet<i32> = input.into_iter().collect();
526        let actual: Vec<i32> = set.into();
527        assert_eq!(actual, expected);
528    }
529
530    #[test_case(vec![1, 2, 3], vec![1, 2, 3]; "simple_conversion")]
531    #[test_case(vec![], vec![]; "empty_conversion")]
532    fn test_into_vec(input: Vec<i32>, expected: Vec<i32>) {
533        let set: SortedVecSet<i32> = input.into();
534        let actual: Vec<i32> = set.into();
535        assert_eq!(actual, expected);
536    }
537
538    #[test_case(vec![3, 1, 2, 2], vec![1, 2, 3]; "removes_duplicates_and_sorts")]
539    #[test_case(vec![], vec![]; "empty_vec")]
540    fn test_from_vec(input: Vec<i32>, expected: Vec<i32>) {
541        let set: SortedVecSet<i32> = input.into();
542        let actual: Vec<i32> = set.into();
543        assert_eq!(actual, expected);
544    }
545
546    #[test_case([3, 1, 2, 2], vec![1, 2, 3]; "array_conversion")]
547    fn test_from_array(input: [i32; 4], expected: Vec<i32>) {
548        let set: SortedVecSet<i32> = input.into();
549        let actual: Vec<i32> = set.into();
550        assert_eq!(actual, expected);
551    }
552
553    #[test_case(vec![], None => 0; "empty_len")]
554    #[test_case(vec![], Some(1) => 1; "insert_into_empty_len")]
555    #[test_case(vec![1], Some(2) => 2; "insert_new_len")]
556    #[test_case(vec![1, 2], Some(1) => 2; "insert_duplicate_len")]
557    fn test_len(initial: Vec<i32>, to_insert: Option<i32>) -> usize {
558        let mut set: SortedVecSet<i32> = initial.into();
559        if let Some(v) = to_insert {
560            set.insert(v);
561        }
562        set.len()
563    }
564
565    #[test_case(vec![1, 2, 3], vec![3, 4, 5], vec![1, 2, 3, 4, 5]; "overlapping")]
566    #[test_case(vec![1, 2, 3], vec![4, 5, 6], vec![1, 2, 3, 4, 5, 6]; "disjoint")]
567    #[test_case(vec![1, 2, 3], vec![], vec![1, 2, 3]; "empty_rhs")]
568    #[test_case(vec![], vec![1, 2, 3], vec![1, 2, 3]; "empty_lhs")]
569    fn test_union(lhs: Vec<i32>, rhs: Vec<i32>, expected: Vec<i32>) {
570        let set1: SortedVecSet<i32> = lhs.into();
571        let set2: SortedVecSet<i32> = rhs.into();
572        let actual: Vec<i32> = set1.union(&set2).cloned().collect();
573        assert_eq!(actual, expected);
574    }
575
576    #[test_case(vec![1, 2, 3], vec![3, 4, 5], vec![1, 2]; "lhs_difference")]
577    #[test_case(vec![3, 4, 5], vec![1, 2, 3], vec![4, 5]; "rhs_difference")]
578    #[test_case(vec![1, 2, 3], vec![1, 2, 3], vec![]; "identical_sets")]
579    #[test_case(vec![1, 2, 3], vec![], vec![1, 2, 3]; "empty_rhs_diff")]
580    #[test_case(vec![], vec![1, 2, 3], vec![]; "empty_lhs_diff")]
581    fn test_difference(lhs: Vec<i32>, rhs: Vec<i32>, expected: Vec<i32>) {
582        let set1: SortedVecSet<i32> = lhs.into();
583        let set2: SortedVecSet<i32> = rhs.into();
584        let actual: Vec<i32> = set1.difference(&set2).cloned().collect();
585        assert_eq!(actual, expected);
586    }
587
588    #[test_case(vec![3, 1, 2], vec![1, 2, 3]; "btreeset_conversion")]
589    #[test_case(vec![], vec![]; "empty_btreeset")]
590    fn test_from_btreeset(input: Vec<i32>, expected: Vec<i32>) {
591        let btree_set: BTreeSet<i32> = input.into_iter().collect();
592        let set: SortedVecSet<i32> = btree_set.into();
593        let actual: Vec<i32> = set.into();
594        assert_eq!(actual, expected);
595    }
596
597    #[test_case(vec![56, 47, 53, 51, 49]; "normal_set")]
598    #[test_case(vec![]; "empty_set_serde")]
599    fn test_serialize_deserialize(input: Vec<i32>) {
600        let set: SortedVecSet<i32> = input.into_iter().collect();
601        let serialized = serde_json::to_vec(&set).unwrap();
602        let deserialized: SortedVecSet<i32> = serde_json::from_slice(&serialized).unwrap();
603        assert_eq!(set, deserialized);
604    }
605
606    #[test]
607    fn test_range() {
608        let entries = [1, 3, 5, 7];
609        let set = SortedVecSet::from(entries);
610        let expected = BTreeSet::from(entries);
611
612        for range in [
613            (Bound::Unbounded, Bound::Unbounded),
614            (Bound::Included(0), Bound::Unbounded),
615            (Bound::Included(1), Bound::Unbounded),
616            (Bound::Included(2), Bound::Unbounded),
617            (Bound::Included(8), Bound::Unbounded),
618            (Bound::Included(1), Bound::Excluded(7)),
619            (Bound::Included(2), Bound::Excluded(6)),
620            (Bound::Included(3), Bound::Excluded(5)),
621            (Bound::Included(8), Bound::Excluded(10)),
622            (Bound::Included(0), Bound::Included(8)),
623            (Bound::Included(1), Bound::Included(7)),
624            (Bound::Included(3), Bound::Included(5)),
625            (Bound::Excluded(2), Bound::Unbounded),
626            (Bound::Excluded(3), Bound::Excluded(7)),
627        ] {
628            assert_eq!(
629                set.range(range.clone()).cloned().collect::<Vec<_>>(),
630                expected.range(range).cloned().collect::<Vec<_>>(),
631            );
632        }
633    }
634}
sorted_vec_map/sorted_vec_set.rs

sorted_vec_map/
sorted_vec_set.rs
