Merge pull request #67 from worm-blossom/local_nb_only

Run clippy
worm-blossom · Nov 28, 2024 · 394a386 · 394a386
2 parents 49981ce + 66f6eb2
commit 394a386
Show file tree

Hide file tree

Showing 2 changed files with 25 additions and 16 deletions.
diff --git a/ufotofu/src/producer/macros.rs b/ufotofu/src/producer/macros.rs
@@ -98,14 +98,20 @@ macro_rules! invarianted_bulk_producer_methods {
         async fn bulk_produce(
             &mut self,
             buf: &mut [Self::Item],
-        ) -> Result<Either<usize, Self::Final>, Self::Error> where Self::Item: Clone {
+        ) -> Result<Either<usize, Self::Final>, Self::Error>
+        where
+            Self::Item: Clone,
+        {
             ufotofu::BulkProducer::bulk_produce(&mut self.0, buf).await
         }
 
         async fn bulk_overwrite_full_slice<'kfhwkfwe>(
             &mut self,
             buf: &'kfhwkfwe mut [Self::Item],
-        ) -> Result<(), ufotofu::OverwriteFullSliceError<Self::Final, Self::Error>> where Self::Item: Clone {
+        ) -> Result<(), ufotofu::OverwriteFullSliceError<Self::Final, Self::Error>>
+        where
+            Self::Item: Clone,
+        {
             ufotofu::BulkProducer::bulk_overwrite_full_slice(&mut self.0, buf).await
         }
     };

diff --git a/ufotofu/src/producer/test_producer.rs b/ufotofu/src/producer/test_producer.rs
@@ -338,31 +338,31 @@ impl<Item: Clone, Final, Error> Producer for TestProducer<Item, Final, Error> {
 
     async fn produce(&mut self) -> Result<Either<Self::Item, Self::Final>, Self::Error> {
         self.maybe_yield().await;
-        if self.inner.remaining().len() == 0 {
-            return Ok(Right(self.last.take().unwrap()?));
+        if self.inner.remaining().is_empty() {
+            Ok(Right(self.last.take().unwrap()?))
         } else {
-            return Ok(Left(
+            Ok(Left(
                 Producer::produce(&mut self.inner)
                     .await
                     .unwrap()
                     .unwrap_left(),
-            ));
+            ))
         }
     }
 }
 
 impl<Item: Clone, Final, Error> BufferedProducer for TestProducer<Item, Final, Error> {
     async fn slurp(&mut self) -> Result<(), Self::Error> {
         self.maybe_yield().await;
-        if self.inner.remaining().len() == 0 && self.last.as_ref().unwrap().is_err() {
+        if self.inner.remaining().is_empty() && self.last.as_ref().unwrap().is_err() {
             let last_owned = self.last.take().unwrap();
             match last_owned {
                 Ok(_) => unreachable!(),
                 Err(err) => return Err(err),
             }
         }
 
-        return Ok(());
+        Ok(())
     }
 }
 
@@ -374,21 +374,21 @@ impl<Item: Clone, Final, Error> BulkProducer for TestProducer<Item, Final, Error
         Self::Item: 'a,
     {
         self.maybe_yield().await;
-        if self.inner.remaining().len() == 0 {
+        if self.inner.remaining().is_empty() {
             let last_owned = self.last.take().unwrap();
             match last_owned {
-                Ok(fin) => return Ok(Right(fin)),
-                Err(err) => return Err(err),
+                Ok(fin) => Ok(Right(fin)),
+                Err(err) => Err(err),
             }
         } else {
             match self.exposed_items_sizes {
                 None => {
-                    return Ok(Left(
+                    Ok(Left(
                         BulkProducer::expose_items(&mut self.inner)
                             .await
                             .unwrap()
                             .unwrap_left(),
-                    ));
+                    ))
                 }
                 Some((ref exposed_item_sizes, ref mut index)) => {
                     let max_len: usize = exposed_item_sizes[*index].into();
@@ -408,16 +408,19 @@ impl<Item: Clone, Final, Error> BulkProducer for TestProducer<Item, Final, Error
 
     async fn consider_produced(&mut self, amount: usize) -> Result<(), Self::Error> {
         self.maybe_yield().await;
-        if self.inner.remaining().len() == 0 && self.last.as_ref().unwrap().is_err() {
+        if self.inner.remaining().is_empty() && self.last.as_ref().unwrap().is_err() {
             let last_owned = self.last.take().unwrap();
             match last_owned {
                 Ok(_) => unreachable!(),
                 Err(err) => return Err(err),
             }
         }
 
-        return Ok(BulkProducer::consider_produced(&mut self.inner, amount)
+        {
+            BulkProducer::consider_produced(&mut self.inner, amount)
             .await
-            .unwrap());
+            .unwrap();
+            Ok(())
+        }
     }
 }