renamed feature and function back to contains

Author: yonikremer

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 has_iteming the next `N` values.
+    /// Advances the iterator and returns an array containing the next `N` values.
     ///
     /// If there are not enough elements to fill the array then `Err` is returned
-    /// has_iteming an iterator over the remaining elements.
+    /// containing 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
-    /// has_items at least `n` elements, otherwise it has_items all of the
+    /// contains at least `n` elements, otherwise it containss 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 has_itemers.
+    /// Converts an iterator of pairs into a pair of containsers.
     ///
     /// `unzip()` consumes an entire iterator of pairs, producing two
     /// collections: one from the left elements of the pairs, and one
@@ -4062,7 +4062,7 @@ pub trait Iterator {
     }
 
     /// Checks if the Iterator has a value.
-    /// 'has_items' is short-circuiting; in other words, it will stop processing
+    /// 'contains' is short-circuiting; in other words, it will stop processing
     /// as soon as the function finds the item in the Iterator.
     ///
     /// Performance:
@@ -4071,28 +4071,28 @@ pub trait Iterator {
     ///
     /// 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));
+    /// #![feature(iter_contains)]
+    /// assert!(![1i32, 2i32, 3i32].iter().contains(&4i32));
+    /// assert!([Some(2i32), Option::<i32>::None].iter().contains(&None));
+    /// assert!([Some(2i32), Option::<i32>::None].iter().contains(&Some(2i32)));
+    /// assert!(!Vec::<i32>::new().iter().contains(&1i32));
+    /// assert!([1i32, 2i32, 2i32, 3i32].iter().contains(&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
+    /// assert!([Item { value: 1i32 }, Item { value: 2i32 }].iter().contains(&Item { value: 2i32 }));
+    /// assert!(["a", "b", "c"].iter().contains(&"b".to_owned()));
+    /// assert!(!["a", "b", "c"].iter().contains(&"d".to_owned()));
+    /// assert!(["a", "b", "c"].iter().contains(&"b"));
+    /// assert!(!["a", "b", "c"].iter().contains(&"d"));
+    /// assert!(["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().contains(&"b"));
+    /// assert!(!["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().contains(&"d"));
+    /// assert!((1..1000).contains(500i32));
+    /// ```
+    ///
+    #[unstable(feature = "iter_contains", reason = "new API", issue = "127494")]
+    fn contains<Q: ?Sized>(&mut self, item: Q) -> bool
     where
         Q: PartialEq<Self::Item>,
         Self: Sized,

library/core/src/lib.rs

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

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

@@ -618,34 +618,34 @@ fn test_next_chunk() {
 }
 #[test]
 fn test_happy_path_item_not_in_iterator() {
-    assert!(![1i32, 2i32, 3i32].iter().has_item(&4i32));
+    assert!(![1i32, 2i32, 3i32].iter().contains(&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)));
+    assert!([Some(2i32), Option::<i32>::None].iter().contains(&None));
+    assert!([Some(2i32), Option::<i32>::None].iter().contains(&Some(2i32)));
 }
 
 #[test]
 fn test_edge_case_handling_empty_iterator() {
-    assert!(!Vec::<i32>::new().iter().has_item(&1i32));
+    assert!(!Vec::<i32>::new().iter().contains(&1i32));
 }
 
 #[test]
 fn test_edge_case_handling_iterator_with_duplicates() {
-    assert!([1i32, 2i32, 2i32, 3i32].iter().has_item(&2i32));
+    assert!([1i32, 2i32, 2i32, 3i32].iter().contains(&2i32));
 }
 
 #[test]
-/// Tests that short-circuiting works correctly when using `has_item`
+/// Tests that short-circuiting works correctly when using `contains`
 /// When you run the function, it should move the iterator forward after the first appearance of the item
 fn test_short_circuiting() {
     let vector: Vec<i32> = vec![1i32, 2i32, 3i32, 1i32, 1i32];
     let mut iterator = vector.into_iter();
-    assert!(iterator.has_item(1i32));
+    assert!(iterator.contains(1i32));
     assert_eq!(iterator.next(), Some(2));
-    assert!(!iterator.has_item(4i32));
+    assert!(!iterator.contains(4i32));
     assert_eq!(iterator.next(), None);
 }
 
@@ -655,30 +655,30 @@ fn test_edge_case_handling_iterator_with_custom_struct() {
     struct Item {
         value: i32,
     }
-    assert!([Item { value: 1i32 }, Item { value: 2i32 }].iter().has_item(&Item { value: 2i32 }));
+    assert!([Item { value: 1i32 }, Item { value: 2i32 }].iter().contains(&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()));
+fn test_str_iterator_contains_string() {
+    assert!(["a", "b", "c"].iter().contains(&"b".to_owned()));
+    assert!(!["a", "b", "c"].iter().contains(&"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"));
+fn test_str_iterator_contains_string_slice() {
+    assert!(["a", "b", "c"].iter().contains(&"b"));
+    assert!(!["a", "b", "c"].iter().contains(&"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"));
+fn test_string_iterator_contains_str_slice() {
+    assert!(["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().contains(&"b"));
+    assert!(!["a".to_owned(), "b".to_owned(), "c".to_owned()].iter().contains(&"d"));
 }
 
 #[test]
 fn test_edge_case_handling_iterator_with_large_number_of_elements() {
-    assert!((1..1000).has_item(500i32));
+    assert!((1..1000).contains(500i32));
 }
 
 // just tests by whether or not this compiles

library/core/tests/lib.rs

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