diff --git a/Cargo.toml b/Cargo.toml
index dc36e64..31bcb9e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@ readme = "README.md"
 license = "MIT"
 description = "memcached client for rust"
 keywords = ["memcache", "memcached", "driver", "cache", "database"]
-edition = "2018"
+edition = "2024"
 
 [features]
 default = ["tls"]
diff --git a/src/client.rs b/src/client.rs
index e77ef97..a06e5b4 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -1,5 +1,5 @@
-use std::collections::hash_map::DefaultHasher;
 use std::collections::HashMap;
+use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 use std::time::Duration;
 
diff --git a/src/connection.rs b/src/connection.rs
index 200fe02..2f18026 100644
--- a/src/connection.rs
+++ b/src/connection.rs
@@ -111,7 +111,7 @@ impl TlsOptions {
             Some(_) => {
                 return Err(MemcacheError::BadURL(
                     "unknown verify_mode, expected 'none' or 'peer'".into(),
-                ))
+                ));
             }
             None => SslVerifyMode::PEER,
         };
@@ -165,7 +165,7 @@ impl Transport {
             _ => {
                 return Err(MemcacheError::BadURL(
                     "memcache URL's scheme should start with 'memcache'".into(),
-                ))
+                ));
             }
         }
 
diff --git a/src/error.rs b/src/error.rs
index cecee1c..a3cb053 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -153,12 +153,12 @@ pub enum ParseError {
 impl error::Error for ParseError {
     fn source(&self) -> Option<&(dyn error::Error + 'static)> {
         match self {
-            ParseError::Bool(ref e) => e.source(),
-            ParseError::Int(ref e) => e.source(),
-            ParseError::Float(ref e) => e.source(),
-            ParseError::String(ref e) => e.source(),
-            ParseError::Str(ref e) => e.source(),
-            ParseError::Url(ref e) => e.source(),
+            ParseError::Bool(e) => e.source(),
+            ParseError::Int(e) => e.source(),
+            ParseError::Float(e) => e.source(),
+            ParseError::String(e) => e.source(),
+            ParseError::Str(e) => e.source(),
+            ParseError::Url(e) => e.source(),
         }
     }
 }
@@ -166,12 +166,12 @@ impl error::Error for ParseError {
 impl fmt::Display for ParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            ParseError::Bool(ref e) => e.fmt(f),
-            ParseError::Int(ref e) => e.fmt(f),
-            ParseError::Float(ref e) => e.fmt(f),
-            ParseError::String(ref e) => e.fmt(f),
-            ParseError::Str(ref e) => e.fmt(f),
-            ParseError::Url(ref e) => e.fmt(f),
+            ParseError::Bool(e) => e.fmt(f),
+            ParseError::Int(e) => e.fmt(f),
+            ParseError::Float(e) => e.fmt(f),
+            ParseError::String(e) => e.fmt(f),
+            ParseError::Str(e) => e.fmt(f),
+            ParseError::Url(e) => e.fmt(f),
         }
     }
 }
diff --git a/src/stream/mod.rs b/src/stream/mod.rs
index 26757ad..5b38472 100644
--- a/src/stream/mod.rs
+++ b/src/stream/mod.rs
@@ -24,24 +24,24 @@ pub enum Stream {
 impl Stream {
     pub(super) fn set_read_timeout(&mut self, timeout: Option<Duration>) -> Result<(), MemcacheError> {
         match self {
-            Stream::Tcp(ref conn) => conn.set_read_timeout(timeout)?,
+            &mut Stream::Tcp(ref conn) => conn.set_read_timeout(timeout)?,
             #[cfg(unix)]
-            Stream::Unix(ref conn) => conn.set_read_timeout(timeout)?,
+            &mut Stream::Unix(ref conn) => conn.set_read_timeout(timeout)?,
             #[cfg(feature = "tls")]
-            Stream::Tls(ref stream) => stream.get_ref().set_read_timeout(timeout)?,
-            Stream::Udp(ref conn) => conn.set_read_timeout(timeout)?,
+            &mut Stream::Tls(ref stream) => stream.get_ref().set_read_timeout(timeout)?,
+            &mut Stream::Udp(ref conn) => conn.set_read_timeout(timeout)?,
         }
         Ok(())
     }
 
     pub(super) fn set_write_timeout(&mut self, timeout: Option<Duration>) -> Result<(), MemcacheError> {
         match self {
-            Stream::Tcp(ref conn) => conn.set_write_timeout(timeout)?,
+            &mut Stream::Tcp(ref conn) => conn.set_write_timeout(timeout)?,
             #[cfg(unix)]
-            Stream::Unix(ref conn) => conn.set_write_timeout(timeout)?,
+            &mut Stream::Unix(ref conn) => conn.set_write_timeout(timeout)?,
             #[cfg(feature = "tls")]
-            Stream::Tls(ref stream) => stream.get_ref().set_write_timeout(timeout)?,
-            Stream::Udp(ref conn) => conn.set_write_timeout(timeout)?,
+            &mut Stream::Tls(ref stream) => stream.get_ref().set_write_timeout(timeout)?,
+            &mut Stream::Udp(ref conn) => conn.set_write_timeout(timeout)?,
         }
         Ok(())
     }
@@ -50,12 +50,12 @@ impl Stream {
 impl Read for Stream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match self {
-            Stream::Tcp(ref mut stream) => stream.read(buf),
-            Stream::Udp(ref mut stream) => stream.read(buf),
+            Stream::Tcp(stream) => stream.read(buf),
+            Stream::Udp(stream) => stream.read(buf),
             #[cfg(unix)]
-            Stream::Unix(ref mut stream) => stream.read(buf),
+            Stream::Unix(stream) => stream.read(buf),
             #[cfg(feature = "tls")]
-            Stream::Tls(ref mut stream) => stream.read(buf),
+            Stream::Tls(stream) => stream.read(buf),
         }
     }
 }
@@ -63,23 +63,23 @@ impl Read for Stream {
 impl Write for Stream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         match self {
-            Stream::Tcp(ref mut stream) => stream.write(buf),
-            Stream::Udp(ref mut stream) => stream.write(buf),
+            Stream::Tcp(stream) => stream.write(buf),
+            Stream::Udp(stream) => stream.write(buf),
             #[cfg(unix)]
-            Stream::Unix(ref mut stream) => stream.write(buf),
+            Stream::Unix(stream) => stream.write(buf),
             #[cfg(feature = "tls")]
-            Stream::Tls(ref mut stream) => stream.write(buf),
+            Stream::Tls(stream) => stream.write(buf),
         }
     }
 
     fn flush(&mut self) -> io::Result<()> {
         match self {
-            Stream::Tcp(ref mut stream) => stream.flush(),
-            Stream::Udp(ref mut stream) => stream.flush(),
+            Stream::Tcp(stream) => stream.flush(),
+            Stream::Udp(stream) => stream.flush(),
             #[cfg(unix)]
-            Stream::Unix(ref mut stream) => stream.flush(),
+            Stream::Unix(stream) => stream.flush(),
             #[cfg(feature = "tls")]
-            Stream::Tls(ref mut stream) => stream.flush(),
+            Stream::Tls(stream) => stream.flush(),
         }
     }
 }
diff --git a/tests/tests.rs b/tests/tests.rs
index a4a43bc..134ea78 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -2,7 +2,7 @@ extern crate memcache;
 extern crate rand;
 
 use rand::distributions::Alphanumeric;
-use rand::{thread_rng, Rng};
+use rand::{Rng, thread_rng};
 use std::iter;
 use std::thread;
 use std::thread::JoinHandle;