diff --git a/src/types/array.rs b/src/types/array.rs
index bc82cec831..fae667f946 100644
--- a/src/types/array.rs
+++ b/src/types/array.rs
@@ -678,13 +678,13 @@ impl<'a> Iterator for Iter<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for Iter<'a> {
+impl ExactSizeIterator for Iter<'_> {
     fn len(&self) -> usize {
         self.ht.len()
     }
 }
 
-impl<'a> DoubleEndedIterator for Iter<'a> {
+impl DoubleEndedIterator for Iter<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         let key_type = unsafe {
             zend_hash_get_current_key_type_ex(
@@ -730,8 +730,8 @@ impl<'a> DoubleEndedIterator for Iter<'a> {
     }
 }
 
-impl<'a, 'b> Iter<'a> {
-    pub fn next_zval(&'b mut self) -> Option<(Zval, &'a Zval)> {
+impl<'a> Iter<'a> {
+    pub fn next_zval(&mut self) -> Option<(Zval, &'a Zval)> {
         let key_type = unsafe {
             zend_hash_get_current_key_type_ex(
                 self.ht as *const ZendHashTable as *mut ZendHashTable,
@@ -805,13 +805,13 @@ impl<'a> Iterator for Values<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for Values<'a> {
+impl ExactSizeIterator for Values<'_> {
     fn len(&self) -> usize {
         self.0.len()
     }
 }
 
-impl<'a> DoubleEndedIterator for Values<'a> {
+impl DoubleEndedIterator for Values<'_> {
     fn next_back(&mut self) -> Option<Self::Item> {
         self.0.next_back().map(|(_, zval)| zval)
     }
@@ -847,7 +847,7 @@ impl<'a> FromZval<'a> for &'a ZendHashTable {
 }
 
 ///////////////////////////////////////////
-/// HashMap
+// HashMap
 ///////////////////////////////////////////
 
 impl<'a, V> TryFrom<&'a ZendHashTable> for HashMap<String, V>
@@ -916,7 +916,7 @@ where
 }
 
 ///////////////////////////////////////////
-/// Vec
+// Vec
 ///////////////////////////////////////////
 
 impl<'a, T> TryFrom<&'a ZendHashTable> for Vec<T>
diff --git a/src/types/callable.rs b/src/types/callable.rs
index c22474b75a..dfb65b3b35 100644
--- a/src/types/callable.rs
+++ b/src/types/callable.rs
@@ -142,7 +142,7 @@ impl<'a> FromZval<'a> for ZendCallable<'a> {
     }
 }
 
-impl<'a> TryFrom<Zval> for ZendCallable<'a> {
+impl TryFrom<Zval> for ZendCallable<'_> {
     type Error = Error;
 
     fn try_from(value: Zval) -> Result<Self> {
@@ -158,7 +158,7 @@ enum OwnedZval<'a> {
     Owned(Zval),
 }
 
-impl<'a> OwnedZval<'a> {
+impl OwnedZval<'_> {
     fn as_ref(&self) -> &Zval {
         match self {
             OwnedZval::Reference(zv) => zv,
@@ -167,7 +167,7 @@ impl<'a> OwnedZval<'a> {
     }
 }
 
-impl<'a> Deref for OwnedZval<'a> {
+impl Deref for OwnedZval<'_> {
     type Target = Zval;
 
     fn deref(&self) -> &Self::Target {
diff --git a/src/types/iterable.rs b/src/types/iterable.rs
index 1440a679d9..24b226733d 100644
--- a/src/types/iterable.rs
+++ b/src/types/iterable.rs
@@ -12,7 +12,7 @@ pub enum Iterable<'a> {
     Traversable(&'a mut ZendIterator),
 }
 
-impl<'a> Iterable<'a> {
+impl Iterable<'_> {
     /// Creates a new rust iterator from a PHP iterable.
     /// May return None if a Traversable cannot be rewound.
     pub fn iter(&mut self) -> Option<Iter> {
diff --git a/src/types/object.rs b/src/types/object.rs
index 68ad535d97..0d45fd8479 100644
--- a/src/types/object.rs
+++ b/src/types/object.rs
@@ -365,7 +365,7 @@ impl IntoZval for ZBox<ZendObject> {
     }
 }
 
-impl<'a> IntoZval for &'a mut ZendObject {
+impl IntoZval for &mut ZendObject {
     const TYPE: DataType = DataType::Object(None);
 
     #[inline]
diff --git a/src/types/zval.rs b/src/types/zval.rs
index d2381d5bb4..6de991d8c7 100644
--- a/src/types/zval.rs
+++ b/src/types/zval.rs
@@ -53,7 +53,7 @@ impl Zval {
 
     /// Dereference the zval, if it is a reference.
     pub fn dereference(&self) -> &Self {
-        return self.reference().or_else(|| self.indirect()).unwrap_or(self);
+        self.reference().or_else(|| self.indirect()).unwrap_or(self)
     }
 
     /// Dereference the zval mutable, if it is a reference.