ci: fix clippy

async-skipdb/examples/optimistic.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::needless_return)]
+
 use async_skipdb::optimistic::TokioOptimisticDb;
 
 #[derive(Debug)]
@@ -61,6 +63,57 @@ async fn main() {
     txn.commit().await.unwrap();
   }
 
+  {
+    let alice = Person {
+      hobby: "swim".to_string(),
+      age: 20,
+    };
+    let bob = Person {
+      hobby: "run".to_string(),
+      age: 30,
+    };
+
+    let mut txn = db.write().await;
+    txn.insert("Alice".to_string(), alice).unwrap();
+    txn.insert("Bob".to_string(), bob).unwrap();
+
+    {
+      let alice = txn.get("Alice").unwrap().unwrap();
+      assert_eq!(alice.value().age, 20);
+      assert_eq!(alice.value().hobby, "swim");
+    }
+
+    {
+      // output:
+      // Alice:Person { hobby: "swim", age: 20 }
+      // Bob:Person { hobby: "run", age: 30 }
+      for ent in txn.iter().unwrap() {
+        println!("{}:{:?}", ent.key(), ent.value());
+      }
+
+      // output:
+      // Bob:Person { hobby: "run", age: 30 }
+      // Alice:Person { hobby: "swim", age: 20 }
+      for ent in txn.iter_rev().unwrap() {
+        println!("{}:{:?}", ent.key(), ent.value());
+      }
+
+      // output:
+      // Bob:Person { hobby: "run", age: 30 }
+      for ent in txn.range("B".to_string()..).unwrap() {
+        println!("{}:{:?}", ent.key(), ent.value());
+      }
+
+      // output:
+      // Alice:Person { hobby: "swim", age: 20 }
+      for ent in txn.range_rev(..="B".to_string()).unwrap() {
+        println!("{}:{:?}", ent.key(), ent.value());
+      }
+    }
+
+    txn.commit().await.unwrap();
+  }
+
   {
     let txn = db.read().await;
     let alice = txn.get("Alice").unwrap();

async-skipdb/examples/serializable.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::needless_return)]
+
 use async_skipdb::serializable::TokioSerializableDb;
 
 #[derive(Debug)]
@@ -65,6 +67,60 @@ async fn main() {
     txn.commit().await.unwrap();
   }
 
+  {
+    let alice = Person {
+      name: "Alice".to_string(),
+      hobby: "swim".to_string(),
+      age: 20,
+    };
+    let bob = Person {
+      name: "Bob".to_string(),
+      hobby: "run".to_string(),
+      age: 30,
+    };
+
+    let mut txn = db.serializable_write().await;
+    txn.insert(1, alice).unwrap();
+    txn.insert(2, bob).unwrap();
+
+    {
+      let alice = txn.get(&1).unwrap().unwrap();
+      assert_eq!(alice.value().name, "Alice");
+      assert_eq!(alice.value().age, 20);
+      assert_eq!(alice.value().hobby, "swim");
+    }
+
+    {
+      // output:
+      // 1: Person { name: "Alice", hobby: "swim", age: 20 }
+      // 2: Person { name: "Bob", hobby: "run", age: 30 }
+      for ent in txn.iter().unwrap() {
+        println!("{}: {:?}", ent.key(), ent.value());
+      }
+
+      // output:
+      // 2: Person { name: "Bob", hobby: "run", age: 30 }
+      // 1: Person { name: "Alice", hobby: "swim", age: 20 }
+      for ent in txn.iter_rev().unwrap() {
+        println!("{}: {:?}", ent.key(), ent.value());
+      }
+
+      // output:
+      // 2: Person { name: "Bob", hobby: "run", age: 30 }
+      for ent in txn.range(1..).unwrap() {
+        println!("{}: {:?}", ent.key(), ent.value());
+      }
+
+      // output:
+      // 1: Person { name: "Alice", hobby: "swim", age: 20 }
+      for ent in txn.range_rev(..2).unwrap() {
+        println!("{}: {:?}", ent.key(), ent.value());
+      }
+    }
+
+    txn.commit().await.unwrap();
+  }
+
   {
     let txn = db.read().await;
     let alice = txn.get(&1).unwrap();

async-skipdb/src/lib.rs

@@ -12,6 +12,7 @@ use std::{borrow::Borrow, hash::BuildHasher, ops::RangeBounds, sync::Arc};
 use async_txn::{error::TransactionError, AsyncRtm, AsyncTm, AsyncWtm, HashCm, HashCmOptions};
 
 /// `OptimisticDb` implementation, which requires `K` implements both [`Hash`](core::hash::Hash) and [`Ord`].
+///
 /// If your `K` does not implement [`Hash`](core::hash::Hash), you can use [`SerializableDb`] instead.
 pub mod optimistic;
 

async-skipdb/src/optimistic/tests.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::blocks_in_conditions)]
+#![allow(clippy::blocks_in_conditions, clippy::needless_return)]
 
 use std::{
   future::Future,

async-skipdb/src/optimistic/write.rs

@@ -50,10 +50,10 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. If callback is provided, Badger will return immediately after checking
-  /// for conflicts. Writes to the database will happen in the background.  If
-  /// there is a conflict, an error will be returned and the callback will not
-  /// run. If there are no conflicts, the callback will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    for conflicts. Writes to the database will happen in the background.  If
+  ///    there is a conflict, an error will be returned and the callback will not
+  ///    run. If there are no conflicts, the callback will be called in the
+  ///    background upon successful completion of writes or any error during write.
   #[inline]
   pub async fn commit(
     &mut self,
@@ -88,9 +88,9 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. Return immediately after checking for conflicts.
-  /// If there is a conflict, an error will be returned immediately and the callback will not
-  /// run. If there are no conflicts, the callback will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    If there is a conflict, an error will be returned immediately and the callback will not
+  ///    run. If there are no conflicts, the callback will be called in the
+  ///    background upon successful completion of writes or any error during write.
   #[inline]
   pub async fn commit_with_task<Fut, E, R>(
     &mut self,

async-skipdb/src/serializable/optimistic.rs

@@ -48,10 +48,10 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. If callback is provided, database will return immediately after checking
-  /// for conflicts. Writes to the database will happen in the background.  If
-  /// there is a conflict, an error will be returned and the callback will not
-  /// run. If there are no conflicts, the callback will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    for conflicts. Writes to the database will happen in the background.  If
+  ///    there is a conflict, an error will be returned and the callback will not
+  ///    run. If there are no conflicts, the callback will be called in the
+  ///    background upon successful completion of writes or any error during write.
   #[inline]
   pub async fn commit(&mut self) -> Result<(), WtmError<Infallible, Infallible, Infallible>> {
     let db = self.db.clone();
@@ -83,9 +83,9 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. Return immediately after checking for conflicts.
-  /// If there is a conflict, an error will be returned immediately and the callback will not
-  /// run. If there are no conflicts, the callback will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    If there is a conflict, an error will be returned immediately and the callback will not
+  ///    run. If there are no conflicts, the callback will be called in the
+  ///    background upon successful completion of writes or any error during write.
   #[inline]
   pub async fn commit_with_task<Fut, E, R>(
     &mut self,

async-skipdb/src/serializable/optimistic/tests.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::blocks_in_conditions)]
+#![allow(clippy::blocks_in_conditions, clippy::needless_return)]
 
 use std::{
   sync::atomic::{AtomicU32, Ordering},

async-skipdb/src/serializable/serializable.rs

@@ -48,10 +48,10 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. If callback is provided, database will return immediately after checking
-  /// for conflicts. Writes to the database will happen in the background.  If
-  /// there is a conflict, an error will be returned and the callback will not
-  /// run. If there are no conflicts, the callback will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    for conflicts. Writes to the database will happen in the background.  If
+  ///    there is a conflict, an error will be returned and the callback will not
+  ///    run. If there are no conflicts, the callback will be called in the
+  ///    background upon successful completion of writes or any error during write.
   #[inline]
   pub async fn commit(&mut self) -> Result<(), WtmError<Infallible, Infallible, Infallible>> {
     let db = self.db.clone();
@@ -83,9 +83,9 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. Return immediately after checking for conflicts.
-  /// If there is a conflict, an error will be returned immediately and the callback will not
-  /// run. If there are no conflicts, the callback will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    If there is a conflict, an error will be returned immediately and the callback will not
+  ///    run. If there are no conflicts, the callback will be called in the
+  ///    background upon successful completion of writes or any error during write.
   #[inline]
   pub async fn commit_with_task<Fut, E, R>(
     &mut self,

async-skipdb/src/serializable/serializable/tests.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::blocks_in_conditions)]
+#![allow(clippy::blocks_in_conditions, clippy::needless_return)]
 
 use std::{
   sync::atomic::{AtomicU32, Ordering},

async-txn/src/write.rs

@@ -258,10 +258,10 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. If callback is provided, Badger will return immediately after checking
-  /// for conflicts. Writes to the database will happen in the background.  If
-  /// there is a conflict, an error will be returned and the callback will not
-  /// run. If there are no conflicts, the callback will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    for conflicts. Writes to the database will happen in the background.  If
+  ///    there is a conflict, an error will be returned and the callback will not
+  ///    run. If there are no conflicts, the callback will be called in the
+  ///    background upon successful completion of writes or any error during write.
   pub async fn commit<F, Fut, O, E>(
     &mut self,
     apply: F,
@@ -745,9 +745,9 @@ where
   /// 4. Batch up all writes, write them to database.
   ///
   /// 5. Return immediately after checking for conflicts.
-  /// If there is a conflict, an error will be returned immediately and the no task will be spawned
-  /// run. If there are no conflicts, a task will be spawned and the future will be called in the
-  /// background upon successful completion of writes or any error during write.
+  ///    If there is a conflict, an error will be returned immediately and the no task will be spawned
+  ///    run. If there are no conflicts, a task will be spawned and the future will be called in the
+  ///    background upon successful completion of writes or any error during write.
   pub async fn commit_with_task<F, Fut, CFut, E, R>(
     &mut self,
     apply: F,

skipdb-core/src/types.rs

@@ -76,7 +76,7 @@ pub struct Entry<'a, K, V> {
   version: u64,
 }
 
-impl<'a, K, V> Clone for Entry<'a, K, V> {
+impl<K, V> Clone for Entry<'_, K, V> {
   #[inline]
   fn clone(&self) -> Self {
     Self {
@@ -87,7 +87,7 @@ impl<'a, K, V> Clone for Entry<'a, K, V> {
   }
 }
 
-impl<'a, K, V> Entry<'a, K, V> {
+impl<K, V> Entry<'_, K, V> {
   /// Get the value of the entry.
   #[inline]
   pub fn value(&self) -> Option<&V> {
@@ -110,26 +110,26 @@ impl<'a, K, V> Entry<'a, K, V> {
 /// A reference to an entry in the write transaction.
 pub struct ValueRef<'a, K, V>(Either<&'a V, Entry<'a, K, V>>);
 
-impl<'a, K, V: core::fmt::Debug> core::fmt::Debug for ValueRef<'a, K, V> {
+impl<K, V: core::fmt::Debug> core::fmt::Debug for ValueRef<'_, K, V> {
   fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
     core::ops::Deref::deref(self).fmt(f)
   }
 }
 
-impl<'a, K, V: core::fmt::Display> core::fmt::Display for ValueRef<'a, K, V> {
+impl<K, V: core::fmt::Display> core::fmt::Display for ValueRef<'_, K, V> {
   fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
     core::ops::Deref::deref(self).fmt(f)
   }
 }
 
-impl<'a, K, V> Clone for ValueRef<'a, K, V> {
+impl<K, V> Clone for ValueRef<'_, K, V> {
   #[inline]
   fn clone(&self) -> Self {
     Self(self.0.clone())
   }
 }
 
-impl<'a, K, V> core::ops::Deref for ValueRef<'a, K, V> {
+impl<K, V> core::ops::Deref for ValueRef<'_, K, V> {
   type Target = V;
 
   #[inline]
@@ -143,15 +143,15 @@ impl<'a, K, V> core::ops::Deref for ValueRef<'a, K, V> {
   }
 }
 
-impl<'a, K, V> ValueRef<'a, K, V> {
+impl<K, V> ValueRef<'_, K, V> {
   /// Returns `true` if the value was commited.
   #[inline]
   pub const fn is_committed(&self) -> bool {
     matches!(self.0, Either::Right(_))
   }
 }
 
-impl<'a, K, V> PartialEq<V> for ValueRef<'a, K, V>
+impl<K, V> PartialEq<V> for ValueRef<'_, K, V>
 where
   V: PartialEq,
 {
@@ -161,7 +161,7 @@ where
   }
 }
 
-impl<'a, K, V> PartialEq<&V> for ValueRef<'a, K, V>
+impl<K, V> PartialEq<&V> for ValueRef<'_, K, V>
 where
   V: PartialEq,
 {