Adding the has_item function to the iterator trait.

library/core/Cargo.toml

@@ -36,6 +36,8 @@ optimize_for_size = []
 # Make `RefCell` store additional debugging information, which is printed out when
 # a borrow error occurs
 debug_refcell = []
+# Adds a function to check if an element is contained in an iterator
+contains = []
 
 [lints.rust.unexpected_cfgs]
 level = "warn"

library/core/src/iter/traits/iterator.rs

@@ -79,10 +79,10 @@ pub trait Iterator {
     #[stable(feature = "rust1", since = "1.0.0")]
     fn next(&mut self) -> Option<Self::Item>;
 
-    /// Advances the iterator and returns an array containing the next `N` values.
+    /// Advances the iterator and returns an array has_iteming the next `N` values.
     ///
     /// If there are not enough elements to fill the array then `Err` is returned
-    /// containing an iterator over the remaining elements.
+    /// has_iteming an iterator over the remaining elements.
     ///
     /// # Examples
     ///
@@ -1327,7 +1327,7 @@ pub trait Iterator {
     /// `take(n)` yields elements until `n` elements are yielded or the end of
     /// the iterator is reached (whichever happens first).
     /// The returned iterator is a prefix of length `n` if the original iterator
-    /// contains at least `n` elements, otherwise it contains all of the
+    /// has_items at least `n` elements, otherwise it has_items all of the
     /// (fewer than `n`) elements of the original iterator.
     ///
     /// # Examples
@@ -3356,7 +3356,7 @@ pub trait Iterator {
         Rev::new(self)
     }
 
-    /// Converts an iterator of pairs into a pair of containers.
+    /// Converts an iterator of pairs into a pair of has_itemers.
     ///
     /// `unzip()` consumes an entire iterator of pairs, producing two
     /// collections: one from the left elements of the pairs, and one
@@ -4060,6 +4060,50 @@ pub trait Iterator {
     {
         unreachable!("Always specialized");
     }
+
+    /// Checks if the Iterator has a value.
+    /// 'has_items' is short-circuiting; in other words, it will stop processing
+    /// as soon as the function finds the item in the Iterator.
+    ///
+    /// Performance:
+    /// This method checks the whole iterator, which takes O(n) time.
+    /// If the iterator is sorted, or a hash map please use the appropriate method instead.
+    ///
+    /// Example:
+    /// ```
+    /// #![feature(iter_has_item)]
+    /// assert!(![1i32, 2i32, 3i32].iter().has_item(&4i32));
+    /// assert!([Some(2i32), Option::<i32>::None].iter().has_item(&None));
+    /// assert!([Some(2i32), Option::<i32>::None].iter().has_item(&Some(2i32)));
+    /// assert!(!Vec::<i32>::new().iter().has_item(&1i32));
+    /// assert!([1i32, 2i32, 2i32, 3i32].iter().has_item(&2i32));
+    /// #[derive(PartialEq)]
+    /// struct Item {
+    ///     value: i32,
+    /// }
+    /// assert!([Item { value: 1i32 }, Item { value: 2i32 }].iter().has_item(&Item { value: 2i32 }));
+    /// assert!(["a", "b", "c"].iter().has_item(&"b".to_owned()));
+    /// assert!(!["a", "b", "c"].iter().has_item(&"d".to_owned()));
+    /// assert!(["a", "b", "c"].iter().has_item(&"b"));
+    /// assert!(!["a", "b", "c"].iter().has_item(&"d"));
+    /// assert!(["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().has_item(&"b"));
+    /// assert!(!["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().has_item(&"d"));
+    /// assert!((1..1000).has_item(500i32));
+    /// ```
+    ///
+    #[unstable(feature = "iter_has_item", reason = "new API", issue = "127494")]
+    fn has_item<Q: ?Sized>(&mut self, item: Q) -> bool
+    where
+        Q: PartialEq<Self::Item>,
+        Self: Sized,
+    {
+        for element in self {
+            if item == element {
+                return true;
+            }
+        }
+        return false;
+    }
 }
 
 /// Compares two iterators element-wise using the given function.

library/core/src/lib.rs

@@ -171,6 +171,7 @@
 #![feature(ip)]
 #![feature(is_ascii_octdigit)]
 #![feature(isqrt)]
+#![feature(iter_has_item)]
 #![feature(link_cfg)]
 #![feature(offset_of_enum)]
 #![feature(offset_of_nested)]

library/core/tests/iter/traits/iterator.rs

@@ -616,6 +616,69 @@ fn test_next_chunk() {
     let mut it = std::iter::repeat_with(|| panic!());
     assert_eq!(it.next_chunk::<0>().unwrap(), []);
 }
+#[test]
+fn test_happy_path_item_not_in_iterator() {
+    assert!(![1i32, 2i32, 3i32].iter().has_item(&4i32));
+}
+
+#[test]
+fn test_edge_case_handling_none_values() {
+    assert!([Some(2i32), Option::<i32>::None].iter().has_item(&None));
+    assert!([Some(2i32), Option::<i32>::None].iter().has_item(&Some(2i32)));
+}
+
+#[test]
+fn test_edge_case_handling_empty_iterator() {
+    assert!(!Vec::<i32>::new().iter().has_item(&1i32));
+}
+
+#[test]
+fn test_edge_case_handling_iterator_with_duplicates() {
+    assert!([1i32, 2i32, 2i32, 3i32].iter().has_item(&2i32));
+}
+
+#[test]
+/// Tests that short-circuiting works correctly when using `has_item`
+/// When you run the function, it should move the iterator forward after the first appearance of the item
+fn test_short_circuiting() {
+    let mut iterator = vec![1, 2, 3, 1, 1].into_iter();
+    assert!(iterator.has_item(&1));
+    assert_eq!(iterator.next(), Some(2));
+    assert!(!iterator.has_item(&4));
+    assert_eq!(iterator.next(), None);
+}
+
+#[test]
+fn test_edge_case_handling_iterator_with_custom_struct() {
+    #[derive(PartialEq)]
+    struct Item {
+        value: i32,
+    }
+    assert!([Item { value: 1i32 }, Item { value: 2i32 }].iter().has_item(&Item { value: 2i32 }));
+}
+
+#[test]
+fn test_str_iterator_has_item_string() {
+    assert!(["a", "b", "c"].iter().has_item(&"b".to_owned()));
+    assert!(!["a", "b", "c"].iter().has_item(&"d".to_owned()));
+}
+
+#[test]
+fn test_str_iterator_has_item_string_slice() {
+    assert!(["a", "b", "c"].iter().has_item(&"b"));
+    assert!(!["a", "b", "c"].iter().has_item(&"d"));
+}
+
+#[test]
+fn test_string_iterator_has_item_str_slice() {
+    assert!(["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().has_item(&"b"));
+    assert!(!["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().has_item(&"d"));
+}
+
+#[test]
+fn test_edge_case_handling_iterator_with_large_number_of_elements() {
+    assert!((1..1000).has_item(500i32));
+}
 
 // just tests by whether or not this compiles
 fn _empty_impl_all_auto_traits<T>() {

library/core/tests/lib.rs

@@ -89,6 +89,7 @@
 #![feature(const_mut_refs)]
 #![feature(const_pin)]
 #![feature(const_waker)]
+#![feature(iter_has_item)]
 #![feature(never_type)]
 #![feature(unwrap_infallible)]
 #![feature(pointer_is_aligned_to)]

src/tools/rust-analyzer/crates/ide-db/src/generated/lints.rs

@@ -6074,6 +6074,17 @@ The tracking issue for this feature is: None.
 
 ------------------------
 
+"##,
+    },
+    Lint {
+        label: "contains",
+        description: r##"# `contains`
+
+The tracking issue for this feature is: [#94047]
+
+[#94047]: https://github.com/rust-lang/rust/issues/94047
+
+
 The `rustc` compiler has certain pluggable operations, that is,
 functionality that isn't hard-coded into the language, but is
 implemented in libraries, with a special marker to tell the compiler