Add PartialEq impls to the character case iterators

Allows easily checking whether a string is in a particular case

Author: Jules-Bertholet

library/core/src/char/methods.rs

@@ -1076,7 +1076,8 @@ impl char {
     }
 
     /// Returns an iterator that yields the lowercase mapping of this `char` as one or more
-    /// `char`s.
+    /// `char`s. The iterator also has implementations of [`Display`][core::fmt::Display]
+    /// and [`PartialEq`].
     ///
     /// If this `char` does not have a lowercase mapping, the iterator yields the same `char`.
     ///
@@ -1134,6 +1135,13 @@ impl char {
     /// // convert into themselves.
     /// assert_eq!('山'.to_lowercase().to_string(), "山");
     /// ```
+    ///
+    /// Check if a string is in lowercase:
+    ///
+    /// ```
+    /// let s = "abcde\u{0301} 山";
+    /// assert!(s.chars().all(|c| c.to_lowercase() == c));
+    /// ```
     #[must_use = "this returns the lowercased character as a new iterator, \
                   without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -1143,7 +1151,8 @@ impl char {
     }
 
     /// Returns an iterator that yields the titlecase mapping of this `char` as one or more
-    /// `char`s.
+    /// `char`s. The iterator also has implementations of [`Display`][core::fmt::Display]
+    /// and [`PartialEq`].
     ///
     /// If this `char` does not have an titlecase mapping, the iterator yields the same `char`.
     ///
@@ -1206,6 +1215,21 @@ impl char {
     /// assert_eq!('山'.to_titlecase().to_string(), "山");
     /// ```
     ///
+    /// Check if a word is in titlecase:
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// let word = "Dross";
+    /// let mut chars = word.chars();
+    /// let first_cased_char = chars.find(|c| c.is_cased());
+    /// let word_is_in_titlecase = if let Some(f) = first_cased_char {
+    ///     f.to_titlecase() == f && chars.all(|c| c.to_lowercase() == c)
+    /// } else {
+    ///     true
+    /// };
+    /// assert!(word_is_in_titlecase);
+    /// ```
+    ///
     /// # Note on locale
     ///
     /// In Turkish and Azeri, the equivalent of 'i' in Latin has five forms instead of two:
@@ -1241,7 +1265,8 @@ impl char {
     }
 
     /// Returns an iterator that yields the uppercase mapping of this `char` as one or more
-    /// `char`s.
+    /// `char`s. The iterator also has implementations of [`Display`][core::fmt::Display]
+    /// and [`PartialEq`].
     ///
     /// If this `char` does not have an uppercase mapping, the iterator yields the same `char`.
     ///
@@ -1300,6 +1325,13 @@ impl char {
     /// assert_eq!('山'.to_uppercase().to_string(), "山");
     /// ```
     ///
+    /// Check if a string is in uppercase:
+    ///
+    /// ```
+    /// let s = "ABCDE\u{0301} 山";
+    /// assert!(s.chars().all(|c| c.to_uppercase() == c));
+    /// ```
+    ///
     /// # Note on locale
     ///
     /// In Turkish and Azeri, the equivalent of 'i' in Latin has five forms instead of two:

library/core/src/char/mod.rs

@@ -380,6 +380,7 @@ macro_rules! casemappingiter_impls {
         #[$fusedstab:meta]
         #[$exactstab:meta]
         #[$displaystab:meta]
+        #[$partialstab:meta]
         $(#[$attr:meta])*
         $ITER_NAME:ident
     ) => {
@@ -478,6 +479,38 @@ macro_rules! casemappingiter_impls {
                 fmt::Display::fmt(&self.0, f)
             }
         }
+
+        #[$partialstab]
+        impl PartialEq<ToUppercase> for $ITER_NAME {
+            #[inline]
+            fn eq(&self, other: &ToUppercase) -> bool {
+                self.0 == other.0
+            }
+        }
+
+        #[unstable(feature = "titlecase", issue = "none")]
+        impl PartialEq<ToTitlecase> for $ITER_NAME {
+            #[inline]
+            fn eq(&self, other: &ToTitlecase) -> bool {
+                self.0 == other.0
+            }
+        }
+
+        #[$partialstab]
+        impl PartialEq<ToLowercase> for $ITER_NAME {
+            #[inline]
+            fn eq(&self, other: &ToLowercase) -> bool {
+                self.0 == other.0
+            }
+        }
+
+        #[$partialstab]
+        impl PartialEq<char> for $ITER_NAME {
+            #[inline]
+            fn eq(&self, other: &char) -> bool {
+                self.0 == *other
+            }
+        }
     }
 }
 
@@ -487,6 +520,7 @@ casemappingiter_impls! {
     #[stable(feature = "fused", since = "1.26.0")]
     #[stable(feature = "exact_size_case_mapping_iter", since = "1.35.0")]
     #[stable(feature = "char_struct_display", since = "1.16.0")]
+    #[stable(feature = "iter_partialeq", since = "CURRENT_RUSTC_VERSION")]
     /// Returns an iterator that yields the uppercase equivalent of a `char`.
     ///
     /// This `struct` is created by the [`to_uppercase`] method on [`char`]. See
@@ -502,6 +536,7 @@ casemappingiter_impls! {
     #[unstable(feature = "titlecase", issue = "none")]
     #[unstable(feature = "titlecase", issue = "none")]
     #[unstable(feature = "titlecase", issue = "none")]
+    #[unstable(feature = "titlecase", issue = "none")]
     /// Returns an iterator that yields the titlecase equivalent of a `char`.
     ///
     /// This `struct` is created by the [`to_titlecase`] method on [`char`]. See
@@ -517,6 +552,7 @@ casemappingiter_impls! {
     #[stable(feature = "fused", since = "1.26.0")]
     #[stable(feature = "exact_size_case_mapping_iter", since = "1.35.0")]
     #[stable(feature = "char_struct_display", since = "1.16.0")]
+    #[stable(feature = "iter_partialeq", since = "CURRENT_RUSTC_VERSION")]
     /// Returns an iterator that yields the lowercase equivalent of a `char`.
     ///
     /// This `struct` is created by the [`to_lowercase`] method on [`char`]. See
@@ -632,6 +668,22 @@ impl fmt::Display for CaseMappingIter {
     }
 }
 
+impl PartialEq for CaseMappingIter {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.0.as_slice() == other.0.as_slice()
+    }
+}
+
+impl Eq for CaseMappingIter {}
+
+impl PartialEq<char> for CaseMappingIter {
+    #[inline]
+    fn eq(&self, other: &char) -> bool {
+        self.0.as_slice() == &[*other]
+    }
+}
+
 /// The error type returned when a checked char conversion fails.
 #[stable(feature = "u8_from_char", since = "1.59.0")]
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]