remove either crate and simplify AsName trait

actix-http/Cargo.toml

@@ -53,7 +53,6 @@ bytes = "1"
 bytestring = "1"
 cookie = { version = "0.14.1", features = ["percent-encode"] }
 derive_more = "0.99.5"
-either = "1.5.3"
 encoding_rs = "0.8"
 futures-channel = { version = "0.3.7", default-features = false }
 futures-core = { version = "0.3.7", default-features = false }

actix-http/src/header/map.rs

@@ -4,8 +4,7 @@ use std::{
 };
 
 use ahash::AHashMap;
-use either::Either;
+use http::header::{HeaderName, HeaderValue, InvalidHeaderName};
-use http::header::{HeaderName, HeaderValue};
 use smallvec::{smallvec, SmallVec};
 
 /// A multi-map of HTTP headers.
@@ -126,14 +125,9 @@ impl HeaderMap {
 
     fn get2<N: AsName>(&self, name: N) -> Option<&Value> {
         match name.as_name() {
-            Either::Left(name) => self.inner.get(name),
+            AsHeaderName::Borrowed(name) => self.inner.get(name),
-            Either::Right(s) => {
+            AsHeaderName::Owned(Ok(name)) => self.inner.get(&name),
-                if let Ok(name) = HeaderName::try_from(s) {
+            AsHeaderName::Owned(Err(_)) => None,
-                    self.inner.get(&name)
-                } else {
-                    None
-                }
-            }
         }
     }
 
@@ -156,28 +150,22 @@ impl HeaderMap {
     /// key. Returns `None` if there are no values associated with the key.
     pub fn get_mut<N: AsName>(&mut self, name: N) -> Option<&mut HeaderValue> {
         match name.as_name() {
-            Either::Left(name) => self.inner.get_mut(name).map(|v| v.first_mut()),
+            AsHeaderName::Borrowed(name) => {
-            Either::Right(s) => {
+                self.inner.get_mut(name).map(|v| v.first_mut())
-                if let Ok(name) = HeaderName::try_from(s) {
+            }
+            AsHeaderName::Owned(Ok(name)) => {
                 self.inner.get_mut(&name).map(|v| v.first_mut())
-                } else {
-                    None
-                }
             }
+            AsHeaderName::Owned(Err(_)) => None,
         }
     }
 
     /// Returns true if the map contains a value for the specified key.
     pub fn contains_key<N: AsName>(&self, key: N) -> bool {
         match key.as_name() {
-            Either::Left(name) => self.inner.contains_key(name),
+            AsHeaderName::Borrowed(name) => self.inner.contains_key(name),
-            Either::Right(s) => {
+            AsHeaderName::Owned(Ok(name)) => self.inner.contains_key(&name),
-                if let Ok(name) = HeaderName::try_from(s) {
+            AsHeaderName::Owned(Err(_)) => false,
-                    self.inner.contains_key(&name)
-                } else {
-                    false
-                }
-            }
         }
     }
 
@@ -238,50 +226,55 @@ impl HeaderMap {
     /// Removes all headers for a particular header name from the map.
     pub fn remove<N: AsName>(&mut self, key: N) {
         match key.as_name() {
-            Either::Left(name) => {
+            AsHeaderName::Borrowed(name) => {
                 let _ = self.inner.remove(name);
             }
-            Either::Right(s) => {
+            AsHeaderName::Owned(Ok(name)) => {
-                if let Ok(name) = HeaderName::try_from(s) {
                 let _ = self.inner.remove(&name);
             }
-            }
+            AsHeaderName::Owned(Err(_)) => {}
         }
     }
 }
 
+#[doc(hidden)]
+pub enum AsHeaderName<'a> {
+    Owned(Result<HeaderName, InvalidHeaderName>),
+    Borrowed(&'a HeaderName),
+}
+
 #[doc(hidden)]
 pub trait AsName {
-    fn as_name(&self) -> Either<&HeaderName, &str>;
+    fn as_name(&self) -> AsHeaderName<'_>;
 }
 
 impl AsName for HeaderName {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
+    fn as_name(&self) -> AsHeaderName<'_> {
-        Either::Left(self)
+        AsHeaderName::Borrowed(self)
     }
 }
 
 impl<'a> AsName for &'a HeaderName {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
+    fn as_name(&self) -> AsHeaderName<'_> {
-        Either::Left(self)
+        AsHeaderName::Borrowed(self)
     }
 }
 
 impl<'a> AsName for &'a str {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
+    fn as_name(&self) -> AsHeaderName<'_> {
-        Either::Right(self)
+        AsHeaderName::Owned(HeaderName::try_from(*self))
     }
 }
 
 impl AsName for String {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
+    fn as_name(&self) -> AsHeaderName<'_> {
-        Either::Right(self.as_str())
+        AsHeaderName::Owned(HeaderName::try_from(self.as_str()))
     }
 }
 
 impl<'a> AsName for &'a String {
-    fn as_name(&self) -> Either<&HeaderName, &str> {
+    fn as_name(&self) -> AsHeaderName<'_> {
-        Either::Right(self.as_str())
+        AsHeaderName::Owned(HeaderName::try_from(self.as_str()))
     }
 }