fix some more clippy lints

src/lazy_buffer.rs

@@ -28,16 +28,12 @@ where
         if self.done {
             return false;
         }
-        let next_item = self.it.next();
-        match next_item {
-            Some(x) => {
-                self.buffer.push(x);
-                true
-            }
-            None => {
-                self.done = true;
-                false
-            }
+        if let Some(x) = self.it.next() {
+            self.buffer.push(x);
+            true
+        } else {
+            self.done = true;
+            false
         }
     }
 
@@ -61,7 +57,7 @@ where
 {
     type Output = <Vec<I::Item> as Index<J>>::Output;
 
-    fn index(&self, _index: J) -> &Self::Output {
-        self.buffer.index(_index)
+    fn index(&self, index: J) -> &Self::Output {
+        self.buffer.index(index)
     }
 }

src/permutations.rs

@@ -113,19 +113,15 @@ where
 
                 Some(indices.map(|i| vals[i].clone()).collect())
             }
-            PermutationState::Complete(CompleteState::Start { .. }) => None,
             PermutationState::Complete(CompleteState::Ongoing { ref indices, ref cycles }) => {
                 let k = cycles.len();
-
                 Some(indices[0..k].iter().map(|&i| vals[i].clone()).collect())
             },
-            PermutationState::Empty => None
+            PermutationState::Complete(CompleteState::Start { .. }) | PermutationState::Empty => None
         }
     }
 
     fn count(self) -> usize {
-        let Permutations { vals, state } = self;
-
         fn from_complete(complete_state: CompleteState) -> usize {
             match complete_state.remaining() {
                 CompleteStateRemaining::Known(count) => count,
@@ -135,6 +131,7 @@ where
             }
         }
 
+        let Permutations { vals, state } = self;
         match state {
             PermutationState::StartUnknownLen { k } => {
                 let n = vals.len() + vals.it.count();

src/tuple_impl.rs

@@ -162,8 +162,8 @@ pub fn tuple_windows<I, T>(mut iter: I) -> TupleWindows<I, T>
     }
 
     TupleWindows {
-        last,
         iter,
+        last,
     }
 }