Add {min,max}_set(_by{_key)?)? functions (2) return Vec instead Option<Vec>

Author: phimuemue

src/extrema_set.rs

@@ -1,13 +1,13 @@
 /// Implementation guts for `min_set`, `min_set_by`, and `min_set_by_key`.
 pub fn min_set_impl<I, K, F, L>(mut it: I,
                                 mut key_for: F,
-                                mut lt: L) -> Option<Vec<I::Item>>
+                                mut lt: L) -> Vec<I::Item>
     where I: Iterator,
           F: FnMut(&I::Item) -> K,
           L: FnMut(&I::Item, &I::Item, &K, &K) -> bool,
 {
     let (mut result, mut current_key) = match it.next() {
-        None => return None,
+        None => return Vec::new(),
         Some(element) => {
             let key = key_for(&element);
             (vec![element], key)
@@ -25,13 +25,13 @@ pub fn min_set_impl<I, K, F, L>(mut it: I,
         }
     }
 
-    Some(result)
+    result
 }
 
 /// Implementation guts for `ax_set`, `max_set_by`, and `max_set_by_key`.
 pub fn max_set_impl<I, K, F, L>(it: I,
                                 key_for: F,
-                                mut lt: L) -> Option<Vec<I::Item>>
+                                mut lt: L) -> Vec<I::Item>
     where I: Iterator,
           F: FnMut(&I::Item) -> K,
           L: FnMut(&I::Item, &I::Item, &K, &K) -> bool,

src/lib.rs

@@ -2912,22 +2912,22 @@ pub trait Itertools : Iterator {
     /// use itertools::Itertools;
     ///
     /// let a: [i32; 0] = [];
-    /// assert_eq!(a.iter().min_set(), None);
+    /// assert_eq!(a.iter().min_set(), Vec::<&i32>::new());
     ///
     /// let a = [1];
-    /// assert_eq!(a.iter().min_set(), Some(vec![&1]));
+    /// assert_eq!(a.iter().min_set(), vec![&1]);
     ///
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().min_set(), Some(vec![&1]));
+    /// assert_eq!(a.iter().min_set(), vec![&1]);
     ///
     /// let a = [1, 1, 1, 1];
-    /// assert_eq!(a.iter().min_set(), Some(vec![&1, &1, &1, &1]));
+    /// assert_eq!(a.iter().min_set(), vec![&1, &1, &1, &1]);
     /// ```
     ///
     /// The elements can be floats but no particular result is guaranteed
     /// if an element is NaN.
     #[cfg(feature = "use_std")]
-    fn min_set(self) -> Option<Vec<Self::Item>>
+    fn min_set(self) -> Vec<Self::Item>
         where Self: Sized, Self::Item: PartialOrd
     {
         extrema_set::min_set_impl(self, |_| (), |x, y, _, _| x < y)
@@ -2943,22 +2943,22 @@ pub trait Itertools : Iterator {
     /// use itertools::Itertools;
     ///
     /// let a: [(i32, i32); 0] = [];
-    /// assert_eq!(a.iter().min_set_by(|_, _| Ordering::Equal), None);
+    /// assert_eq!(a.iter().min_set_by(|_, _| Ordering::Equal), Vec::<&(i32, i32)>::new());
     ///
     /// let a = [(1, 2)];
-    /// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2)]));
+    /// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2)]);
     ///
     /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
-    /// assert_eq!(a.iter().min_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), Some(vec![&(1, 2), &(2, 2)]));
+    /// assert_eq!(a.iter().min_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), vec![&(1, 2), &(2, 2)]);
     ///
     /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
-    /// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
+    /// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
     /// ```
     ///
     /// The elements can be floats but no particular result is guaranteed
     /// if an element is NaN.
     #[cfg(feature = "use_std")]
-    fn min_set_by<F>(self, mut compare: F) -> Option<Vec<Self::Item>>
+    fn min_set_by<F>(self, mut compare: F) -> Vec<Self::Item>
         where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering
     {
         extrema_set::min_set_impl(
@@ -2977,22 +2977,22 @@ pub trait Itertools : Iterator {
     /// use itertools::Itertools;
     ///
     /// let a: [(i32, i32); 0] = [];
-    /// assert_eq!(a.iter().min_set_by_key(|_| ()), None);
+    /// assert_eq!(a.iter().min_set_by_key(|_| ()), Vec::<&(i32, i32)>::new());
     ///
     /// let a = [(1, 2)];
-    /// assert_eq!(a.iter().min_set_by_key(|&&(k,_)| k), Some(vec![&(1, 2)]));
+    /// assert_eq!(a.iter().min_set_by_key(|&&(k,_)| k), vec![&(1, 2)]);
     ///
     /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
-    /// assert_eq!(a.iter().min_set_by_key(|&&(_, k)| k), Some(vec![&(1, 2), &(2, 2)]));
+    /// assert_eq!(a.iter().min_set_by_key(|&&(_, k)| k), vec![&(1, 2), &(2, 2)]);
     ///
     /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
-    /// assert_eq!(a.iter().min_set_by_key(|&&(k, _)| k), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
+    /// assert_eq!(a.iter().min_set_by_key(|&&(k, _)| k), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
     /// ```
     ///
     /// The elements can be floats but no particular result is guaranteed
     /// if an element is NaN.
     #[cfg(feature = "use_std")]
-    fn min_set_by_key<K, F>(self, key: F) -> Option<Vec<Self::Item>>
+    fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
         where Self: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K
     {
         extrema_set::min_set_impl(self, key, |_, _, kx, ky| kx < ky)
@@ -3006,22 +3006,22 @@ pub trait Itertools : Iterator {
     /// use itertools::Itertools;
     ///
     /// let a: [i32; 0] = [];
-    /// assert_eq!(a.iter().max_set(), None);
+    /// assert_eq!(a.iter().max_set(), Vec::<&i32>::new());
     ///
     /// let a = [1];
-    /// assert_eq!(a.iter().max_set(), Some(vec![&1]));
+    /// assert_eq!(a.iter().max_set(), vec![&1]);
     ///
     /// let a = [1, 2, 3, 4, 5];
-    /// assert_eq!(a.iter().max_set(), Some(vec![&5]));
+    /// assert_eq!(a.iter().max_set(), vec![&5]);
     ///
     /// let a = [1, 1, 1, 1];
-    /// assert_eq!(a.iter().max_set(), Some(vec![&1, &1, &1, &1]));
+    /// assert_eq!(a.iter().max_set(), vec![&1, &1, &1, &1]);
     /// ```
     ///
     /// The elements can be floats but no particular result is guaranteed
     /// if an element is NaN.
     #[cfg(feature = "use_std")]
-    fn max_set(self) -> Option<Vec<Self::Item>>
+    fn max_set(self) -> Vec<Self::Item>
         where Self: Sized, Self::Item: PartialOrd
     {
         extrema_set::max_set_impl(self, |_| (), |x, y, _, _| x < y)
@@ -3037,22 +3037,22 @@ pub trait Itertools : Iterator {
     /// use itertools::Itertools;
     ///
     /// let a: [(i32, i32); 0] = [];
-    /// assert_eq!(a.iter().max_set_by(|_, _| Ordering::Equal), None);
+    /// assert_eq!(a.iter().max_set_by(|_, _| Ordering::Equal), Vec::<&(i32, i32)>::new());
     ///
     /// let a = [(1, 2)];
-    /// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2)]));
+    /// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2)]);
     ///
     /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
-    /// assert_eq!(a.iter().max_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), Some(vec![&(3, 9), &(5, 9)]));
+    /// assert_eq!(a.iter().max_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), vec![&(3, 9), &(5, 9)]);
     ///
     /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
-    /// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
+    /// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
     /// ```
     ///
     /// The elements can be floats but no particular result is guaranteed
     /// if an element is NaN.
     #[cfg(feature = "use_std")]
-    fn max_set_by<F>(self, mut compare: F) -> Option<Vec<Self::Item>>
+    fn max_set_by<F>(self, mut compare: F) -> Vec<Self::Item>
         where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering
     {
         extrema_set::max_set_impl(
@@ -3071,22 +3071,22 @@ pub trait Itertools : Iterator {
     /// use itertools::Itertools;
     ///
     /// let a: [(i32, i32); 0] = [];
-    /// assert_eq!(a.iter().max_set_by_key(|_| ()), None);
+    /// assert_eq!(a.iter().max_set_by_key(|_| ()), Vec::<&(i32, i32)>::new());
     ///
     /// let a = [(1, 2)];
-    /// assert_eq!(a.iter().max_set_by_key(|&&(k,_)| k), Some(vec![&(1, 2)]));
+    /// assert_eq!(a.iter().max_set_by_key(|&&(k,_)| k), vec![&(1, 2)]);
     ///
     /// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
-    /// assert_eq!(a.iter().max_set_by_key(|&&(_, k)| k), Some(vec![&(3, 9), &(5, 9)]));
+    /// assert_eq!(a.iter().max_set_by_key(|&&(_, k)| k), vec![&(3, 9), &(5, 9)]);
     ///
     /// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
-    /// assert_eq!(a.iter().max_set_by_key(|&&(k, _)| k), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
+    /// assert_eq!(a.iter().max_set_by_key(|&&(k, _)| k), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
     /// ```
     ///
     /// The elements can be floats but no particular result is guaranteed
     /// if an element is NaN.
     #[cfg(feature = "use_std")]
-    fn max_set_by_key<K, F>(self, key: F) -> Option<Vec<Self::Item>>
+    fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
         where Self: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K
     {
         extrema_set::max_set_impl(self, key, |_, _, kx, ky| kx < ky)

tests/test_std.rs

@@ -1013,30 +1013,30 @@ fn extrema_set() {
         }
     }
 
-    assert_eq!(None::<Option<u32>>.iter().min_set(), None);
-    assert_eq!(None::<Option<u32>>.iter().max_set(), None);
+    assert_eq!(None::<u32>.iter().min_set(), Vec::<&u32>::new());
+    assert_eq!(None::<u32>.iter().max_set(), Vec::<&u32>::new());
 
-    assert_eq!(Some(1u32).iter().min_set(), Some(vec![&1]));
-    assert_eq!(Some(1u32).iter().max_set(), Some(vec![&1]));
+    assert_eq!(Some(1u32).iter().min_set(), vec![&1]);
+    assert_eq!(Some(1u32).iter().max_set(), vec![&1]);
 
     let data = vec![Val(0, 1), Val(2, 0), Val(0, 2), Val(1, 0), Val(2, 1)];
 
-    let min_set = data.iter().min_set().unwrap();
+    let min_set = data.iter().min_set();
     assert_eq!(min_set, vec![&Val(0, 1), &Val(0, 2)]);
 
-    let min_set_by_key = data.iter().min_set_by_key(|v| v.1).unwrap();
+    let min_set_by_key = data.iter().min_set_by_key(|v| v.1);
     assert_eq!(min_set_by_key, vec![&Val(2, 0), &Val(1, 0)]);
 
-    let min_set_by = data.iter().min_set_by(|x, y| x.1.cmp(&y.1)).unwrap();
+    let min_set_by = data.iter().min_set_by(|x, y| x.1.cmp(&y.1));
     assert_eq!(min_set_by, vec![&Val(2, 0), &Val(1, 0)]);
 
-    let max_set = data.iter().max_set().unwrap();
+    let max_set = data.iter().max_set();
     assert_eq!(max_set, vec![&Val(2, 0), &Val(2, 1)]);
 
-    let max_set_by_key = data.iter().max_set_by_key(|v| v.1).unwrap();
+    let max_set_by_key = data.iter().max_set_by_key(|v| v.1);
     assert_eq!(max_set_by_key, vec![&Val(0, 2)]);
 
-    let max_set_by = data.iter().max_set_by(|x, y| x.1.cmp(&y.1)).unwrap();
+    let max_set_by = data.iter().max_set_by(|x, y| x.1.cmp(&y.1));
     assert_eq!(max_set_by, vec![&Val(0, 2)]);
 }
 
@@ -1167,4 +1167,4 @@ fn multiunzip() {
     let (): () = [(), (), ()].iter().cloned().multiunzip();
     let t: (Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = [(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)].iter().cloned().multiunzip();    
     assert_eq!(t, (vec![0], vec![1], vec![2], vec![3], vec![4], vec![5], vec![6], vec![7], vec![8], vec![9], vec![10], vec![11]));
-}
+}