From 17bdc0361fcf0c6000b71ba3a46d657d8da1548a Mon Sep 17 00:00:00 2001 From: Adam Nemecek Date: Wed, 20 Dec 2023 10:41:06 -0800 Subject: [PATCH 1/7] use self --- benches/extra/zipslices.rs | 2 +- src/adaptors/multi_product.rs | 2 +- src/duplicates_impl.rs | 2 +- src/groupbylazy.rs | 2 +- src/kmerge_impl.rs | 4 ++-- src/lazy_buffer.rs | 4 ++-- src/tuple_impl.rs | 2 +- tests/quick.rs | 2 +- 8 files changed, 10 insertions(+), 10 deletions(-) diff --git a/benches/extra/zipslices.rs b/benches/extra/zipslices.rs index 5476c0cb8..feafce972 100644 --- a/benches/extra/zipslices.rs +++ b/benches/extra/zipslices.rs @@ -36,7 +36,7 @@ impl<'a, 'b, A, B> ZipSlices<&'a [A], &'b [B]> { #[inline(always)] pub fn new(a: &'a [A], b: &'b [B]) -> Self { let minl = cmp::min(a.len(), b.len()); - ZipSlices { + Self { t: a, u: b, len: minl, diff --git a/src/adaptors/multi_product.rs b/src/adaptors/multi_product.rs index ef7fadba8..d7a6eb275 100644 --- a/src/adaptors/multi_product.rs +++ b/src/adaptors/multi_product.rs @@ -139,7 +139,7 @@ where I::Item: Clone, { fn new(iter: I) -> Self { - MultiProductIter { + Self { cur: None, iter: iter.clone(), iter_orig: iter, diff --git a/src/duplicates_impl.rs b/src/duplicates_impl.rs index 71ed21841..e1c13b4bd 100644 --- a/src/duplicates_impl.rs +++ b/src/duplicates_impl.rs @@ -22,7 +22,7 @@ mod private { impl DuplicatesBy { pub(crate) fn new(iter: I, key_method: F) -> Self { - DuplicatesBy { + Self { iter, meta: Meta { used: HashMap::new(), diff --git a/src/groupbylazy.rs b/src/groupbylazy.rs index 6cf33838c..3d1bfab5e 100644 --- a/src/groupbylazy.rs +++ b/src/groupbylazy.rs @@ -29,7 +29,7 @@ struct ChunkIndex { impl ChunkIndex { #[inline(always)] fn new(size: usize) -> Self { - ChunkIndex { + Self { size, index: 0, key: 0, diff --git a/src/kmerge_impl.rs b/src/kmerge_impl.rs index c077cdda1..4660caf07 100644 --- a/src/kmerge_impl.rs +++ b/src/kmerge_impl.rs @@ -27,9 +27,9 @@ where I: Iterator, { /// Constructs a `HeadTail` from an `Iterator`. Returns `None` if the `Iterator` is empty. - fn new(mut it: I) -> Option> { + fn new(mut it: I) -> Option { let head = it.next(); - head.map(|h| HeadTail { head: h, tail: it }) + head.map(|h| Self { head: h, tail: it }) } /// Get the next element and update `head`, returning the old head in `Some`. diff --git a/src/lazy_buffer.rs b/src/lazy_buffer.rs index 38c7d405b..5cb039a63 100644 --- a/src/lazy_buffer.rs +++ b/src/lazy_buffer.rs @@ -14,8 +14,8 @@ impl LazyBuffer where I: Iterator, { - pub fn new(it: I) -> LazyBuffer { - LazyBuffer { + pub fn new(it: I) -> Self { + Self { it: it.fuse(), buffer: Vec::new(), } diff --git a/src/tuple_impl.rs b/src/tuple_impl.rs index 9cfb484af..ba839dff8 100644 --- a/src/tuple_impl.rs +++ b/src/tuple_impl.rs @@ -34,7 +34,7 @@ where T: HomogeneousTuple, { fn new(buf: T::Buffer) -> Self { - TupleBuffer { cur: 0, buf } + Self { cur: 0, buf } } } diff --git a/tests/quick.rs b/tests/quick.rs index 92d3f9f8e..0856fbdc4 100644 --- a/tests/quick.rs +++ b/tests/quick.rs @@ -108,7 +108,7 @@ where HK: HintKind, { fn new(it: Range, hint_kind: HK) -> Self { - Iter { + Self { iterator: it, fuse_flag: 0, hint_kind, From 7c7f1ff596f59aacd3b2d1704469199414eb1d56 Mon Sep 17 00:00:00 2001 From: Adam Nemecek Date: Wed, 20 Dec 2023 10:44:26 -0800 Subject: [PATCH 2/7] cargo fmt --- src/adaptors/coalesce.rs | 28 ++++++++------- src/adaptors/mod.rs | 11 +++--- src/lib.rs | 68 ++++++++++++++++++++---------------- src/minmax.rs | 23 ++++++------ src/permutations.rs | 11 +++--- src/size_hint.rs | 9 ++--- tests/adaptors_no_collect.rs | 9 ++--- tests/test_core.rs | 12 ++++--- tests/test_std.rs | 39 +++++++++++---------- 9 files changed, 114 insertions(+), 96 deletions(-) diff --git a/src/adaptors/coalesce.rs b/src/adaptors/coalesce.rs index 21eaa016d..ff5f1dae3 100644 --- a/src/adaptors/coalesce.rs +++ b/src/adaptors/coalesce.rs @@ -50,13 +50,14 @@ where fn next(&mut self) -> Option { let Self { iter, last, f } = self; // this fuses the iterator - let init = match last { - Some(elt) => elt.take(), - None => { - *last = Some(None); - iter.next().map(C::new) - } - }?; + let init = + match last { + Some(elt) => elt.take(), + None => { + *last = Some(None); + iter.next().map(C::new) + } + }?; Some( iter.try_fold(init, |accum, next| match f.coalesce_pair(accum, next) { @@ -88,12 +89,13 @@ where mut f, } = self; if let Some(last) = last.unwrap_or_else(|| iter.next().map(C::new)) { - let (last, acc) = iter.fold((last, acc), |(last, acc), elt| { - match f.coalesce_pair(last, elt) { - Ok(joined) => (joined, acc), - Err((last_, next_)) => (next_, fn_acc(acc, last_)), - } - }); + let (last, acc) = + iter.fold((last, acc), |(last, acc), elt| { + match f.coalesce_pair(last, elt) { + Ok(joined) => (joined, acc), + Err((last_, next_)) => (next_, fn_acc(acc, last_)), + } + }); fn_acc(acc, last) } else { acc diff --git a/src/adaptors/mod.rs b/src/adaptors/mod.rs index f622bceda..d995b5877 100644 --- a/src/adaptors/mod.rs +++ b/src/adaptors/mod.rs @@ -152,11 +152,12 @@ where let (next_lower, next_upper) = next_hint; let (combined_lower, combined_upper) = size_hint::mul_scalar(size_hint::min(curr_hint, next_hint), 2); - let lower = if curr_lower > next_lower { - combined_lower + 1 - } else { - combined_lower - }; + let lower = + if curr_lower > next_lower { + combined_lower + 1 + } else { + combined_lower + }; let upper = { let extra_elem = match (curr_upper, next_upper) { (_, None) => false, diff --git a/src/lib.rs b/src/lib.rs index f3b6e807d..f86d553b0 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2545,16 +2545,18 @@ pub trait Itertools: Iterator { // but half the useful tree_fold1 work is combining adjacent items, // so put that in a form that LLVM is more likely to optimize well. - let a = if let Some(v) = it.next() { - v - } else { - return Err(None); - }; - let b = if let Some(v) = it.next() { - v - } else { - return Err(Some(a)); - }; + let a = + if let Some(v) = it.next() { + v + } else { + return Err(None); + }; + let b = + if let Some(v) = it.next() { + v + } else { + return Err(Some(a)); + }; Ok(f(a, b)) } @@ -2638,14 +2640,15 @@ pub trait Itertools: Iterator { { use Result::{Err as Break, Ok as Continue}; - let result = self.try_fold( - init, - #[inline(always)] - |acc, v| match f(acc, v) { - FoldWhile::Continue(acc) => Continue(acc), - FoldWhile::Done(acc) => Break(acc), - }, - ); + let result = + self.try_fold( + init, + #[inline(always)] + |acc, v| match f(acc, v) { + FoldWhile::Continue(acc) => Continue(acc), + FoldWhile::Done(acc) => Break(acc), + }, + ); match result { Continue(acc) => FoldWhile::Continue(acc), @@ -3783,10 +3786,12 @@ pub trait Itertools: Iterator { { match self.next() { Some(first) => match self.next() { - Some(second) => Err(ExactlyOneError::new( - Some(Either::Left([first, second])), - self, - )), + Some(second) => { + Err(ExactlyOneError::new( + Some(Either::Left([first, second])), + self, + )) + } None => Ok(first), }, None => Err(ExactlyOneError::new(None, self)), @@ -3816,10 +3821,12 @@ pub trait Itertools: Iterator { { match self.next() { Some(first) => match self.next() { - Some(second) => Err(ExactlyOneError::new( - Some(Either::Left([first, second])), - self, - )), + Some(second) => { + Err(ExactlyOneError::new( + Some(Either::Left([first, second])), + self, + )) + } None => Ok(Some(first)), }, None => Ok(None), @@ -4012,10 +4019,11 @@ where match (ia.next(), ib.next()) { (None, None) => return, (a, b) => { - let equal = match (&a, &b) { - (&Some(ref a), &Some(ref b)) => a == b, - _ => false, - }; + let equal = + match (&a, &b) { + (&Some(ref a), &Some(ref b)) => a == b, + _ => false, + }; assert!( equal, "Failed assertion {a:?} == {b:?} for iteration {i}", diff --git a/src/minmax.rs b/src/minmax.rs index f04e5adba..4fee5ccd8 100644 --- a/src/minmax.rs +++ b/src/minmax.rs @@ -77,18 +77,19 @@ where None => break, Some(x) => x, }; - let second = match it.next() { - None => { - let first_key = key_for(&first); - if lt(&first, &min, &first_key, &min_key) { - min = first; - } else if !lt(&first, &max, &first_key, &max_key) { - max = first; + let second = + match it.next() { + None => { + let first_key = key_for(&first); + if lt(&first, &min, &first_key, &min_key) { + min = first; + } else if !lt(&first, &max, &first_key, &max_key) { + max = first; + } + break; } - break; - } - Some(x) => x, - }; + Some(x) => x, + }; let first_key = key_for(&first); let second_key = key_for(&second); if !lt(&second, &first, &second_key, &first_key) { diff --git a/src/permutations.rs b/src/permutations.rs index 534ca59c9..8b303c127 100644 --- a/src/permutations.rs +++ b/src/permutations.rs @@ -157,11 +157,12 @@ fn advance(indices: &mut [usize], cycles: &mut [usize]) -> bool { impl PermutationState { fn size_hint_for(&self, n: usize) -> SizeHint { // At the beginning, there are `n!/(n-k)!` items to come. - let at_start = |n, k| { - debug_assert!(n >= k); - let total = (n - k + 1..=n).try_fold(1usize, |acc, i| acc.checked_mul(i)); - (total.unwrap_or(usize::MAX), total) - }; + let at_start = + |n, k| { + debug_assert!(n >= k); + let total = (n - k + 1..=n).try_fold(1usize, |acc, i| acc.checked_mul(i)); + (total.unwrap_or(usize::MAX), total) + }; match *self { Self::Start { k } if n < k => (0, Some(0)), Self::Start { k } => at_start(n, k), diff --git a/src/size_hint.rs b/src/size_hint.rs index 857e0c4c6..9799d5bd2 100644 --- a/src/size_hint.rs +++ b/src/size_hint.rs @@ -80,10 +80,11 @@ pub fn min(a: SizeHint, b: SizeHint) -> SizeHint { let (a_lower, a_upper) = a; let (b_lower, b_upper) = b; let lower = cmp::min(a_lower, b_lower); - let upper = match (a_upper, b_upper) { - (Some(u1), Some(u2)) => Some(cmp::min(u1, u2)), - _ => a_upper.or(b_upper), - }; + let upper = + match (a_upper, b_upper) { + (Some(u1), Some(u2)) => Some(cmp::min(u1, u2)), + _ => a_upper.or(b_upper), + }; (lower, upper) } diff --git a/tests/adaptors_no_collect.rs b/tests/adaptors_no_collect.rs index 977224af2..bb2ac5133 100644 --- a/tests/adaptors_no_collect.rs +++ b/tests/adaptors_no_collect.rs @@ -26,10 +26,11 @@ where A: Iterator, T: Fn(PanickingCounter) -> A, { - let counter = PanickingCounter { - curr: 0, - max: 10_000, - }; + let counter = + PanickingCounter { + curr: 0, + max: 10_000, + }; let adaptor = to_adaptor(counter); for _ in adaptor.take(5) {} diff --git a/tests/test_core.rs b/tests/test_core.rs index c624a7e33..32d6fe8ab 100644 --- a/tests/test_core.rs +++ b/tests/test_core.rs @@ -32,11 +32,13 @@ fn product2() { #[test] fn product_temporary() { - for (_x, _y, _z) in iproduct!( - [0, 1, 2].iter().cloned(), - [0, 1, 2].iter().cloned(), - [0, 1, 2].iter().cloned() - ) { + for (_x, _y, _z) in + iproduct!( + [0, 1, 2].iter().cloned(), + [0, 1, 2].iter().cloned(), + [0, 1, 2].iter().cloned() + ) + { // ok } } diff --git a/tests/test_std.rs b/tests/test_std.rs index 732be7b7d..16fc9237d 100644 --- a/tests/test_std.rs +++ b/tests/test_std.rs @@ -246,13 +246,14 @@ fn dedup_by_with_count() { (0, 3), (1, 3), ]; - let ys = [ - (1, &(0, 0)), - (3, &(0, 1)), - (1, &(0, 2)), - (1, &(3, 1)), - (2, &(0, 3)), - ]; + let ys = + [ + (1, &(0, 0)), + (3, &(0, 1)), + (1, &(0, 2)), + (1, &(3, 1)), + (2, &(0, 3)), + ]; it::assert_equal( ys.iter().cloned(), @@ -1378,18 +1379,18 @@ fn while_some() { fn fold_while() { let mut iterations = 0; let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - let sum = vec - .into_iter() - .fold_while(0, |acc, item| { - iterations += 1; - let new_sum = acc + item; - if new_sum <= 20 { - FoldWhile::Continue(new_sum) - } else { - FoldWhile::Done(acc) - } - }) - .into_inner(); + let sum = + vec.into_iter() + .fold_while(0, |acc, item| { + iterations += 1; + let new_sum = acc + item; + if new_sum <= 20 { + FoldWhile::Continue(new_sum) + } else { + FoldWhile::Done(acc) + } + }) + .into_inner(); assert_eq!(iterations, 6); assert_eq!(sum, 15); } From 10cca5971c27dd61abd8ac758bda81d02382ac40 Mon Sep 17 00:00:00 2001 From: Adam Nemecek Date: Wed, 20 Dec 2023 12:38:07 -0800 Subject: [PATCH 3/7] refactored inner0 --- src/lib.rs | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index f86d553b0..c6654d6ae 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2545,18 +2545,14 @@ pub trait Itertools: Iterator { // but half the useful tree_fold1 work is combining adjacent items, // so put that in a form that LLVM is more likely to optimize well. - let a = - if let Some(v) = it.next() { - v - } else { - return Err(None); - }; - let b = - if let Some(v) = it.next() { - v - } else { - return Err(Some(a)); - }; + let Some(a) = it.next() else { + return Err(None); + }; + + let Some(b) = it.next() else { + return Err(Some(a)); + }; + Ok(f(a, b)) } From 0a3381baae894627cbe23ed9521d7c27ff3e0615 Mon Sep 17 00:00:00 2001 From: Adam Nemecek Date: Wed, 20 Dec 2023 12:41:32 -0800 Subject: [PATCH 4/7] use Self --- src/adaptors/mod.rs | 2 +- src/duplicates_impl.rs | 4 ++-- src/zip_longest.rs | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/adaptors/mod.rs b/src/adaptors/mod.rs index d995b5877..3866dfcc3 100644 --- a/src/adaptors/mod.rs +++ b/src/adaptors/mod.rs @@ -219,7 +219,7 @@ where /// Split the `PutBack` into its parts. #[inline] pub fn into_parts(self) -> (Option, I) { - let PutBack { top, iter } = self; + let Self { top, iter } = self; (top, iter) } diff --git a/src/duplicates_impl.rs b/src/duplicates_impl.rs index e1c13b4bd..a0db15432 100644 --- a/src/duplicates_impl.rs +++ b/src/duplicates_impl.rs @@ -77,7 +77,7 @@ mod private { type Item = I::Item; fn next(&mut self) -> Option { - let DuplicatesBy { iter, meta } = self; + let Self { iter, meta } = self; iter.find_map(|v| meta.filter(v)) } @@ -109,7 +109,7 @@ mod private { F: KeyMethod, { fn next_back(&mut self) -> Option { - let DuplicatesBy { iter, meta } = self; + let Self { iter, meta } = self; iter.rev().find_map(|v| meta.filter(v)) } } diff --git a/src/zip_longest.rs b/src/zip_longest.rs index 27d9f3ab6..e53733542 100644 --- a/src/zip_longest.rs +++ b/src/zip_longest.rs @@ -59,7 +59,7 @@ where Self: Sized, F: FnMut(B, Self::Item) -> B, { - let ZipLongest { a, mut b } = self; + let Self { a, mut b } = self; init = a.fold(init, |init, a| match b.next() { Some(b) => f(init, EitherOrBoth::Both(a, b)), None => f(init, EitherOrBoth::Left(a)), From 4394f1271e964cb1d72092310d5786e35e8cd255 Mon Sep 17 00:00:00 2001 From: Adam Nemecek Date: Wed, 20 Dec 2023 12:43:51 -0800 Subject: [PATCH 5/7] use vec![] --- benches/bench1.rs | 2 +- examples/iris.rs | 2 +- src/extrema_set.rs | 2 +- src/free.rs | 4 ++-- src/groupbylazy.rs | 8 ++++---- src/lazy_buffer.rs | 2 +- src/lib.rs | 10 +++++----- src/permutations.rs | 2 +- src/put_back_n_impl.rs | 2 +- tests/quick.rs | 14 +++++++------- tests/test_std.rs | 12 ++++++------ 11 files changed, 30 insertions(+), 30 deletions(-) diff --git a/benches/bench1.rs b/benches/bench1.rs index b01b8f360..8da06a128 100644 --- a/benches/bench1.rs +++ b/benches/bench1.rs @@ -590,7 +590,7 @@ fn kmerge_tenway(c: &mut Criterion) { *elt = rng(&mut state); } - let mut chunks = Vec::new(); + let mut chunks = vec![]; let mut rest = &mut data[..]; while rest.len() > 0 { let chunk_len = 1 + rng(&mut state) % 512; diff --git a/examples/iris.rs b/examples/iris.rs index af64322d6..ba347c834 100644 --- a/examples/iris.rs +++ b/examples/iris.rs @@ -58,7 +58,7 @@ fn main() { let irises = DATA .lines() .map(str::parse) - .fold_ok(Vec::new(), |mut v, iris: Iris| { + .fold_ok(vec![], |mut v, iris: Iris| { v.push(iris); v }); diff --git a/src/extrema_set.rs b/src/extrema_set.rs index d24114c6d..d288a9fd7 100644 --- a/src/extrema_set.rs +++ b/src/extrema_set.rs @@ -14,7 +14,7 @@ where Compare: FnMut(&I::Item, &I::Item, &K, &K) -> Ordering, { match it.next() { - None => Vec::new(), + None => vec![], Some(element) => { let mut current_key = key_for(&element); let mut result = vec![element]; diff --git a/src/free.rs b/src/free.rs index 5ce1b49b3..7b05a6722 100644 --- a/src/free.rs +++ b/src/free.rs @@ -112,7 +112,7 @@ where /// ``` /// use itertools::zip; /// -/// let mut result: Vec<(i32, char)> = Vec::new(); +/// let mut result: Vec<(i32, char)> = vec![]; /// /// for (a, b) in zip(&[1, 2, 3, 4, 5], &['a', 'b', 'c']) { /// result.push((*a, *b)); @@ -139,7 +139,7 @@ where /// ``` /// use itertools::chain; /// -/// let mut result:Vec = Vec::new(); +/// let mut result:Vec = vec![]; /// /// for element in chain(&[1, 2, 3], &[4]) { /// result.push(*element); diff --git a/src/groupbylazy.rs b/src/groupbylazy.rs index 3d1bfab5e..1403aeaf0 100644 --- a/src/groupbylazy.rs +++ b/src/groupbylazy.rs @@ -163,7 +163,7 @@ where // Because the `Groups` iterator is always the first to request // each group index, client is the next index efter top_group. debug_assert!(self.top_group + 1 == client); - let mut group = Vec::new(); + let mut group = vec![]; if let Some(elt) = self.current_elt.take() { if self.top_group != self.dropped_group { @@ -207,7 +207,7 @@ where self.bottom_group += 1; self.oldest_buffered_group += 1; } else { - self.buffer.push(Vec::new().into_iter()); + self.buffer.push(vec![].into_iter()); } } self.buffer.push(group.into_iter()); @@ -322,7 +322,7 @@ where top_group: 0, oldest_buffered_group: 0, bottom_group: 0, - buffer: Vec::new(), + buffer: vec![], dropped_group: !0, }), index: Cell::new(0), @@ -463,7 +463,7 @@ where top_group: 0, oldest_buffered_group: 0, bottom_group: 0, - buffer: Vec::new(), + buffer: vec![], dropped_group: !0, }), index: Cell::new(0), diff --git a/src/lazy_buffer.rs b/src/lazy_buffer.rs index 5cb039a63..db5fe853e 100644 --- a/src/lazy_buffer.rs +++ b/src/lazy_buffer.rs @@ -17,7 +17,7 @@ where pub fn new(it: I) -> Self { Self { it: it.fuse(), - buffer: Vec::new(), + buffer: vec![], } } diff --git a/src/lib.rs b/src/lib.rs index c6654d6ae..21265bf1f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -599,7 +599,7 @@ pub trait Itertools: Iterator { /// /// // Note: The `&` is significant here, `GroupBy` is iterable /// // only by reference. You can also call `.into_iter()` explicitly. - /// let mut data_grouped = Vec::new(); + /// let mut data_grouped = vec![]; /// for (key, group) in &data.into_iter().group_by(|elt| *elt >= 0) { /// data_grouped.push((key, group.collect())); /// } @@ -660,7 +660,7 @@ pub trait Itertools: Iterator { /// /// ``` /// use itertools::Itertools; - /// let mut v = Vec::new(); + /// let mut v = vec![]; /// /// // pairwise iteration /// for (a, b) in (1..5).tuple_windows() { @@ -703,7 +703,7 @@ pub trait Itertools: Iterator { /// /// ``` /// use itertools::Itertools; - /// let mut v = Vec::new(); + /// let mut v = vec![]; /// for (a, b) in (1..5).circular_tuple_windows() { /// v.push((a, b)); /// } @@ -735,7 +735,7 @@ pub trait Itertools: Iterator { /// /// ``` /// use itertools::Itertools; - /// let mut v = Vec::new(); + /// let mut v = vec![]; /// for (a, b) in (1..5).tuples() { /// v.push((a, b)); /// } @@ -1567,7 +1567,7 @@ pub trait Itertools: Iterator { /// ``` /// use itertools::Itertools; /// - /// let mut v = Vec::new(); + /// let mut v = vec![]; /// for (a, b) in (1..5).tuple_combinations() { /// v.push((a, b)); /// } diff --git a/src/permutations.rs b/src/permutations.rs index 8b303c127..2aad4a645 100644 --- a/src/permutations.rs +++ b/src/permutations.rs @@ -67,7 +67,7 @@ where match state { PermutationState::Start { k: 0 } => { *state = PermutationState::End; - Some(Vec::new()) + Some(vec![]) } &mut PermutationState::Start { k } => { vals.prefill(k); diff --git a/src/put_back_n_impl.rs b/src/put_back_n_impl.rs index 40b55e5f6..0208ec524 100644 --- a/src/put_back_n_impl.rs +++ b/src/put_back_n_impl.rs @@ -22,7 +22,7 @@ where I: IntoIterator, { PutBackN { - top: Vec::new(), + top: vec![], iter: iterable.into_iter(), } } diff --git a/tests/quick.rs b/tests/quick.rs index 0856fbdc4..3cb193ee3 100644 --- a/tests/quick.rs +++ b/tests/quick.rs @@ -415,7 +415,7 @@ quickcheck! { let cr = &c.clone(); let answer: Vec<_> = ac.flat_map(move |ea| br.clone().flat_map(move |eb| cr.clone().map(move |ec| (ea, eb, ec)))).collect(); let mut product_iter = iproduct!(a, b, c); - let mut actual = Vec::new(); + let mut actual = vec![]; actual.extend((&mut product_iter).take(take_manual)); if actual.len() == take_manual { @@ -439,7 +439,7 @@ quickcheck! { let i2r = &iters.next().unwrap(); let answer: Vec<_> = i0.flat_map(move |ei0| i1r.clone().flat_map(move |ei1| i2r.clone().map(move |ei2| vec![ei0, ei1, ei2]))).collect(); let mut multi_product = a.clone().multi_cartesian_product(); - let mut actual = Vec::new(); + let mut actual = vec![]; actual.extend((&mut multi_product).take(take_manual)); if actual.len() == take_manual { @@ -667,7 +667,7 @@ quickcheck! { } fn equal_combinations_2(a: Vec) -> bool { - let mut v = Vec::new(); + let mut v = vec![]; for (i, x) in enumerate(&a) { for y in &a[i + 1..] { v.push((x, y)); @@ -1078,7 +1078,7 @@ quickcheck! { let mut groups1 = grouper.into_iter(); let mut groups2 = grouper.into_iter(); let mut elts = Vec::<&u8>::new(); - let mut old_groups = Vec::new(); + let mut old_groups = vec![]; let tup1 = |(_, b)| b; for &(ord, consume_now) in &order { @@ -1373,7 +1373,7 @@ quickcheck! { fn collapse_adjacent(x: Vec, mut f: F) -> Vec where F: FnMut(f64, f64) -> f64 { - let mut out = Vec::new(); + let mut out = vec![]; for i in (0..x.len()).step(2) { if i == x.len()-1 { out.push(x[i]) @@ -1815,7 +1815,7 @@ quickcheck! { let y = multizip((a.into_iter(), b.into_iter())) - .rfold(Vec::new(), |mut vec, e| { vec.push(e); vec }); + .rfold(vec![], |mut vec, e| { vec.push(e); vec }); TestResult::from_bool(itertools::equal(x, y)) } @@ -1828,7 +1828,7 @@ quickcheck! { let y = multizip((a.into_iter(), b.into_iter(), c.into_iter())) - .rfold(Vec::new(), |mut vec, e| { vec.push(e); vec }); + .rfold(vec![], |mut vec, e| { vec.push(e); vec }); TestResult::from_bool(itertools::equal(x, y)) } diff --git a/tests/test_std.rs b/tests/test_std.rs index 16fc9237d..8934d061d 100644 --- a/tests/test_std.rs +++ b/tests/test_std.rs @@ -160,7 +160,7 @@ fn dedup() { let xs = [0, 1, 1, 1, 2, 1, 3, 3]; let ys = [0, 1, 2, 1, 3]; - let mut xs_d = Vec::new(); + let mut xs_d = vec![]; xs.iter().dedup().fold((), |(), &elt| xs_d.push(elt)); assert_eq!(&xs_d, &ys); } @@ -214,7 +214,7 @@ fn dedup_by() { (1, 3), ]; let ys = [(0, 0), (0, 1), (0, 2), (3, 1), (0, 3)]; - let mut xs_d = Vec::new(); + let mut xs_d = vec![]; xs.iter() .dedup_by(|x, y| x.1 == y.1) .fold((), |(), &elt| xs_d.push(elt)); @@ -876,7 +876,7 @@ fn group_by_lazy_2() { it::assert_equal(&[0, 0, 0, 1, 1], gs.into_iter().flat_map(|(_, g)| g)); let grouper = data.iter().group_by(|k| *k); - let mut groups = Vec::new(); + let mut groups = vec![]; for (k, group) in &grouper { if *k == 1 { groups.push(group); @@ -886,7 +886,7 @@ fn group_by_lazy_2() { let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3]; let grouper = data.iter().group_by(|k| *k); - let mut groups = Vec::new(); + let mut groups = vec![]; for (i, (_, group)) in grouper.into_iter().enumerate() { if i < 2 { groups.push(group); @@ -952,8 +952,8 @@ fn chunks() { #[test] fn concat_empty() { - let data: Vec> = Vec::new(); - assert_eq!(data.into_iter().concat(), Vec::new()) + let data: Vec> = vec![]; + assert_eq!(data.into_iter().concat(), vec![]) } #[test] From d0838ac8571b5110c626afec6c809b5447485dfb Mon Sep 17 00:00:00 2001 From: Adam Nemecek Date: Wed, 20 Dec 2023 12:58:04 -0800 Subject: [PATCH 6/7] nitpicks --- src/either_or_both.rs | 14 +++++++------- src/kmerge_impl.rs | 9 ++------- src/size_hint.rs | 6 +----- 3 files changed, 10 insertions(+), 19 deletions(-) diff --git a/src/either_or_both.rs b/src/either_or_both.rs index 9dbc880d3..9bd98e0a8 100644 --- a/src/either_or_both.rs +++ b/src/either_or_both.rs @@ -307,9 +307,9 @@ impl EitherOrBoth { B: Default, { match self { - EitherOrBoth::Left(l) => (l, B::default()), - EitherOrBoth::Right(r) => (A::default(), r), - EitherOrBoth::Both(l, r) => (l, r), + Left(l) => (l, B::default()), + Right(r) => (A::default(), r), + Both(l, r) => (l, r), } } @@ -503,8 +503,8 @@ impl EitherOrBoth { impl Into>> for EitherOrBoth { fn into(self) -> Option> { match self { - EitherOrBoth::Left(l) => Some(Either::Left(l)), - EitherOrBoth::Right(r) => Some(Either::Right(r)), + Left(l) => Some(Either::Left(l)), + Right(r) => Some(Either::Right(r)), _ => None, } } @@ -513,8 +513,8 @@ impl Into>> for EitherOrBoth { impl From> for EitherOrBoth { fn from(either: Either) -> Self { match either { - Either::Left(l) => EitherOrBoth::Left(l), - Either::Right(l) => EitherOrBoth::Right(l), + Either::Left(l) => Left(l), + Either::Right(l) => Right(l), } } } diff --git a/src/kmerge_impl.rs b/src/kmerge_impl.rs index 4660caf07..84b1aa567 100644 --- a/src/kmerge_impl.rs +++ b/src/kmerge_impl.rs @@ -28,19 +28,14 @@ where { /// Constructs a `HeadTail` from an `Iterator`. Returns `None` if the `Iterator` is empty. fn new(mut it: I) -> Option { - let head = it.next(); - head.map(|h| Self { head: h, tail: it }) + it.next().map(|h| Self { head: h, tail: it }) } /// Get the next element and update `head`, returning the old head in `Some`. /// /// Returns `None` when the tail is exhausted (only `head` then remains). fn next(&mut self) -> Option { - if let Some(next) = self.tail.next() { - Some(replace(&mut self.head, next)) - } else { - None - } + self.tail.next().map(|next| replace(&mut self.head, next)) } /// Hints at the size of the sequence, same as the `Iterator` method. diff --git a/src/size_hint.rs b/src/size_hint.rs index 9799d5bd2..f9a3ec867 100644 --- a/src/size_hint.rs +++ b/src/size_hint.rs @@ -11,11 +11,7 @@ pub type SizeHint = (usize, Option); #[inline] pub fn add(a: SizeHint, b: SizeHint) -> SizeHint { let min = a.0.saturating_add(b.0); - let max = match (a.1, b.1) { - (Some(x), Some(y)) => x.checked_add(y), - _ => None, - }; - + let max = a.1.zip(b.1).and_then(|(x, y)| x.checked_add(y)); (min, max) } From f6c65ea0de06ce71c6b04333735024e44b058e99 Mon Sep 17 00:00:00 2001 From: Adam Nemecek Date: Wed, 20 Dec 2023 13:02:13 -0800 Subject: [PATCH 7/7] nitpicks --- src/size_hint.rs | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/src/size_hint.rs b/src/size_hint.rs index f9a3ec867..aca11478a 100644 --- a/src/size_hint.rs +++ b/src/size_hint.rs @@ -60,12 +60,9 @@ pub fn max(a: SizeHint, b: SizeHint) -> SizeHint { let (a_lower, a_upper) = a; let (b_lower, b_upper) = b; - let lower = cmp::max(a_lower, b_lower); + let lower = a_lower.max(b_lower); - let upper = match (a_upper, b_upper) { - (Some(x), Some(y)) => Some(cmp::max(x, y)), - _ => None, - }; + let upper = a_upper.zip(b_upper).map(|(x, y)| x.max(y)); (lower, upper) } @@ -76,11 +73,11 @@ pub fn min(a: SizeHint, b: SizeHint) -> SizeHint { let (a_lower, a_upper) = a; let (b_lower, b_upper) = b; let lower = cmp::min(a_lower, b_lower); - let upper = - match (a_upper, b_upper) { - (Some(u1), Some(u2)) => Some(cmp::min(u1, u2)), - _ => a_upper.or(b_upper), - }; + + let upper = a_upper + .zip(b_upper) + .map(|(x, y)| x.min(y)) + .or_else(|| a_upper.or(b_upper)); (lower, upper) }