Skip to content

Commit bb8b41a

Browse files
phimuemuephimuemue
committed
Add {min,max}_set(_by{_key)?)? functions (2) return Vec instead Option<Vec>
1 parent e8c67ef commit bb8b41a

File tree

3 files changed

+45
-45
lines changed

3 files changed

+45
-45
lines changed

‎src/extrema_set.rs

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,13 @@
11
/// Implementation guts for `min_set`, `min_set_by`, and `min_set_by_key`.
22
pub fn min_set_impl<I, K, F, L>(mut it: I,
33
mut key_for: F,
4-
mut lt: L) -> Option<Vec<I::Item>>
4+
mut lt: L) -> Vec<I::Item>
55
where I: Iterator,
66
F: FnMut(&I::Item) -> K,
77
L: FnMut(&I::Item, &I::Item, &K, &K) -> bool,
88
{
99
let (mut result, mut current_key) = match it.next() {
10-
None => return None,
10+
None => return Vec::new(),
1111
Some(element) => {
1212
let key = key_for(&element);
1313
(vec![element], key)
@@ -25,13 +25,13 @@ pub fn min_set_impl<I, K, F, L>(mut it: I,
2525
}
2626
}
2727

28-
Some(result)
28+
result
2929
}
3030

3131
/// Implementation guts for `ax_set`, `max_set_by`, and `max_set_by_key`.
3232
pub fn max_set_impl<I, K, F, L>(it: I,
3333
key_for: F,
34-
mut lt: L) -> Option<Vec<I::Item>>
34+
mut lt: L) -> Vec<I::Item>
3535
where I: Iterator,
3636
F: FnMut(&I::Item) -> K,
3737
L: FnMut(&I::Item, &I::Item, &K, &K) -> bool,

‎src/lib.rs

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -2912,22 +2912,22 @@ pub trait Itertools : Iterator {
29122912
/// use itertools::Itertools;
29132913
///
29142914
/// let a: [i32; 0] = [];
2915-
/// assert_eq!(a.iter().min_set(), None);
2915+
/// assert_eq!(a.iter().min_set(), Vec::<&i32>::new());
29162916
///
29172917
/// let a = [1];
2918-
/// assert_eq!(a.iter().min_set(), Some(vec![&1]));
2918+
/// assert_eq!(a.iter().min_set(), vec![&1]);
29192919
///
29202920
/// let a = [1, 2, 3, 4, 5];
2921-
/// assert_eq!(a.iter().min_set(), Some(vec![&1]));
2921+
/// assert_eq!(a.iter().min_set(), vec![&1]);
29222922
///
29232923
/// let a = [1, 1, 1, 1];
2924-
/// assert_eq!(a.iter().min_set(), Some(vec![&1, &1, &1, &1]));
2924+
/// assert_eq!(a.iter().min_set(), vec![&1, &1, &1, &1]);
29252925
/// ```
29262926
///
29272927
/// The elements can be floats but no particular result is guaranteed
29282928
/// if an element is NaN.
29292929
#[cfg(feature = "use_std")]
2930-
fn min_set(self) -> Option<Vec<Self::Item>>
2930+
fn min_set(self) -> Vec<Self::Item>
29312931
where Self: Sized, Self::Item: PartialOrd
29322932
{
29332933
extrema_set::min_set_impl(self, |_| (), |x, y, _, _| x < y)
@@ -2943,22 +2943,22 @@ pub trait Itertools : Iterator {
29432943
/// use itertools::Itertools;
29442944
///
29452945
/// let a: [(i32, i32); 0] = [];
2946-
/// assert_eq!(a.iter().min_set_by(|_, _| Ordering::Equal), None);
2946+
/// assert_eq!(a.iter().min_set_by(|_, _| Ordering::Equal), Vec::<&(i32, i32)>::new());
29472947
///
29482948
/// let a = [(1, 2)];
2949-
/// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2)]));
2949+
/// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2)]);
29502950
///
29512951
/// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
2952-
/// assert_eq!(a.iter().min_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), Some(vec![&(1, 2), &(2, 2)]));
2952+
/// assert_eq!(a.iter().min_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), vec![&(1, 2), &(2, 2)]);
29532953
///
29542954
/// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
2955-
/// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
2955+
/// assert_eq!(a.iter().min_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
29562956
/// ```
29572957
///
29582958
/// The elements can be floats but no particular result is guaranteed
29592959
/// if an element is NaN.
29602960
#[cfg(feature = "use_std")]
2961-
fn min_set_by<F>(self, mut compare: F) -> Option<Vec<Self::Item>>
2961+
fn min_set_by<F>(self, mut compare: F) -> Vec<Self::Item>
29622962
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering
29632963
{
29642964
extrema_set::min_set_impl(
@@ -2977,22 +2977,22 @@ pub trait Itertools : Iterator {
29772977
/// use itertools::Itertools;
29782978
///
29792979
/// let a: [(i32, i32); 0] = [];
2980-
/// assert_eq!(a.iter().min_set_by_key(|_| ()), None);
2980+
/// assert_eq!(a.iter().min_set_by_key(|_| ()), Vec::<&(i32, i32)>::new());
29812981
///
29822982
/// let a = [(1, 2)];
2983-
/// assert_eq!(a.iter().min_set_by_key(|&&(k,_)| k), Some(vec![&(1, 2)]));
2983+
/// assert_eq!(a.iter().min_set_by_key(|&&(k,_)| k), vec![&(1, 2)]);
29842984
///
29852985
/// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
2986-
/// assert_eq!(a.iter().min_set_by_key(|&&(_, k)| k), Some(vec![&(1, 2), &(2, 2)]));
2986+
/// assert_eq!(a.iter().min_set_by_key(|&&(_, k)| k), vec![&(1, 2), &(2, 2)]);
29872987
///
29882988
/// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
2989-
/// assert_eq!(a.iter().min_set_by_key(|&&(k, _)| k), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
2989+
/// assert_eq!(a.iter().min_set_by_key(|&&(k, _)| k), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
29902990
/// ```
29912991
///
29922992
/// The elements can be floats but no particular result is guaranteed
29932993
/// if an element is NaN.
29942994
#[cfg(feature = "use_std")]
2995-
fn min_set_by_key<K, F>(self, key: F) -> Option<Vec<Self::Item>>
2995+
fn min_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
29962996
where Self: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K
29972997
{
29982998
extrema_set::min_set_impl(self, key, |_, _, kx, ky| kx < ky)
@@ -3006,22 +3006,22 @@ pub trait Itertools : Iterator {
30063006
/// use itertools::Itertools;
30073007
///
30083008
/// let a: [i32; 0] = [];
3009-
/// assert_eq!(a.iter().max_set(), None);
3009+
/// assert_eq!(a.iter().max_set(), Vec::<&i32>::new());
30103010
///
30113011
/// let a = [1];
3012-
/// assert_eq!(a.iter().max_set(), Some(vec![&1]));
3012+
/// assert_eq!(a.iter().max_set(), vec![&1]);
30133013
///
30143014
/// let a = [1, 2, 3, 4, 5];
3015-
/// assert_eq!(a.iter().max_set(), Some(vec![&5]));
3015+
/// assert_eq!(a.iter().max_set(), vec![&5]);
30163016
///
30173017
/// let a = [1, 1, 1, 1];
3018-
/// assert_eq!(a.iter().max_set(), Some(vec![&1, &1, &1, &1]));
3018+
/// assert_eq!(a.iter().max_set(), vec![&1, &1, &1, &1]);
30193019
/// ```
30203020
///
30213021
/// The elements can be floats but no particular result is guaranteed
30223022
/// if an element is NaN.
30233023
#[cfg(feature = "use_std")]
3024-
fn max_set(self) -> Option<Vec<Self::Item>>
3024+
fn max_set(self) -> Vec<Self::Item>
30253025
where Self: Sized, Self::Item: PartialOrd
30263026
{
30273027
extrema_set::max_set_impl(self, |_| (), |x, y, _, _| x < y)
@@ -3037,22 +3037,22 @@ pub trait Itertools : Iterator {
30373037
/// use itertools::Itertools;
30383038
///
30393039
/// let a: [(i32, i32); 0] = [];
3040-
/// assert_eq!(a.iter().max_set_by(|_, _| Ordering::Equal), None);
3040+
/// assert_eq!(a.iter().max_set_by(|_, _| Ordering::Equal), Vec::<&(i32, i32)>::new());
30413041
///
30423042
/// let a = [(1, 2)];
3043-
/// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2)]));
3043+
/// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2)]);
30443044
///
30453045
/// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
3046-
/// assert_eq!(a.iter().max_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), Some(vec![&(3, 9), &(5, 9)]));
3046+
/// assert_eq!(a.iter().max_set_by(|&&(_,k1), &&(_,k2)| k1.cmp(&k2)), vec![&(3, 9), &(5, 9)]);
30473047
///
30483048
/// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
3049-
/// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
3049+
/// assert_eq!(a.iter().max_set_by(|&&(k1,_), &&(k2, _)| k1.cmp(&k2)), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
30503050
/// ```
30513051
///
30523052
/// The elements can be floats but no particular result is guaranteed
30533053
/// if an element is NaN.
30543054
#[cfg(feature = "use_std")]
3055-
fn max_set_by<F>(self, mut compare: F) -> Option<Vec<Self::Item>>
3055+
fn max_set_by<F>(self, mut compare: F) -> Vec<Self::Item>
30563056
where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering
30573057
{
30583058
extrema_set::max_set_impl(
@@ -3071,22 +3071,22 @@ pub trait Itertools : Iterator {
30713071
/// use itertools::Itertools;
30723072
///
30733073
/// let a: [(i32, i32); 0] = [];
3074-
/// assert_eq!(a.iter().max_set_by_key(|_| ()), None);
3074+
/// assert_eq!(a.iter().max_set_by_key(|_| ()), Vec::<&(i32, i32)>::new());
30753075
///
30763076
/// let a = [(1, 2)];
3077-
/// assert_eq!(a.iter().max_set_by_key(|&&(k,_)| k), Some(vec![&(1, 2)]));
3077+
/// assert_eq!(a.iter().max_set_by_key(|&&(k,_)| k), vec![&(1, 2)]);
30783078
///
30793079
/// let a = [(1, 2), (2, 2), (3, 9), (4, 8), (5, 9)];
3080-
/// assert_eq!(a.iter().max_set_by_key(|&&(_, k)| k), Some(vec![&(3, 9), &(5, 9)]));
3080+
/// assert_eq!(a.iter().max_set_by_key(|&&(_, k)| k), vec![&(3, 9), &(5, 9)]);
30813081
///
30823082
/// let a = [(1, 2), (1, 3), (1, 4), (1, 5)];
3083-
/// assert_eq!(a.iter().max_set_by_key(|&&(k, _)| k), Some(vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]));
3083+
/// assert_eq!(a.iter().max_set_by_key(|&&(k, _)| k), vec![&(1, 2), &(1, 3), &(1, 4), &(1, 5)]);
30843084
/// ```
30853085
///
30863086
/// The elements can be floats but no particular result is guaranteed
30873087
/// if an element is NaN.
30883088
#[cfg(feature = "use_std")]
3089-
fn max_set_by_key<K, F>(self, key: F) -> Option<Vec<Self::Item>>
3089+
fn max_set_by_key<K, F>(self, key: F) -> Vec<Self::Item>
30903090
where Self: Sized, K: PartialOrd, F: FnMut(&Self::Item) -> K
30913091
{
30923092
extrema_set::max_set_impl(self, key, |_, _, kx, ky| kx < ky)

‎tests/test_std.rs

Lines changed: 11 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1013,30 +1013,30 @@ fn extrema_set() {
10131013
}
10141014
}
10151015

1016-
assert_eq!(None::<Option<u32>>.iter().min_set(), None);
1017-
assert_eq!(None::<Option<u32>>.iter().max_set(), None);
1016+
assert_eq!(None::<u32>.iter().min_set(), Vec::<&u32>::new());
1017+
assert_eq!(None::<u32>.iter().max_set(), Vec::<&u32>::new());
10181018

1019-
assert_eq!(Some(1u32).iter().min_set(), Some(vec![&1]));
1020-
assert_eq!(Some(1u32).iter().max_set(), Some(vec![&1]));
1019+
assert_eq!(Some(1u32).iter().min_set(), vec![&1]);
1020+
assert_eq!(Some(1u32).iter().max_set(), vec![&1]);
10211021

10221022
let data = vec![Val(0, 1), Val(2, 0), Val(0, 2), Val(1, 0), Val(2, 1)];
10231023

1024-
let min_set = data.iter().min_set().unwrap();
1024+
let min_set = data.iter().min_set();
10251025
assert_eq!(min_set, vec![&Val(0, 1), &Val(0, 2)]);
10261026

1027-
let min_set_by_key = data.iter().min_set_by_key(|v| v.1).unwrap();
1027+
let min_set_by_key = data.iter().min_set_by_key(|v| v.1);
10281028
assert_eq!(min_set_by_key, vec![&Val(2, 0), &Val(1, 0)]);
10291029

1030-
let min_set_by = data.iter().min_set_by(|x, y| x.1.cmp(&y.1)).unwrap();
1030+
let min_set_by = data.iter().min_set_by(|x, y| x.1.cmp(&y.1));
10311031
assert_eq!(min_set_by, vec![&Val(2, 0), &Val(1, 0)]);
10321032

1033-
let max_set = data.iter().max_set().unwrap();
1033+
let max_set = data.iter().max_set();
10341034
assert_eq!(max_set, vec![&Val(2, 0), &Val(2, 1)]);
10351035

1036-
let max_set_by_key = data.iter().max_set_by_key(|v| v.1).unwrap();
1036+
let max_set_by_key = data.iter().max_set_by_key(|v| v.1);
10371037
assert_eq!(max_set_by_key, vec![&Val(0, 2)]);
10381038

1039-
let max_set_by = data.iter().max_set_by(|x, y| x.1.cmp(&y.1)).unwrap();
1039+
let max_set_by = data.iter().max_set_by(|x, y| x.1.cmp(&y.1));
10401040
assert_eq!(max_set_by, vec![&Val(0, 2)]);
10411041
}
10421042

@@ -1167,4 +1167,4 @@ fn multiunzip() {
11671167
let (): () = [(), (), ()].iter().cloned().multiunzip();
11681168
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();
11691169
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]));
1170-
}
1170+
}

0 commit comments

Comments
 (0)