chore: avoid collecting iterators when possible

src/address.rs

@@ -112,21 +112,17 @@ impl FromStr for Address {
     type Err = AddressError;
 
     fn from_str(val: &str) -> Result<Self, AddressError> {
-        if val.is_empty() || !val.contains('@') {
-            return Err(AddressError::MissingParts);
-        }
+        let mut parts = val.rsplitn(2, '@');
+        let domain = parts.next().ok_or(AddressError::MissingParts)?;
+        let user = parts.next().ok_or(AddressError::MissingParts)?;
 
-        let parts: Vec<&str> = val.rsplitn(2, '@').collect();
-        let user = parts[1];
-        let domain = parts[0];
-
-        Address::check_user(user)
-            .and_then(|_| Address::check_domain(domain))
-            .map(|_| Address {
-                user: user.into(),
-                domain: domain.into(),
-                complete: val.to_string(),
-            })
+        Address::check_user(user)?;
+        Address::check_domain(domain)?;
+        Ok(Address {
+            user: user.into(),
+            domain: domain.into(),
+            complete: val.to_string(),
+        })
     }
 }
 

src/message/header/special.rs

@@ -35,15 +35,12 @@ impl Header for MimeVersion {
         Self: Sized,
     {
         raw.one().ok_or(HeaderError::Header).and_then(|r| {
-            let s: Vec<&str> = from_utf8(r)
-                .map_err(|_| HeaderError::Header)?
-                .split('.')
-                .collect();
-            if s.len() != 2 {
-                return Err(HeaderError::Header);
-            }
-            let major = s[0].parse().map_err(|_| HeaderError::Header)?;
-            let minor = s[1].parse().map_err(|_| HeaderError::Header)?;
+            let mut s = from_utf8(r).map_err(|_| HeaderError::Header)?.split('.');
+
+            let major = s.next().ok_or(HeaderError::Header)?;
+            let minor = s.next().ok_or(HeaderError::Header)?;
+            let major = major.parse().map_err(|_| HeaderError::Header)?;
+            let minor = minor.parse().map_err(|_| HeaderError::Header)?;
             Ok(MimeVersion::new(major, minor))
         })
     }

src/message/mimebody.rs

@@ -209,10 +209,8 @@ fn make_boundary() -> String {
 }
 
 impl MultiPartKind {
-    fn to_mime<S: AsRef<str>>(&self, boundary: Option<S>) -> Mime {
-        let boundary = boundary
-            .map(|s| s.as_ref().into())
-            .unwrap_or_else(make_boundary);
+    fn to_mime<S: Into<String>>(&self, boundary: Option<S>) -> Mime {
+        let boundary = boundary.map_or_else(make_boundary, |s| s.into());
 
         use self::MultiPartKind::*;
         format!(

src/transport/smtp/response.rs

@@ -237,25 +237,19 @@ pub(crate) fn parse_response(i: &str) -> IResult<&str, Response> {
     let (i, _) = complete(tag("\r\n"))(i)?;
 
     // Check that all codes are equal.
-    if !lines.iter().all(|&(ref code, _, _)| *code == last_code) {
+    if !lines.iter().all(|&(code, _, _)| code == last_code) {
         return Err(nom::Err::Failure(("", nom::error::ErrorKind::Not)));
     }
 
     // Extract text from lines, and append last line.
-    let mut lines: Vec<&str> = lines
-        .into_iter()
-        .map(|(_, text, _)| text)
-        .collect::<Vec<_>>();
-    lines.push(last_line);
+    let mut lines: Vec<String> = lines.into_iter().map(|(_, text, _)| text.into()).collect();
+    lines.push(last_line.into());
 
     Ok((
         i,
         Response {
             code: last_code,
-            message: lines
-                .iter()
-                .map(ToString::to_string)
-                .collect::<Vec<String>>(),
+            message: lines,
         },
     ))
 }