map_vec/
set.rs

1use alloc::vec::Vec;
2use core::{
3    borrow::Borrow,
4    fmt::{self, Debug},
5    iter::FusedIterator,
6    slice::Iter,
7};
8
9/// `Set` is a data structure with a [`HashSet`]-like API but based on a `Vec`.
10///
11/// It's primarily useful when you care about constant factors or prefer determinism to speed.
12/// Please refer to the docs for [`HashSet`] for details and examples of the Set API.
13///
14/// ## Example
15///
16/// ```
17/// let mut set1 = map_vec::Set::new();
18/// let mut set2 = map_vec::Set::new();
19/// set1.insert(1);
20/// set1.insert(2);
21/// set2.insert(2);
22/// set2.insert(3);
23/// let mut set3 = map_vec::Set::with_capacity(1);
24/// assert!(set3.insert(3));
25/// assert_eq!(&set2 - &set1, set3);
26/// ```
27///
28/// [`HashSet`]: std::collections::HashSet
29#[derive(Clone, PartialEq, Eq)]
30pub struct Set<T> {
31    backing: Vec<T>,
32}
33
34impl<T> Default for Set<T> {
35    fn default() -> Self {
36        Self {
37            backing: Vec::default(),
38        }
39    }
40}
41
42impl<T: Eq> Set<T> {
43    pub fn new() -> Self {
44        Self {
45            backing: Vec::new(),
46        }
47    }
48
49    pub fn with_capacity(capacity: usize) -> Self {
50        Self {
51            backing: Vec::with_capacity(capacity),
52        }
53    }
54
55    pub fn capacity(&self) -> usize {
56        self.backing.capacity()
57    }
58
59    pub fn clear(&mut self) {
60        self.backing.clear()
61    }
62
63    pub fn contains<Q>(&self, value: &Q) -> bool
64    where
65        T: Borrow<Q>,
66        Q: Eq + ?Sized,
67    {
68        self.backing.iter().any(|v| value.eq(v.borrow()))
69    }
70
71    pub fn difference<'a>(&'a self, other: &'a Self) -> Difference<'a, T> {
72        Difference {
73            iter: self.iter(),
74            other,
75        }
76    }
77
78    pub fn drain(&mut self) -> alloc::vec::Drain<T> {
79        self.backing.drain(..)
80    }
81
82    pub fn get<Q>(&self, value: &Q) -> Option<&T>
83    where
84        T: Borrow<Q>,
85        Q: Eq + ?Sized,
86    {
87        self.backing.iter().find(|v| value.eq((*v).borrow()))
88    }
89
90    pub fn get_or_insert(&mut self, value: T) -> &T {
91        // TODO: One day, rustc will be smart enough for this.
92        // Needs Polonius to complete the non-lexical lifetimes (NLL).
93        // https://blog.rust-lang.org/2022/08/05/nll-by-default.html
94        //
95        // match self.get(&value) {
96        //     Some(existing) => existing,
97        //     None => {
98        //         self.backing.push(value);
99        //         self.backing.last().unwrap()
100        //     }
101        // }
102
103        let self_ptr = self as *mut Self;
104
105        if let Some(value) = self.get(&value) {
106            return value;
107        }
108
109        // SAFETY: self_ptr is not null and is not otherwise borrowed.
110        // This is needed until the NLL-related solution above works in stable Rust.
111        unsafe { (*self_ptr).backing.push(value) };
112
113        self.backing.last().unwrap()
114    }
115
116    pub fn get_or_insert_with<Q>(&mut self, value: &Q, f: impl FnOnce(&Q) -> T) -> &T
117    where
118        T: Borrow<Q>,
119        Q: Eq + ?Sized,
120    {
121        // TODO: One day, rustc will be smart enough for this.
122        //       https://stackoverflow.com/a/38031183/297468
123        // self.get(&value).unwrap_or_else(|| {
124        //     self.backing.push(f(value));
125        //     self.backing.last().unwrap()
126        // })
127
128        let self_ptr = self as *mut Self;
129
130        if let Some(value) = self.get(value) {
131            return value;
132        }
133
134        // SAFETY: self_ptr is not null and is not otherwise borrowed.
135        // This is needed until the NLL-related solution above works in stable Rust.
136        unsafe { (*self_ptr).backing.push(f(value)) };
137
138        self.backing.last().unwrap()
139    }
140
141    pub fn insert(&mut self, value: T) -> bool {
142        !self.backing.iter().any(|v| *v == value) && {
143            self.backing.push(value);
144            true
145        }
146    }
147
148    pub fn intersection<'a>(&'a self, other: &'a Self) -> Intersection<'a, T> {
149        Intersection {
150            iter: self.iter(),
151            other,
152        }
153    }
154
155    pub fn is_disjoint<'a>(&'a self, other: &'a Self) -> bool {
156        self.intersection(other).count() == 0
157    }
158
159    pub fn is_empty(&self) -> bool {
160        self.backing.is_empty()
161    }
162
163    pub fn is_subset(&self, other: &Self) -> bool {
164        self.len() <= other.len() && self.difference(other).count() == 0
165    }
166
167    pub fn is_superset(&self, other: &Self) -> bool {
168        other.is_subset(self)
169    }
170
171    pub fn iter(&self) -> Iter<T> {
172        self.backing.iter()
173    }
174
175    pub fn len(&self) -> usize {
176        self.backing.len()
177    }
178
179    pub fn remove<Q>(&mut self, value: &Q) -> bool
180    where
181        T: Borrow<Q>,
182        Q: Eq + ?Sized,
183    {
184        self.take(value).is_some()
185    }
186
187    pub fn replace(&mut self, value: T) -> Option<T> {
188        match self.backing.iter_mut().find(|v| **v == value) {
189            Some(v) => Some(core::mem::replace(v, value)),
190            None => {
191                self.backing.push(value);
192                None
193            }
194        }
195    }
196
197    pub fn reserve(&mut self, additional: usize) {
198        self.backing.reserve(additional)
199    }
200
201    pub fn retain<F>(&mut self, f: F)
202    where
203        F: FnMut(&T) -> bool,
204    {
205        self.backing.retain(f);
206    }
207
208    pub fn shrink_to_fit(&mut self) {
209        self.backing.shrink_to_fit()
210    }
211
212    pub fn symmetric_difference<'a>(&'a self, other: &'a Self) -> SymmetricDifference<'a, T> {
213        SymmetricDifference {
214            iter: self.difference(other).chain(other.difference(self)),
215        }
216    }
217
218    pub fn take<Q>(&mut self, value: &Q) -> Option<T>
219    where
220        T: Borrow<Q>,
221        Q: Eq + ?Sized,
222    {
223        self.backing
224            .iter()
225            .position(|v| value.eq(v.borrow()))
226            .map(|pos| self.backing.swap_remove(pos))
227    }
228
229    pub fn union<'a>(&'a self, other: &'a Self) -> Union<'a, T> {
230        Union {
231            iter: self.iter().chain(other.difference(self)),
232        }
233    }
234
235    pub fn try_reserve(
236        &mut self,
237        additional: usize,
238    ) -> Result<(), alloc::collections::TryReserveError> {
239        self.backing.try_reserve(additional)
240    }
241
242    pub fn shrink_to(&mut self, min_capacity: usize) {
243        self.backing.shrink_to(min_capacity)
244    }
245}
246
247impl<T: Debug> fmt::Debug for Set<T> {
248    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
249        f.debug_set().entries(self.backing.iter()).finish()
250    }
251}
252
253impl<'a, T> IntoIterator for &'a Set<T> {
254    type Item = &'a T;
255    type IntoIter = core::slice::Iter<'a, T>;
256
257    fn into_iter(self) -> <Self as IntoIterator>::IntoIter {
258        self.backing.iter()
259    }
260}
261
262impl<'a, T> IntoIterator for &'a mut Set<T> {
263    type Item = &'a mut T;
264    type IntoIter = core::slice::IterMut<'a, T>;
265
266    fn into_iter(self) -> <Self as IntoIterator>::IntoIter {
267        self.backing.iter_mut()
268    }
269}
270
271impl<T> IntoIterator for Set<T> {
272    type Item = T;
273    type IntoIter = alloc::vec::IntoIter<T>;
274
275    fn into_iter(self) -> <Self as IntoIterator>::IntoIter {
276        self.backing.into_iter()
277    }
278}
279
280impl<T: Eq> FromIterator<T> for Set<T> {
281    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
282        let iter = iter.into_iter();
283
284        let mut this = match iter.size_hint() {
285            (min, Some(max)) if min > 0 && min == max => {
286                // Exact size is known. Reserve the space.
287                Self::with_capacity(min)
288            }
289            (min, Some(_)) | (min, None) if min > 0 => {
290                // The exact size is not known, but there's a minimum size known.
291                // We'll reserve what we know.
292                Self::with_capacity(min)
293            }
294            (_, _) => {
295                // There isn't even a minimum size known.
296                Self::new()
297            }
298        };
299
300        this.extend(iter);
301        this.shrink_to_fit();
302        this
303    }
304}
305
306impl<T: Eq> Extend<T> for Set<T> {
307    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
308        for item in iter {
309            self.insert(item);
310        }
311    }
312}
313
314impl<'a, T: 'a + Copy + Eq> Extend<&'a T> for Set<T> {
315    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
316        for item in iter {
317            self.insert(*item);
318        }
319    }
320}
321
322impl<V: Eq, T: Into<Vec<V>>> From<T> for Set<V> {
323    fn from(values: T) -> Self {
324        let values = values.into();
325        let mut map = Self::with_capacity(values.len());
326        map.extend(values);
327        map.shrink_to_fit();
328        map
329    }
330}
331
332impl<T: Clone + Eq> core::ops::BitOr<&Set<T>> for &Set<T> {
333    type Output = Set<T>;
334    fn bitor(self, rhs: &Set<T>) -> Set<T> {
335        self.union(rhs).cloned().collect()
336    }
337}
338
339impl<T: Clone + Eq> core::ops::BitAnd<&Set<T>> for &Set<T> {
340    type Output = Set<T>;
341    fn bitand(self, rhs: &Set<T>) -> Set<T> {
342        self.intersection(rhs).cloned().collect()
343    }
344}
345
346impl<T: Clone + Eq> core::ops::BitXor<&Set<T>> for &Set<T> {
347    type Output = Set<T>;
348    fn bitxor(self, rhs: &Set<T>) -> Set<T> {
349        self.symmetric_difference(rhs).cloned().collect()
350    }
351}
352
353impl<T: Clone + Eq> core::ops::Sub<&Set<T>> for &Set<T> {
354    type Output = Set<T>;
355    fn sub(self, rhs: &Set<T>) -> Set<T> {
356        self.difference(rhs).cloned().collect()
357    }
358}
359
360#[derive(Debug, Clone)]
361pub struct Difference<'a, T> {
362    iter: core::slice::Iter<'a, T>,
363    other: &'a Set<T>,
364}
365
366impl<'a, T> Iterator for Difference<'a, T>
367where
368    T: Eq,
369{
370    type Item = &'a T;
371
372    fn next(&mut self) -> Option<Self::Item> {
373        loop {
374            let elt = self.iter.next()?;
375            if !self.other.contains(elt) {
376                return Some(elt);
377            }
378        }
379    }
380
381    fn size_hint(&self) -> (usize, Option<usize>) {
382        let (_, upper) = self.iter.size_hint();
383        (0, upper)
384    }
385}
386
387impl<T> DoubleEndedIterator for Difference<'_, T>
388where
389    T: Eq,
390{
391    fn next_back(&mut self) -> Option<Self::Item> {
392        loop {
393            let elt = self.iter.next_back()?;
394            if !self.other.contains(elt) {
395                return Some(elt);
396            }
397        }
398    }
399}
400
401impl<T> FusedIterator for Difference<'_, T> where T: Eq {}
402
403#[derive(Debug, Clone)]
404pub struct Intersection<'a, T> {
405    iter: core::slice::Iter<'a, T>,
406    other: &'a Set<T>,
407}
408
409impl<'a, T> Iterator for Intersection<'a, T>
410where
411    T: Eq,
412{
413    type Item = &'a T;
414
415    fn next(&mut self) -> Option<Self::Item> {
416        loop {
417            let elt = self.iter.next()?;
418            if self.other.contains(elt) {
419                return Some(elt);
420            }
421        }
422    }
423
424    fn size_hint(&self) -> (usize, Option<usize>) {
425        let (_, upper) = self.iter.size_hint();
426        (0, upper)
427    }
428}
429
430impl<T> DoubleEndedIterator for Intersection<'_, T>
431where
432    T: Eq,
433{
434    fn next_back(&mut self) -> Option<Self::Item> {
435        loop {
436            let elt = self.iter.next_back()?;
437            if self.other.contains(elt) {
438                return Some(elt);
439            }
440        }
441    }
442}
443
444impl<T> FusedIterator for Intersection<'_, T> where T: Eq {}
445
446#[derive(Debug, Clone)]
447pub struct SymmetricDifference<'a, T> {
448    iter: core::iter::Chain<Difference<'a, T>, Difference<'a, T>>,
449}
450
451impl<'a, T> Iterator for SymmetricDifference<'a, T>
452where
453    T: Eq,
454{
455    type Item = &'a T;
456
457    fn next(&mut self) -> Option<Self::Item> {
458        self.iter.next()
459    }
460
461    fn size_hint(&self) -> (usize, Option<usize>) {
462        let (_, upper) = self.iter.size_hint();
463        (0, upper)
464    }
465}
466
467impl<T> DoubleEndedIterator for SymmetricDifference<'_, T>
468where
469    T: Eq,
470{
471    fn next_back(&mut self) -> Option<Self::Item> {
472        self.iter.next_back()
473    }
474}
475
476impl<T> FusedIterator for SymmetricDifference<'_, T> where T: Eq {}
477
478#[derive(Debug, Clone)]
479pub struct Union<'a, T> {
480    iter: core::iter::Chain<Iter<'a, T>, Difference<'a, T>>,
481}
482
483impl<'a, T> Iterator for Union<'a, T>
484where
485    T: Eq,
486{
487    type Item = &'a T;
488
489    fn next(&mut self) -> Option<Self::Item> {
490        self.iter.next()
491    }
492
493    fn size_hint(&self) -> (usize, Option<usize>) {
494        let (_, upper) = self.iter.size_hint();
495        (0, upper)
496    }
497}
498
499impl<T> DoubleEndedIterator for Union<'_, T>
500where
501    T: Eq,
502{
503    fn next_back(&mut self) -> Option<Self::Item> {
504        self.iter.next_back()
505    }
506}
507
508impl<T> FusedIterator for Union<'_, T> where T: Eq {}
509
510#[cfg(feature = "serde")]
511mod set_serde {
512    use core::{fmt, marker::PhantomData};
513
514    use serde::{
515        de::{SeqAccess, Visitor},
516        ser::SerializeSeq,
517        Deserialize, Deserializer, Serialize, Serializer,
518    };
519
520    use super::Set;
521
522    #[cfg_attr(any(docsrs, feature = "nightly"), doc(cfg(feature = "serde")))]
523    impl<T> Serialize for Set<T>
524    where
525        T: Serialize + Eq,
526    {
527        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
528        where
529            S: Serializer,
530        {
531            let mut seq = serializer.serialize_seq(Some(self.len()))?;
532            for item in self {
533                seq.serialize_element(item)?;
534            }
535            seq.end()
536        }
537    }
538
539    #[cfg_attr(any(docsrs, feature = "nightly"), doc(cfg(feature = "serde")))]
540    impl<'de, T> Deserialize<'de> for Set<T>
541    where
542        T: Deserialize<'de> + Eq,
543    {
544        /// If deserializing a sequence with duplicate values, only the first one will be kept.
545        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
546        where
547            D: Deserializer<'de>,
548        {
549            struct SetVisitor<T> {
550                marker: PhantomData<T>,
551            }
552
553            impl<'de, T> Visitor<'de> for SetVisitor<T>
554            where
555                T: Deserialize<'de> + Eq,
556            {
557                type Value = Set<T>;
558
559                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
560                    formatter.write_str("a sequence")
561                }
562
563                fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
564                where
565                    S: SeqAccess<'de>,
566                {
567                    let mut set = Set::with_capacity(seq.size_hint().unwrap_or(0));
568
569                    while let Some(item) = seq.next_element()? {
570                        set.get_or_insert(item);
571                    }
572
573                    Ok(set)
574                }
575            }
576
577            deserializer.deserialize_seq(SetVisitor {
578                marker: PhantomData,
579            })
580        }
581    }
582
583    #[cfg(test)]
584    mod test {
585        use pretty_assertions::assert_eq;
586
587        use super::Set;
588
589        #[test]
590        fn test_roundtrip() {
591            let s = Set::from(["one fish", "two fish", "red fish", "blue fish"]);
592
593            let json = serde_json::to_string(&s).unwrap();
594            assert_eq!(
595                json.as_str(),
596                r#"["one fish","two fish","red fish","blue fish"]"#
597            );
598
599            let s2: Set<&str> = serde_json::from_str(&json).unwrap();
600            assert_eq!(s2, s);
601        }
602
603        #[test]
604        fn test_deserialize() {
605            const INPUT: &str =
606                r#"["one fish","two fish","red fish","blue fish","red fish","third fish"]"#;
607
608            let m: Set<&str> = serde_json::from_str(INPUT).unwrap();
609            assert_eq!(
610                Set::from([
611                    "one fish",
612                    "two fish",
613                    "red fish",
614                    "blue fish",
615                    "third fish"
616                ]),
617                m,
618                "Duplicate keys should be deduplicated, and the first one should be kept."
619            );
620        }
621    }
622}
623
624// taken from libstd/collections/hash/set.rs @ 7454b2
625#[cfg(test)]
626mod test_set {
627    use pretty_assertions::assert_eq;
628
629    use super::Set;
630
631    #[test]
632    fn test_zero_capacities() {
633        type S = Set<i32>;
634
635        let s = S::new();
636        assert_eq!(s.capacity(), 0);
637
638        let s = S::default();
639        assert_eq!(s.capacity(), 0);
640
641        let s = S::with_capacity(0);
642        assert_eq!(s.capacity(), 0);
643
644        let mut s = S::new();
645        s.insert(1);
646        s.insert(2);
647        s.remove(&1);
648        s.remove(&2);
649        s.shrink_to_fit();
650        assert_eq!(s.capacity(), 0);
651
652        let mut s = S::new();
653        s.reserve(0);
654        assert_eq!(s.capacity(), 0);
655    }
656
657    #[test]
658    fn test_disjoint() {
659        let mut xs = Set::new();
660        let mut ys = Set::new();
661        assert!(xs.is_disjoint(&ys));
662        assert!(ys.is_disjoint(&xs));
663        assert!(xs.insert(5));
664        assert!(ys.insert(11));
665        assert!(xs.is_disjoint(&ys));
666        assert!(ys.is_disjoint(&xs));
667        assert!(xs.insert(7));
668        assert!(xs.insert(19));
669        assert!(xs.insert(4));
670        assert!(ys.insert(2));
671        assert!(ys.insert(-11));
672        assert!(xs.is_disjoint(&ys));
673        assert!(ys.is_disjoint(&xs));
674        assert!(ys.insert(7));
675        assert!(!xs.is_disjoint(&ys));
676        assert!(!ys.is_disjoint(&xs));
677    }
678
679    #[test]
680    fn test_subset_and_superset() {
681        let mut a = Set::new();
682        assert!(a.insert(0));
683        assert!(a.insert(5));
684        assert!(a.insert(11));
685        assert!(a.insert(7));
686
687        let mut b = Set::new();
688        assert!(b.insert(0));
689        assert!(b.insert(7));
690        assert!(b.insert(19));
691        assert!(b.insert(250));
692        assert!(b.insert(11));
693        assert!(b.insert(200));
694
695        assert!(!a.is_subset(&b));
696        assert!(!a.is_superset(&b));
697        assert!(!b.is_subset(&a));
698        assert!(!b.is_superset(&a));
699
700        assert!(b.insert(5));
701
702        assert!(a.is_subset(&b));
703        assert!(!a.is_superset(&b));
704        assert!(!b.is_subset(&a));
705        assert!(b.is_superset(&a));
706    }
707
708    #[test]
709    fn test_iterate() {
710        let mut a = Set::new();
711        for i in 0..32 {
712            assert!(a.insert(i));
713        }
714        assert_eq!(a.len(), 32);
715
716        let mut observed: u32 = 0;
717        // Ensure that we can iterate over the owned collection,
718        // and that the items are owned.
719        for k in a {
720            observed |= 1 << k;
721        }
722
723        assert_eq!(observed, 0xFFFF_FFFF);
724    }
725
726    #[test]
727    fn test_iterate_ref() {
728        let a = Set::from_iter(0..32);
729        assert_eq!(a.len(), 32);
730
731        let mut observed: u32 = 0;
732        // Ensure that we can iterate over the borrowed collection,
733        // and that the items are borrowed.
734        for &k in &a {
735            observed |= 1 << k;
736        }
737
738        assert_eq!(observed, 0xFFFF_FFFF);
739    }
740
741    #[test]
742    fn test_iterate_mut() {
743        let mut a: Set<_> = (0..32).collect();
744        assert_eq!(a.len(), 32);
745
746        let mut observed: u32 = 0;
747        // Ensure that we can iterate over the mutably borrowed collection,
748        // and that the items are mutably borrowed.
749        for &mut k in &mut a {
750            observed |= 1 << k;
751        }
752
753        assert_eq!(observed, 0xFFFF_FFFF);
754    }
755
756    #[test]
757    fn test_intersection() {
758        let mut a = Set::new();
759        let mut b = Set::new();
760        assert!(a.intersection(&b).next().is_none());
761
762        assert!(a.insert(11));
763        assert!(a.insert(1));
764        assert!(a.insert(3));
765        assert!(a.insert(77));
766        assert!(a.insert(103));
767        assert!(a.insert(5));
768        assert!(a.insert(-5));
769
770        assert!(b.insert(2));
771        assert!(b.insert(11));
772        assert!(b.insert(77));
773        assert!(b.insert(-9));
774        assert!(b.insert(-42));
775        assert!(b.insert(5));
776        assert!(b.insert(3));
777
778        let mut i = 0;
779        let expected = [3, 5, 11, 77];
780        for x in a.intersection(&b) {
781            assert!(expected.contains(x));
782            i += 1
783        }
784        assert_eq!(i, expected.len());
785
786        assert!(a.insert(9)); // make a bigger than b
787
788        i = 0;
789        for x in a.intersection(&b) {
790            assert!(expected.contains(x));
791            i += 1
792        }
793        assert_eq!(i, expected.len());
794
795        i = 0;
796        for x in b.intersection(&a) {
797            assert!(expected.contains(x));
798            i += 1
799        }
800        assert_eq!(i, expected.len());
801    }
802
803    #[test]
804    fn test_difference() {
805        let mut a = Set::new();
806        let mut b = Set::new();
807
808        assert!(a.insert(1));
809        assert!(a.insert(3));
810        assert!(a.insert(5));
811        assert!(a.insert(9));
812        assert!(a.insert(11));
813
814        assert!(b.insert(3));
815        assert!(b.insert(9));
816
817        let mut i = 0;
818        let expected = [1, 5, 11];
819        for x in a.difference(&b) {
820            assert!(expected.contains(x));
821            i += 1
822        }
823        assert_eq!(i, expected.len());
824    }
825
826    #[test]
827    fn test_symmetric_difference() {
828        let mut a = Set::new();
829        let mut b = Set::new();
830
831        assert!(a.insert(1));
832        assert!(a.insert(3));
833        assert!(a.insert(5));
834        assert!(a.insert(9));
835        assert!(a.insert(11));
836
837        assert!(b.insert(-2));
838        assert!(b.insert(3));
839        assert!(b.insert(9));
840        assert!(b.insert(14));
841        assert!(b.insert(22));
842
843        let mut i = 0;
844        let expected = [-2, 1, 5, 11, 14, 22];
845        for x in a.symmetric_difference(&b) {
846            assert!(expected.contains(x));
847            i += 1
848        }
849        assert_eq!(i, expected.len());
850    }
851
852    #[test]
853    fn test_union() {
854        let mut a = Set::new();
855        let mut b = Set::new();
856        assert!(a.union(&b).next().is_none());
857        assert!(b.union(&a).next().is_none());
858
859        assert!(a.insert(1));
860        assert!(a.insert(3));
861        assert!(a.insert(11));
862        assert!(a.insert(16));
863        assert!(a.insert(19));
864        assert!(a.insert(24));
865
866        assert!(b.insert(-2));
867        assert!(b.insert(1));
868        assert!(b.insert(5));
869        assert!(b.insert(9));
870        assert!(b.insert(13));
871        assert!(b.insert(19));
872
873        let mut i = 0;
874        let expected = [-2, 1, 3, 5, 9, 11, 13, 16, 19, 24];
875        for x in a.union(&b) {
876            assert!(expected.contains(x));
877            i += 1
878        }
879        assert_eq!(i, expected.len());
880
881        assert!(a.insert(9)); // make a bigger than b
882        assert!(a.insert(5));
883
884        i = 0;
885        for x in a.union(&b) {
886            assert!(expected.contains(x));
887            i += 1
888        }
889        assert_eq!(i, expected.len());
890
891        i = 0;
892        for x in b.union(&a) {
893            assert!(expected.contains(x));
894            i += 1
895        }
896        assert_eq!(i, expected.len());
897    }
898
899    #[test]
900    fn test_from_iter() {
901        let xs = [1, 2, 2, 3, 4, 5, 6, 7, 8, 9];
902
903        let set: Set<_> = xs.iter().cloned().collect();
904
905        for x in &xs {
906            assert!(set.contains(x));
907        }
908
909        // -1 because `2` is duplicated in the source array, and the collected
910        // `Set` will contain unique values.
911        assert_eq!(set.iter().len(), xs.len() - 1);
912    }
913
914    #[test]
915    fn test_move_iter() {
916        let hs = {
917            let mut hs = Set::new();
918
919            hs.insert('a');
920            hs.insert('b');
921
922            hs
923        };
924
925        let v = hs.into_iter().collect::<Vec<char>>();
926        assert!(v == ['a', 'b'] || v == ['b', 'a']);
927    }
928
929    #[test]
930    fn test_eq() {
931        // These constants once happened to expose a bug in insert().
932        // I'm keeping them around to prevent a regression.
933        let mut s1 = Set::new();
934
935        s1.insert(1);
936        s1.insert(2);
937        s1.insert(3);
938
939        let mut s2 = Set::new();
940
941        s2.insert(1);
942        s2.insert(2);
943
944        assert!(s1 != s2);
945
946        s2.insert(3);
947
948        assert_eq!(s1, s2);
949    }
950
951    #[test]
952    fn test_show() {
953        let mut set = Set::new();
954        let empty = Set::<i32>::new();
955
956        set.insert(1);
957        set.insert(2);
958
959        let set_str = format!("{:?}", set);
960
961        assert!(set_str == "{1, 2}" || set_str == "{2, 1}");
962        assert_eq!(format!("{:?}", empty), "{}");
963    }
964
965    #[test]
966    fn test_trivial_drain() {
967        let mut s = Set::<i32>::new();
968        for _ in s.drain() {}
969        assert!(s.is_empty());
970        drop(s);
971
972        let mut s = Set::<i32>::new();
973        drop(s.drain());
974        assert!(s.is_empty());
975    }
976
977    #[test]
978    fn test_drain() {
979        let mut s: Set<_> = (1..100).collect();
980
981        // try this a bunch of times to make sure we don't screw up internal state.
982        for _ in 0..20 {
983            assert_eq!(s.len(), 99);
984
985            {
986                let mut last_i = 0;
987                let mut d = s.drain();
988                for (i, x) in d.by_ref().take(50).enumerate() {
989                    last_i = i;
990                    assert!(x != 0);
991                }
992                assert_eq!(last_i, 49);
993            }
994
995            assert_eq!(s.iter().next(), None, "s should be empty!");
996
997            // reset to try again.
998            s.extend(1..100);
999        }
1000    }
1001
1002    #[test]
1003    fn test_replace() {
1004        #[derive(Debug)]
1005        struct Foo(&'static str, i32);
1006
1007        impl PartialEq for Foo {
1008            fn eq(&self, other: &Self) -> bool {
1009                self.0 == other.0
1010            }
1011        }
1012
1013        impl Eq for Foo {}
1014
1015        let mut s = Set::new();
1016        assert_eq!(s.replace(Foo("a", 1)), None);
1017        assert_eq!(s.len(), 1);
1018
1019        let existing = s
1020            .replace(Foo("a", 2))
1021            .expect("Did not get the existing item");
1022
1023        // Do _not_ use `assert_eq!(Foo("a", 1), existing)` here as the `PartialEq`
1024        // implementation only checks `Foo.0`, but we also need to check `Foo.1`.
1025        let Foo(a, b) = existing;
1026        assert_eq!(a, "a");
1027        assert_eq!(b, 1);
1028
1029        assert_eq!(s.len(), 1);
1030
1031        let mut it = s.iter();
1032
1033        // Do _not_ use `assert_eq!()` here as the `PartialEq` implementation
1034        // only checks `Foo.0`, but we also need to check `Foo.1`.
1035        let item = it.next().expect("Should get an item from the iterator");
1036        let &Foo(a, b) = item;
1037        assert_eq!(a, "a");
1038        assert_eq!(b, 2);
1039
1040        assert_eq!(it.next(), None, "Should be no more items in the iterator");
1041    }
1042
1043    #[test]
1044    fn test_extend_ref() {
1045        let mut a = Set::new();
1046        a.insert(1);
1047
1048        a.extend(&[2, 3, 4]);
1049
1050        assert_eq!(a.len(), 4);
1051        assert!(a.contains(&1));
1052        assert!(a.contains(&2));
1053        assert!(a.contains(&3));
1054        assert!(a.contains(&4));
1055
1056        let mut b = Set::new();
1057        b.insert(5);
1058        b.insert(6);
1059
1060        a.extend(&b);
1061
1062        assert_eq!(a.len(), 6);
1063        assert!(a.contains(&1));
1064        assert!(a.contains(&2));
1065        assert!(a.contains(&3));
1066        assert!(a.contains(&4));
1067        assert!(a.contains(&5));
1068        assert!(a.contains(&6));
1069    }
1070
1071    #[test]
1072    fn test_retain() {
1073        let xs = [1, 2, 3, 4, 5, 6];
1074        let mut set: Set<i32> = xs.iter().cloned().collect();
1075        set.retain(|&k| k % 2 == 0);
1076        assert_eq!(set.len(), 3);
1077        assert!(set.contains(&2));
1078        assert!(set.contains(&4));
1079        assert!(set.contains(&6));
1080    }
1081
1082    /// Ensures that, like `Vec`, `Default` works for `Set` even when its value
1083    /// type does not implement `Default`.
1084    #[test]
1085    fn test_default() {
1086        struct NoDefault;
1087
1088        let _: Vec<NoDefault> = Default::default();
1089        let _: Set<NoDefault> = Default::default();
1090    }
1091
1092    /// Ensures that things that can be turned `Into` a `Vec` can also be turned into a `Set`
1093    #[test]
1094    fn test_from_into_vec() {
1095        #[allow(
1096            clippy::useless_conversion,
1097            // reason = "Being consistent about the desired type"
1098        )]
1099        let _: Vec<()> = vec![()].into();
1100        let _: Set<()> = vec![()].into();
1101        let _: Vec<()> = [()].into();
1102        let _: Set<()> = [()].into();
1103
1104        let expected: Set<char> = ['a', 'b'].iter().copied().collect();
1105        let actual: Set<char> = ['a', 'b', 'a'].into();
1106        assert_eq!(expected, actual, "Values should be de-duped");
1107    }
1108}
map_vec/set.rs

map_vec/
set.rs
