Use Self

Two simple steps:
- run `cargo clippy --fix -- -D clippy::use_self`
- In `either_or_both`, remove `Self::` as glob use is quite convenient.

https://rust-lang.github.io/rust-clippy/master/index.html#/use_self

Co-Authored-By: Marcel Hellwig <[email protected]>

Author: Philippe-Cholet

benches/extra/zipslices.rs

@@ -58,7 +58,7 @@ where
     #[inline(always)]
     pub fn from_slices(a: T, b: U) -> Self {
         let minl = cmp::min(a.len(), b.len());
-        ZipSlices {
+        Self {
             t: a,
             u: b,
             len: minl,

examples/iris.rs

@@ -25,7 +25,7 @@ enum ParseError {
 
 impl From<ParseFloatError> for ParseError {
     fn from(err: ParseFloatError) -> Self {
-        ParseError::Numeric(err)
+        Self::Numeric(err)
     }
 }
 
@@ -34,7 +34,7 @@ impl FromStr for Iris {
     type Err = ParseError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut iris = Iris {
+        let mut iris = Self {
             name: "".into(),
             data: [0.; 4],
         };

src/adaptors/mod.rs

@@ -218,7 +218,7 @@ where
     /// Split the `PutBack` into its parts.
     #[inline]
     pub fn into_parts(self) -> (Option<I::Item>, I) {
-        let PutBack { top, iter } = self;
+        let Self { top, iter } = self;
         (top, iter)
     }
 
@@ -689,7 +689,7 @@ pub struct Tuple1Combination<I> {
 
 impl<I> From<I> for Tuple1Combination<I> {
     fn from(iter: I) -> Self {
-        Tuple1Combination { iter }
+        Self { iter }
     }
 }
 

src/adaptors/multi_product.rs

@@ -95,7 +95,7 @@ where
 
             if last.in_progress() {
                 true
-            } else if MultiProduct::iterate_last(rest, state) {
+            } else if Self::iterate_last(rest, state) {
                 last.reset();
                 last.iterate();
                 // If iterator is None twice consecutively, then iterator is
@@ -139,7 +139,7 @@ where
     I::Item: Clone,
 {
     fn new(iter: I) -> Self {
-        MultiProductIter {
+        Self {
             cur: None,
             iter: iter.clone(),
             iter_orig: iter,
@@ -171,7 +171,7 @@ where
     type Item = Vec<I::Item>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        if MultiProduct::iterate_last(&mut self.0, MultiProductIterState::StartOfIter) {
+        if Self::iterate_last(&mut self.0, MultiProductIterState::StartOfIter) {
             Some(self.curr_iterator())
         } else {
             None

src/duplicates_impl.rs

@@ -22,7 +22,7 @@ mod private {
 
     impl<I: Iterator, Key: Eq + Hash, F> DuplicatesBy<I, Key, F> {
         pub(crate) fn new(iter: I, key_method: F) -> Self {
-            DuplicatesBy {
+            Self {
                 iter,
                 meta: Meta {
                     used: HashMap::new(),
@@ -77,7 +77,7 @@ mod private {
         type Item = I::Item;
 
         fn next(&mut self) -> Option<Self::Item> {
-            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<Key, I::Item>,
     {
         fn next_back(&mut self) -> Option<Self::Item> {
-            let DuplicatesBy { iter, meta } = self;
+            let Self { iter, meta } = self;
             iter.rev().find_map(|v| meta.filter(v))
         }
     }

src/either_or_both.rs

@@ -301,9 +301,9 @@ impl<A, B> EitherOrBoth<A, B> {
         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),
         }
     }
 
@@ -498,18 +498,18 @@ impl<T> EitherOrBoth<T, T> {
 impl<A, B> Into<Option<Either<A, B>>> for EitherOrBoth<A, B> {
     fn into(self) -> Option<Either<A, B>> {
         match self {
-            EitherOrBoth::Left(l) => Some(Either::Left(l)),
-            EitherOrBoth::Right(r) => Some(Either::Right(r)),
-            _ => None,
+            Left(l) => Some(Either::Left(l)),
+            Right(r) => Some(Either::Right(r)),
+            Both(..) => None,
         }
     }
 }
 
 impl<A, B> From<Either<A, B>> for EitherOrBoth<A, B> {
     fn from(either: Either<A, B>) -> 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),
         }
     }
 }

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,

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<HeadTail<I>> {
+    fn new(mut it: I) -> Option<Self> {
         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`.

src/lazy_buffer.rs

@@ -14,8 +14,8 @@ impl<I> LazyBuffer<I>
 where
     I: Iterator,
 {
-    pub fn new(it: I) -> LazyBuffer<I> {
-        LazyBuffer {
+    pub fn new(it: I) -> Self {
+        Self {
             it: it.fuse(),
             buffer: Vec::new(),
         }

src/lib.rs

@@ -4077,15 +4077,15 @@ impl<T> FoldWhile<T> {
     /// Return the value in the continue or done.
     pub fn into_inner(self) -> T {
         match self {
-            FoldWhile::Continue(x) | FoldWhile::Done(x) => x,
+            Self::Continue(x) | Self::Done(x) => x,
         }
     }
 
     /// Return true if `self` is `Done`, false if it is `Continue`.
     pub fn is_done(&self) -> bool {
         match *self {
-            FoldWhile::Continue(_) => false,
-            FoldWhile::Done(_) => true,
+            Self::Continue(_) => false,
+            Self::Done(_) => true,
         }
     }
 }