Skip to content

Commit e00e461

Browse files
author
Jorge Aparicio
committed
libcollections: convert TreeSet binops to by value
1 parent 3084604 commit e00e461

File tree

1 file changed

+100
-4
lines changed

1 file changed

+100
-4
lines changed

‎src/libcollections/tree/set.rs

+100-4
Original file line numberDiff line numberDiff line change
@@ -668,6 +668,8 @@ impl<'a, T: Ord> Iterator<&'a T> for UnionItems<'a, T> {
668668
}
669669

670670
#[unstable = "matches collection reform specification, waiting for dust to settle"]
671+
// NOTE(stage0): Remove impl after a snapshot
672+
#[cfg(stage0)]
671673
impl<T: Ord + Clone> BitOr<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
672674
/// Returns the union of `self` and `rhs` as a new `TreeSet<T>`.
673675
///
@@ -689,6 +691,30 @@ impl<T: Ord + Clone> BitOr<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
689691
}
690692

691693
#[unstable = "matches collection reform specification, waiting for dust to settle"]
694+
#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
695+
impl<'a, 'b, T: Ord + Clone> BitOr<&'b TreeSet<T>, TreeSet<T>> for &'a TreeSet<T> {
696+
/// Returns the union of `self` and `rhs` as a new `TreeSet<T>`.
697+
///
698+
/// # Examples
699+
///
700+
/// ```
701+
/// use std::collections::TreeSet;
702+
///
703+
/// let a: TreeSet<int> = vec![1, 2, 3].into_iter().collect();
704+
/// let b: TreeSet<int> = vec![3, 4, 5].into_iter().collect();
705+
///
706+
/// let set: TreeSet<int> = &a | &b;
707+
/// let v: Vec<int> = set.into_iter().collect();
708+
/// assert_eq!(v, vec![1, 2, 3, 4, 5]);
709+
/// ```
710+
fn bitor(self, rhs: &TreeSet<T>) -> TreeSet<T> {
711+
self.union(rhs).cloned().collect()
712+
}
713+
}
714+
715+
#[unstable = "matches collection reform specification, waiting for dust to settle"]
716+
// NOTE(stage0): Remove impl after a snapshot
717+
#[cfg(stage0)]
692718
impl<T: Ord + Clone> BitAnd<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
693719
/// Returns the intersection of `self` and `rhs` as a new `TreeSet<T>`.
694720
///
@@ -710,6 +736,30 @@ impl<T: Ord + Clone> BitAnd<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
710736
}
711737

712738
#[unstable = "matches collection reform specification, waiting for dust to settle"]
739+
#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
740+
impl<'a, 'b, T: Ord + Clone> BitAnd<&'b TreeSet<T>, TreeSet<T>> for &'a TreeSet<T> {
741+
/// Returns the intersection of `self` and `rhs` as a new `TreeSet<T>`.
742+
///
743+
/// # Examples
744+
///
745+
/// ```
746+
/// use std::collections::TreeSet;
747+
///
748+
/// let a: TreeSet<int> = vec![1, 2, 3].into_iter().collect();
749+
/// let b: TreeSet<int> = vec![2, 3, 4].into_iter().collect();
750+
///
751+
/// let set: TreeSet<int> = &a & &b;
752+
/// let v: Vec<int> = set.into_iter().collect();
753+
/// assert_eq!(v, vec![2, 3]);
754+
/// ```
755+
fn bitand(self, rhs: &TreeSet<T>) -> TreeSet<T> {
756+
self.intersection(rhs).cloned().collect()
757+
}
758+
}
759+
760+
#[unstable = "matches collection reform specification, waiting for dust to settle"]
761+
// NOTE(stage0): Remove impl after a snapshot
762+
#[cfg(stage0)]
713763
impl<T: Ord + Clone> BitXor<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
714764
/// Returns the symmetric difference of `self` and `rhs` as a new `TreeSet<T>`.
715765
///
@@ -731,6 +781,30 @@ impl<T: Ord + Clone> BitXor<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
731781
}
732782

733783
#[unstable = "matches collection reform specification, waiting for dust to settle"]
784+
#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
785+
impl<'a, 'b, T: Ord + Clone> BitXor<&'b TreeSet<T>, TreeSet<T>> for &'a TreeSet<T> {
786+
/// Returns the symmetric difference of `self` and `rhs` as a new `TreeSet<T>`.
787+
///
788+
/// # Examples
789+
///
790+
/// ```
791+
/// use std::collections::TreeSet;
792+
///
793+
/// let a: TreeSet<int> = vec![1, 2, 3].into_iter().collect();
794+
/// let b: TreeSet<int> = vec![3, 4, 5].into_iter().collect();
795+
///
796+
/// let set: TreeSet<int> = &a ^ &b;
797+
/// let v: Vec<int> = set.into_iter().collect();
798+
/// assert_eq!(v, vec![1, 2, 4, 5]);
799+
/// ```
800+
fn bitxor(self, rhs: &TreeSet<T>) -> TreeSet<T> {
801+
self.symmetric_difference(rhs).cloned().collect()
802+
}
803+
}
804+
805+
#[unstable = "matches collection reform specification, waiting for dust to settle"]
806+
// NOTE(stage0): Remove impl after a snapshot
807+
#[cfg(stage0)]
734808
impl<T: Ord + Clone> Sub<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
735809
/// Returns the difference of `self` and `rhs` as a new `TreeSet<T>`.
736810
///
@@ -751,6 +825,28 @@ impl<T: Ord + Clone> Sub<TreeSet<T>, TreeSet<T>> for TreeSet<T> {
751825
}
752826
}
753827

828+
#[unstable = "matches collection reform specification, waiting for dust to settle"]
829+
#[cfg(not(stage0))] // NOTE(stage0): Remove cfg after a snapshot
830+
impl<'a, 'b, T: Ord + Clone> Sub<&'b TreeSet<T>, TreeSet<T>> for &'a TreeSet<T> {
831+
/// Returns the difference of `self` and `rhs` as a new `TreeSet<T>`.
832+
///
833+
/// # Examples
834+
///
835+
/// ```
836+
/// use std::collections::TreeSet;
837+
///
838+
/// let a: TreeSet<int> = vec![1, 2, 3].into_iter().collect();
839+
/// let b: TreeSet<int> = vec![3, 4, 5].into_iter().collect();
840+
///
841+
/// let set: TreeSet<int> = &a - &b;
842+
/// let v: Vec<int> = set.into_iter().collect();
843+
/// assert_eq!(v, vec![1, 2]);
844+
/// ```
845+
fn sub(self, rhs: &TreeSet<T>) -> TreeSet<T> {
846+
self.difference(rhs).cloned().collect()
847+
}
848+
}
849+
754850
impl<T: Ord> FromIterator<T> for TreeSet<T> {
755851
fn from_iter<Iter: Iterator<T>>(iter: Iter) -> TreeSet<T> {
756852
let mut set = TreeSet::new();
@@ -1032,7 +1128,7 @@ mod test {
10321128
let a: TreeSet<int> = vec![1, 3, 5, 9, 11, 16, 19, 24].into_iter().collect();
10331129
let b: TreeSet<int> = vec![-2, 1, 5, 9, 13, 19].into_iter().collect();
10341130

1035-
let set: TreeSet<int> = a | b;
1131+
let set: TreeSet<int> = &a | &b;
10361132
let v: Vec<int> = set.into_iter().collect();
10371133
assert_eq!(v, vec![-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
10381134
}
@@ -1042,7 +1138,7 @@ mod test {
10421138
let a: TreeSet<int> = vec![11, 1, 3, 77, 103, 5, -5].into_iter().collect();
10431139
let b: TreeSet<int> = vec![2, 11, 77, -9, -42, 5, 3].into_iter().collect();
10441140

1045-
let set: TreeSet<int> = a & b;
1141+
let set: TreeSet<int> = &a & &b;
10461142
let v: Vec<int> = set.into_iter().collect();
10471143
assert_eq!(v, vec![3, 5, 11, 77]);
10481144
}
@@ -1052,7 +1148,7 @@ mod test {
10521148
let a: TreeSet<int> = vec![1, 3, 5, 9, 11].into_iter().collect();
10531149
let b: TreeSet<int> = vec![-2, 3, 9, 14, 22].into_iter().collect();
10541150

1055-
let set: TreeSet<int> = a ^ b;
1151+
let set: TreeSet<int> = &a ^ &b;
10561152
let v: Vec<int> = set.into_iter().collect();
10571153
assert_eq!(v, vec![-2, 1, 5, 11, 14, 22]);
10581154
}
@@ -1062,7 +1158,7 @@ mod test {
10621158
let a: TreeSet<int> = vec![-5, 11, 22, 33, 40, 42].into_iter().collect();
10631159
let b: TreeSet<int> = vec![-12, -5, 14, 23, 34, 38, 39, 50].into_iter().collect();
10641160

1065-
let set: TreeSet<int> = a - b;
1161+
let set: TreeSet<int> = &a - &b;
10661162
let v: Vec<int> = set.into_iter().collect();
10671163
assert_eq!(v, vec![11, 22, 33, 40, 42]);
10681164
}

0 commit comments

Comments
 (0)