chore: avoid single char error bindings

actix-http/src/encoding/decoder.rs

@@ -191,7 +191,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
 
             #[cfg(feature = "compress-gzip")]
@@ -205,7 +205,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
 
             #[cfg(feature = "compress-gzip")]
@@ -218,7 +218,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
 
             #[cfg(feature = "compress-zstd")]
@@ -231,7 +231,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
         }
     }
@@ -250,7 +250,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
 
             #[cfg(feature = "compress-gzip")]
@@ -265,7 +265,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
 
             #[cfg(feature = "compress-gzip")]
@@ -280,7 +280,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
 
             #[cfg(feature = "compress-zstd")]
@@ -295,7 +295,7 @@ impl ContentDecoder {
                         Ok(None)
                     }
                 }
-                Err(e) => Err(e),
+                Err(err) => Err(err),
             },
         }
     }

actix-http/src/h1/decoder.rs

@@ -532,7 +532,7 @@ impl Decoder for PayloadDecoder {
                     *state = match state.step(src, size, &mut buf) {
                         Poll::Pending => return Ok(None),
                         Poll::Ready(Ok(state)) => state,
-                        Poll::Ready(Err(e)) => return Err(e),
+                        Poll::Ready(Err(err)) => return Err(err),
                     };
 
                     if *state == ChunkedState::End {

actix-http/src/responses/builder.rs

@@ -93,7 +93,7 @@ impl ResponseBuilder {
                 Ok((key, value)) => {
                     parts.headers.insert(key, value);
                 }
-                Err(e) => self.err = Some(e.into()),
+                Err(err) => self.err = Some(err.into()),
             };
         }
 
@@ -119,7 +119,7 @@ impl ResponseBuilder {
         if let Some(parts) = self.inner() {
             match header.try_into_pair() {
                 Ok((key, value)) => parts.headers.append(key, value),
-                Err(e) => self.err = Some(e.into()),
+                Err(err) => self.err = Some(err.into()),
             };
         }
 
@@ -193,7 +193,7 @@ impl ResponseBuilder {
                 Ok(value) => {
                     parts.headers.insert(header::CONTENT_TYPE, value);
                 }
-                Err(e) => self.err = Some(e.into()),
+                Err(err) => self.err = Some(err.into()),
             };
         }
         self

actix-http/src/ws/codec.rs

@@ -296,7 +296,7 @@ impl Decoder for Codec {
                 }
             }
             Ok(None) => Ok(None),
-            Err(e) => Err(e),
+            Err(err) => Err(err),
         }
     }
 }

actix-http/tests/test_server.rs

@@ -147,7 +147,7 @@ async fn chunked_payload() {
                     .take_payload()
                     .map(|res| match res {
                         Ok(pl) => pl,
-                        Err(e) => panic!("Error reading payload: {}", e),
+                        Err(err) => panic!("Error reading payload: {err}"),
                     })
                     .fold(0usize, |acc, chunk| ready(acc + chunk.len()))
                     .map(|req_size| {

actix-web-actors/src/ws.rs

@@ -775,10 +775,10 @@ where
                         break;
                     }
                     Poll::Pending => break,
-                    Poll::Ready(Some(Err(e))) => {
+                    Poll::Ready(Some(Err(err))) => {
                         return Poll::Ready(Some(Err(ProtocolError::Io(io::Error::new(
                             io::ErrorKind::Other,
-                            format!("{}", e),
+                            format!("{err}"),
                         )))));
                     }
                 }

actix-web/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "actix-web"
 version = "4.4.0"
+description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
 authors = [
     "Nikolay Kim <fafhrd91@gmail.com>",
     "Rob Ede <robjtede@icloud.com>",
 ]
-description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
 keywords = ["actix", "http", "web", "framework", "async"]
 categories = [
     "network-programming",

actix-web/src/app.rs

@@ -141,8 +141,8 @@ where
                 let fut = data();
                 async move {
                     match fut.await {
-                        Err(e) => {
-                            log::error!("Can not construct data instance: {:?}", e);
+                        Err(err) => {
+                            log::error!("Can not construct data instance: {err:?}");
                             Err(())
                         }
                         Ok(data) => {

actix-web/src/extract.rs

@@ -175,8 +175,8 @@ where
         let res = ready!(this.fut.poll(cx));
         match res {
             Ok(t) => Poll::Ready(Ok(Some(t))),
-            Err(e) => {
-                log::debug!("Error for Option<T> extractor: {}", e.into());
+            Err(err) => {
+                log::debug!("Error for Option<T> extractor: {}", err.into());
                 Poll::Ready(Ok(None))
             }
         }
@@ -217,8 +217,8 @@ where
 /// /// extract `Thing` from request
 /// async fn index(supplied_thing: Result<Thing>) -> String {
 ///     match supplied_thing {
-///         Ok(thing) => format!("Got thing: {:?}", thing),
-///         Err(e) => format!("Error extracting thing: {}", e)
+///         Ok(thing) => format!("Got thing: {thing:?}"),
+///         Err(err) => format!("Error extracting thing: {err}"),
 ///     }
 /// }
 ///
@@ -355,7 +355,7 @@ mod tuple_from_req {
                                 Poll::Ready(Ok(output)) => {
                                     let _ = this.$T.as_mut().project_replace(ExtractFuture::Done { output });
                                 },
-                                Poll::Ready(Err(e)) => return Poll::Ready(Err(e.into())),
+                                Poll::Ready(Err(err)) => return Poll::Ready(Err(err.into())),
                                 Poll::Pending => ready = false,
                             },
                             ExtractProj::Done { .. } => {},

actix-web/src/middleware/logger.rs

@@ -356,7 +356,7 @@ where
 
         let res = match ready!(this.fut.poll(cx)) {
             Ok(res) => res,
-            Err(e) => return Poll::Ready(Err(e)),
+            Err(err) => return Poll::Ready(Err(err)),
         };
 
         if let Some(error) = res.response().error() {

actix-web/src/response/builder.rs

@@ -64,7 +64,7 @@ impl HttpResponseBuilder {
                 Ok((key, value)) => {
                     parts.headers.insert(key, value);
                 }
-                Err(e) => self.error = Some(e.into()),
+                Err(err) => self.error = Some(err.into()),
             };
         }
 
@@ -86,7 +86,7 @@ impl HttpResponseBuilder {
         if let Some(parts) = self.inner() {
             match header.try_into_pair() {
                 Ok((key, value)) => parts.headers.append(key, value),
-                Err(e) => self.error = Some(e.into()),
+                Err(err) => self.error = Some(err.into()),
             };
         }
 
@@ -210,7 +210,7 @@ impl HttpResponseBuilder {
                 Ok(value) => {
                     parts.headers.insert(header::CONTENT_TYPE, value);
                 }
-                Err(e) => self.error = Some(e.into()),
+                Err(err) => self.error = Some(err.into()),
             };
         }
         self

actix-web/src/server.rs

@@ -853,7 +853,7 @@ fn bind_addrs(addrs: impl net::ToSocketAddrs, backlog: u32) -> io::Result<Vec<ne
                 success = true;
                 sockets.push(lst);
             }
-            Err(e) => err = Some(e),
+            Err(error) => err = Some(error),
         }
     }
 

actix-web/src/types/header.rs

@@ -2,7 +2,7 @@
 
 use std::{fmt, ops};
 
-use actix_utils::future::{err, ok, Ready};
+use actix_utils::future::{ready, Ready};
 
 use crate::{
     dev::Payload, error::ParseError, extract::FromRequest, http::header::Header as ParseHeader,
@@ -66,8 +66,8 @@ where
     #[inline]
     fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
         match ParseHeader::parse(req) {
-            Ok(header) => ok(Header(header)),
-            Err(e) => err(e),
+            Ok(header) => ready(Ok(Header(header))),
+            Err(err) => ready(Err(err)),
         }
     }
 }

awc/src/client/connector.rs

@@ -909,8 +909,8 @@ mod resolver {
                 None => {
                     let (cfg, opts) = match read_system_conf() {
                         Ok((cfg, opts)) => (cfg, opts),
-                        Err(e) => {
-                            log::error!("TRust-DNS can not load system config: {}", e);
+                        Err(err) => {
+                            log::error!("Trust-DNS can not load system config: {err}");
                             (ResolverConfig::default(), ResolverOpts::default())
                         }
                     };

awc/src/client/h1proto.rs

@@ -56,7 +56,7 @@ where
                         headers.insert(HOST, value);
                     }
                 },
-                Err(e) => log::error!("Can not set HOST header {}", e),
+                Err(err) => log::error!("Can not set HOST header {err}"),
             }
         }
     }

awc/src/client/h2proto.rs

@@ -106,9 +106,9 @@ where
     }
 
     let res = poll_fn(|cx| io.poll_ready(cx)).await;
-    if let Err(e) = res {
-        io.on_release(e.is_io());
-        return Err(SendRequestError::from(e));
+    if let Err(err) = res {
+        io.on_release(err.is_io());
+        return Err(SendRequestError::from(err));
     }
 
     let resp = match io.send_request(req, eof) {
@@ -120,9 +120,9 @@ where
             }
             fut.await.map_err(SendRequestError::from)?
         }
-        Err(e) => {
-            io.on_release(e.is_io());
-            return Err(e.into());
+        Err(err) => {
+            io.on_release(err.is_io());
+            return Err(err.into());
         }
     };
 
@@ -169,8 +169,8 @@ where
                 let len = b.len();
                 let bytes = b.split_to(std::cmp::min(cap, len));
 
-                if let Err(e) = send.send_data(bytes, false) {
-                    return Err(e.into());
+                if let Err(err) = send.send_data(bytes, false) {
+                    return Err(err.into());
                 }
                 if !b.is_empty() {
                     send.reserve_capacity(b.len());
@@ -179,7 +179,7 @@ where
                 }
                 continue;
             }
-            Some(Err(e)) => return Err(e.into()),
+            Some(Err(err)) => return Err(err.into()),
         }
     }
 }

awc/src/request.rs

@@ -83,7 +83,7 @@ impl ClientRequest {
     {
         match Uri::try_from(uri) {
             Ok(uri) => self.head.uri = uri,
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         }
         self
     }
@@ -152,7 +152,7 @@ impl ClientRequest {
             Ok((key, value)) => {
                 self.head.headers.insert(key, value);
             }
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         };
 
         self
@@ -166,7 +166,7 @@ impl ClientRequest {
                     self.head.headers.insert(key, value);
                 }
             }
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         };
 
         self
@@ -185,7 +185,7 @@ impl ClientRequest {
     pub fn append_header(mut self, header: impl TryIntoHeaderPair) -> Self {
         match header.try_into_pair() {
             Ok((key, value)) => self.head.headers.append(key, value),
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         };
 
         self
@@ -217,7 +217,7 @@ impl ClientRequest {
             Ok(value) => {
                 self.head.headers.insert(header::CONTENT_TYPE, value);
             }
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         }
         self
     }
@@ -299,7 +299,7 @@ impl ClientRequest {
 
             match Uri::from_parts(parts) {
                 Ok(uri) => self.head.uri = uri,
-                Err(e) => self.err = Some(e.into()),
+                Err(err) => self.err = Some(err.into()),
             }
         }
 
@@ -311,7 +311,7 @@ impl ClientRequest {
     pub fn freeze(self) -> Result<FrozenClientRequest, FreezeRequestError> {
         let slf = match self.prep_for_sending() {
             Ok(slf) => slf,
-            Err(e) => return Err(e.into()),
+            Err(err) => return Err(err.into()),
         };
 
         let request = FrozenClientRequest {
@@ -332,7 +332,7 @@ impl ClientRequest {
     {
         let slf = match self.prep_for_sending() {
             Ok(slf) => slf,
-            Err(e) => return e.into(),
+            Err(err) => return err.into(),
         };
 
         RequestSender::Owned(slf.head).send_body(
@@ -348,7 +348,7 @@ impl ClientRequest {
     pub fn send_json<T: Serialize>(self, value: &T) -> SendClientRequest {
         let slf = match self.prep_for_sending() {
             Ok(slf) => slf,
-            Err(e) => return e.into(),
+            Err(err) => return err.into(),
         };
 
         RequestSender::Owned(slf.head).send_json(
@@ -366,7 +366,7 @@ impl ClientRequest {
     pub fn send_form<T: Serialize>(self, value: &T) -> SendClientRequest {
         let slf = match self.prep_for_sending() {
             Ok(slf) => slf,
-            Err(e) => return e.into(),
+            Err(err) => return err.into(),
         };
 
         RequestSender::Owned(slf.head).send_form(
@@ -386,7 +386,7 @@ impl ClientRequest {
     {
         let slf = match self.prep_for_sending() {
             Ok(slf) => slf,
-            Err(e) => return e.into(),
+            Err(err) => return err.into(),
         };
 
         RequestSender::Owned(slf.head).send_stream(
@@ -402,7 +402,7 @@ impl ClientRequest {
     pub fn send(self) -> SendClientRequest {
         let slf = match self.prep_for_sending() {
             Ok(slf) => slf,
-            Err(e) => return e.into(),
+            Err(err) => return err.into(),
         };
 
         RequestSender::Owned(slf.head).send(

awc/src/sender.rs

@@ -122,8 +122,8 @@ impl Future for SendClientRequest {
 
                 Poll::Ready(res)
             }
-            SendClientRequest::Err(ref mut e) => match e.take() {
-                Some(e) => Poll::Ready(Err(e)),
+            SendClientRequest::Err(ref mut err) => match err.take() {
+                Some(err) => Poll::Ready(Err(err)),
                 None => panic!("Attempting to call completed future"),
             },
         }
@@ -147,8 +147,8 @@ impl Future for SendClientRequest {
                     .poll(cx)
                     .map_ok(|res| res.into_client_response()._timeout(delay.take()))
             }
-            SendClientRequest::Err(ref mut e) => match e.take() {
-                Some(e) => Poll::Ready(Err(e)),
+            SendClientRequest::Err(ref mut err) => match err.take() {
+                Some(err) => Poll::Ready(Err(err)),
                 None => panic!("Attempting to call completed future"),
             },
         }
@@ -219,8 +219,8 @@ impl RequestSender {
             Err(err) => return PrepForSendingError::Json(err).into(),
         };
 
-        if let Err(e) = self.set_header_if_none(header::CONTENT_TYPE, "application/json") {
-            return e.into();
+        if let Err(err) = self.set_header_if_none(header::CONTENT_TYPE, "application/json") {
+            return err.into();
         }
 
         self.send_body(addr, response_decompress, timeout, config, body)
@@ -291,7 +291,7 @@ impl RequestSender {
                         Ok(value) => {
                             head.headers.insert(key, value);
                         }
-                        Err(e) => return Err(e.into()),
+                        Err(err) => return Err(err.into()),
                     }
                 }
             }
@@ -304,7 +304,7 @@ impl RequestSender {
                             let h = extra_headers.get_or_insert(HeaderMap::new());
                             h.insert(key, v)
                         }
-                        Err(e) => return Err(e.into()),
+                        Err(err) => return Err(err.into()),
                     };
                 }
             }

awc/src/ws.rs

@@ -64,7 +64,7 @@ pub struct WebsocketsRequest {
 }
 
 impl WebsocketsRequest {
-    /// Create new WebSocket connection
+    /// Create new WebSocket connection.
     pub(crate) fn new<U>(uri: U, config: ClientConfig) -> Self
     where
         Uri: TryFrom<U>,
@@ -82,7 +82,7 @@ impl WebsocketsRequest {
 
         match Uri::try_from(uri) {
             Ok(uri) => head.uri = uri,
-            Err(e) => err = Some(e.into()),
+            Err(error) => err = Some(error.into()),
         }
 
         WebsocketsRequest {
@@ -143,7 +143,7 @@ impl WebsocketsRequest {
     {
         match HeaderValue::try_from(origin) {
             Ok(value) => self.origin = Some(value),
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         }
         self
     }
@@ -177,9 +177,9 @@ impl WebsocketsRequest {
                 Ok(value) => {
                     self.head.headers.append(key, value);
                 }
-                Err(e) => self.err = Some(e.into()),
+                Err(err) => self.err = Some(err.into()),
             },
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         }
         self
     }
@@ -196,9 +196,9 @@ impl WebsocketsRequest {
                 Ok(value) => {
                     self.head.headers.insert(key, value);
                 }
-                Err(e) => self.err = Some(e.into()),
+                Err(err) => self.err = Some(err.into()),
             },
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         }
         self
     }
@@ -217,11 +217,11 @@ impl WebsocketsRequest {
                         Ok(value) => {
                             self.head.headers.insert(key, value);
                         }
-                        Err(e) => self.err = Some(e.into()),
+                        Err(err) => self.err = Some(err.into()),
                     }
                 }
             }
-            Err(e) => self.err = Some(e.into()),
+            Err(err) => self.err = Some(err.into()),
         }
         self
     }