Generalise slice::contains over PartialEq

This allows `contains` to be used on slices to search for elements that
satisfy a partial equality with the slice item type, rather than an
identity. This closes #42671. Note that string literals need to be
referenced in this implementation due to `str` not implementing
`Sized`. It’s likely this will have to go through a Crater run to test
for breakage (see #43020).

Author: varkor

src/liballoc/slice.rs

@@ -980,8 +980,8 @@ impl<T> [T] {
     /// assert!(!v.contains(&50));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn contains(&self, x: &T) -> bool
-        where T: PartialEq
+    pub fn contains<U>(&self, x: &U) -> bool
+        where T: PartialEq<U>
     {
         core_slice::SliceExt::contains(self, x)
     }

src/liballoc/tests/slice.rs

@@ -1051,6 +1051,19 @@ fn test_shrink_to_fit() {
     assert_eq!(xs, (0..100).collect::<Vec<_>>());
 }
 
+#[test]
+fn test_contains() {
+    let numbers = [1, 2, 3];
+    assert!(numbers.contains(&2));
+    assert!(!numbers.contains(&4));
+
+    let strings = vec![String::from("AB"), String::from("CD")];
+    assert!(strings.contains(&String::from("AB")));
+    assert!(!strings.contains(&String::from("A")));
+    assert!(strings.contains(&"AB"));
+    assert!(!strings.contains(&"BC"));
+}
+
 #[test]
 fn test_starts_with() {
     assert!(b"foobar".starts_with(b"foo"));

src/libcore/slice/mod.rs

@@ -192,7 +192,7 @@ pub trait SliceExt {
     fn as_mut_ptr(&mut self) -> *mut Self::Item;
 
     #[stable(feature = "core", since = "1.6.0")]
-    fn contains(&self, x: &Self::Item) -> bool where Self::Item: PartialEq;
+    fn contains<U>(&self, x: &U) -> bool where Self::Item: PartialEq<U>;
 
     #[stable(feature = "core", since = "1.6.0")]
     fn starts_with(&self, needle: &[Self::Item]) -> bool where Self::Item: PartialEq;
@@ -618,8 +618,8 @@ impl<T> SliceExt for [T] {
     }
 
     #[inline]
-    fn contains(&self, x: &T) -> bool where T: PartialEq {
-        self.iter().any(|elt| *x == *elt)
+    fn contains<U>(&self, x: &U) -> bool where T: PartialEq<U> {
+        self.iter().any(|e| e == x)
     }
 
     #[inline]