Auto merge of #59591 - kennytm:needle-api, r=<try>

[WIP] Implement Needle API (RFC 2500)

cc #56345

----

Insta-stable changes:

* `impl Index<Range***> for OsStr` cannot be gated and is insta-stable.

I'll add more comments after the crater run.

Author: bors

src/liballoc/lib.rs

@@ -93,7 +93,7 @@
 #![feature(needs_allocator)]
 #![feature(nll)]
 #![feature(optin_builtin_traits)]
-#![feature(pattern)]
+#![feature(needle)]
 #![feature(ptr_internals)]
 #![feature(ptr_offset_from)]
 #![feature(rustc_attrs)]

src/liballoc/slice.rs

@@ -92,6 +92,7 @@ use core::cmp::Ordering::{self, Less};
 use core::mem::{self, size_of};
 use core::ptr;
 use core::{u8, u16, u32};
+use core::needle::{ext, Needle, Searcher, Consumer};
 
 use crate::borrow::ToOwned;
 use crate::boxed::Box;
@@ -485,6 +486,40 @@ impl<T> [T] {
         }
         buf
     }
+
+    /// Replaces all matches of a predicate with another slice.
+    #[unstable(feature = "slice_needle_methods", issue = "56345")]
+    #[inline]
+    #[must_use = "this returns the replaced slice as a new allocation, \
+                  without modifying the original"]
+    pub fn replace<'s: 'a, 'a, F>(&'s self, from: F, to: &'a [T]) -> Vec<T>
+    where
+        T: Clone,
+        F: Needle<&'a [T]>,
+        F::Searcher: Searcher<[T]>, // FIXME: RFC 2089
+        F::Consumer: Consumer<[T]>, // FIXME: RFC 2089
+    {
+        let mut result = Vec::with_capacity(self.len());
+        ext::replace_with(self, from, |_| to, |s| result.extend_from_slice(s));
+        result
+    }
+
+    /// Replaces first N matches of a predicate with another slice.
+    #[unstable(feature = "slice_needle_methods", issue = "56345")]
+    #[inline]
+    #[must_use = "this returns the replaced slice as a new allocation, \
+                  without modifying the original"]
+    pub fn replacen<'s: 'a, 'a, F>(&'s self, from: F, to: &'a [T], count: usize) -> Vec<T>
+    where
+        T: Clone,
+        F: Needle<&'a [T]>,
+        F::Searcher: Searcher<[T]>, // FIXME: RFC 2089
+        F::Consumer: Consumer<[T]>, // FIXME: RFC 2089
+    {
+        let mut result = Vec::with_capacity(self.len());
+        ext::replacen_with(self, from, |_| to, count, |s| result.extend_from_slice(s));
+        result
+    }
 }
 
 #[lang = "slice_u8_alloc"]

src/liballoc/str.rs

@@ -28,14 +28,14 @@
 // It's cleaner to just turn off the unused_imports warning than to fix them.
 #![allow(unused_imports)]
 
-use core::borrow::Borrow;
-use core::str::pattern::{Pattern, Searcher, ReverseSearcher, DoubleEndedSearcher};
+use core::fmt;
+use core::needle::{ext, Needle, Searcher, Consumer};
 use core::mem;
 use core::ptr;
 use core::iter::FusedIterator;
 use core::unicode::conversions;
 
-use crate::borrow::ToOwned;
+use crate::borrow::{Borrow, ToOwned};
 use crate::boxed::Box;
 use crate::slice::{SliceConcatExt, SliceIndex};
 use crate::string::String;
@@ -62,8 +62,6 @@ pub use core::str::{from_utf8, from_utf8_mut, Chars, CharIndices, Bytes};
 pub use core::str::{from_utf8_unchecked, from_utf8_unchecked_mut, ParseBoolError};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::str::SplitWhitespace;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::pattern;
 #[stable(feature = "encode_utf16", since = "1.8.0")]
 pub use core::str::EncodeUtf16;
 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
@@ -253,15 +251,14 @@ impl str {
                   without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String {
-        let mut result = String::new();
-        let mut last_end = 0;
-        for (start, part) in self.match_indices(from) {
-            result.push_str(unsafe { self.get_unchecked(last_end..start) });
-            result.push_str(to);
-            last_end = start + part.len();
-        }
-        result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });
+    pub fn replace<'s: 'a, 'a, P>(&'s self, from: P, to: &'a str) -> String
+    where
+        P: Needle<&'a str>,
+        P::Searcher: Searcher<str>, // FIXME: RFC 2089
+        P::Consumer: Consumer<str>, // FIXME: RFC 2089
+    {
+        let mut result = String::with_capacity(self.len());
+        ext::replace_with(self, from, |_| to, |s| result.push_str(s));
         result
     }
 
@@ -293,16 +290,15 @@ impl str {
     #[must_use = "this returns the replaced string as a new allocation, \
                   without modifying the original"]
     #[stable(feature = "str_replacen", since = "1.16.0")]
-    pub fn replacen<'a, P: Pattern<'a>>(&'a self, pat: P, to: &str, count: usize) -> String {
+    pub fn replacen<'s: 'a, 'a, P>(&'s self, pat: P, to: &'a str, count: usize) -> String
+    where
+        P: Needle<&'a str>,
+        P::Searcher: Searcher<str>, // FIXME: RFC 2089
+        P::Consumer: Consumer<str>, // FIXME: RFC 2089
+    {
         // Hope to reduce the times of re-allocation
-        let mut result = String::with_capacity(32);
-        let mut last_end = 0;
-        for (start, part) in self.match_indices(pat).take(count) {
-            result.push_str(unsafe { self.get_unchecked(last_end..start) });
-            result.push_str(to);
-            last_end = start + part.len();
-        }
-        result.push_str(unsafe { self.get_unchecked(last_end..self.len()) });
+        let mut result = String::with_capacity(self.len());
+        ext::replacen_with(self, pat, |_| to, count, |s| result.push_str(s));
         result
     }
 

src/liballoc/string.rs

@@ -53,7 +53,8 @@ use core::iter::{FromIterator, FusedIterator};
 use core::ops::{self, Add, AddAssign, Index, IndexMut, RangeBounds};
 use core::ops::Bound::{Excluded, Included, Unbounded};
 use core::ptr;
-use core::str::{pattern::Pattern, lossy};
+use core::needle::Needle;
+use core::str::lossy;
 
 use crate::borrow::{Cow, ToOwned};
 use crate::collections::CollectionAllocErr;
@@ -1792,24 +1793,19 @@ impl<'a> Extend<Cow<'a, str>> for String {
 }
 
 /// A convenience impl that delegates to the impl for `&str`
-#[unstable(feature = "pattern",
-           reason = "API not fully fleshed out and ready to be stabilized",
-           issue = "27721")]
-impl<'a, 'b> Pattern<'a> for &'b String {
-    type Searcher = <&'b str as Pattern<'a>>::Searcher;
-
-    fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher {
-        self[..].into_searcher(haystack)
-    }
+#[unstable(feature = "needle", issue = "56345")]
+impl<'a, 'b> Needle<&'a str> for &'b String {
+    type Searcher = <&'b str as Needle<&'a str>>::Searcher;
+    type Consumer = <&'b str as Needle<&'a str>>::Consumer;
 
     #[inline]
-    fn is_contained_in(self, haystack: &'a str) -> bool {
-        self[..].is_contained_in(haystack)
+    fn into_searcher(self) -> Self::Searcher {
+        <&'b str as Needle<&'a str>>::into_searcher(&**self)
     }
 
     #[inline]
-    fn is_prefix_of(self, haystack: &'a str) -> bool {
-        self[..].is_prefix_of(haystack)
+    fn into_consumer(self) -> Self::Consumer {
+        <&'b str as Needle<&'a str>>::into_consumer(&**self)
     }
 }
 

src/liballoc/tests/lib.rs

@@ -2,11 +2,13 @@
 #![feature(box_syntax)]
 #![feature(drain_filter)]
 #![feature(exact_size_is_empty)]
-#![feature(pattern)]
 #![feature(repeat_generic_slice)]
+#![feature(needle)]
 #![feature(try_reserve)]
 #![feature(unboxed_closures)]
 #![feature(vecdeque_rotate)]
+#![feature(mut_str_needle_methods)]
+#![feature(slice_needle_methods)]
 
 use std::hash::{Hash, Hasher};
 use std::collections::hash_map::DefaultHasher;

src/liballoc/tests/slice.rs

@@ -5,6 +5,7 @@ use std::panic;
 use std::rc::Rc;
 use std::sync::atomic::{Ordering::Relaxed, AtomicUsize};
 use std::thread;
+use std::f64::NAN;
 
 use rand::{Rng, RngCore, thread_rng};
 use rand::seq::SliceRandom;
@@ -835,88 +836,88 @@ fn test_splitator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1], &[3], &[5]];
-    assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[], &[2, 3, 4, 5]];
-    assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 1).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[1, 2, 3, 4], &[]];
-    assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 5).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 10).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
-    assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(), splits);
+    assert_eq!(xs.split(|_: &i32| true).collect::<Vec<&[i32]>>(), splits);
 
     let xs: &[i32] = &[];
     let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 5).collect::<Vec<&[i32]>>(), splits);
 }
 
 #[test]
 fn test_splitnator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.splitn(1, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[1], &[3, 4, 5]];
-    assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.splitn(2, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[], &[], &[], &[4, 5]];
-    assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.splitn(4, |_: &i32| true).collect::<Vec<_>>(), splits);
 
     let xs: &[i32] = &[];
     let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.splitn(2, |x: &i32| *x == 5).collect::<Vec<_>>(), splits);
 }
 
 #[test]
 fn test_splitnator_mut() {
     let xs = &mut [1, 2, 3, 4, 5];
 
     let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]];
-    assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
+    assert_eq!(xs.splitn_mut(1, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(),
                splits);
     let splits: &[&mut [_]] = &[&mut [1], &mut [3, 4, 5]];
-    assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
+    assert_eq!(xs.splitn_mut(2, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(),
                splits);
     let splits: &[&mut [_]] = &[&mut [], &mut [], &mut [], &mut [4, 5]];
-    assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.splitn_mut(4, |_: &i32| true).collect::<Vec<_>>(), splits);
 
     let xs: &mut [i32] = &mut [];
     let splits: &[&mut [i32]] = &[&mut []];
-    assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.splitn_mut(2, |x: &i32| *x == 5).collect::<Vec<_>>(), splits);
 }
 
 #[test]
 fn test_rsplitator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[5], &[3], &[1]];
-    assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[2, 3, 4, 5], &[]];
-    assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 1).rev().collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[], &[1, 2, 3, 4]];
-    assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 5).rev().collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 10).rev().collect::<Vec<_>>(), splits);
 
     let xs: &[i32] = &[];
     let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
+    assert_eq!(xs.split(|x: &i32| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
 }
 
 #[test]
 fn test_rsplitnator() {
     let xs = &[1, 2, 3, 4, 5];
 
     let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.rsplitn(1, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[5], &[1, 2, 3]];
-    assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.rsplitn(2, |x: &i32| *x % 2 == 0).collect::<Vec<_>>(), splits);
     let splits: &[&[_]] = &[&[], &[], &[], &[1, 2]];
-    assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(), splits);
+    assert_eq!(xs.rsplitn(4, |_: &i32| true).collect::<Vec<_>>(), splits);
 
     let xs: &[i32] = &[];
     let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
-    assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
+    assert_eq!(xs.rsplitn(2, |x: &i32| *x == 5).collect::<Vec<&[i32]>>(), splits);
+    assert!(xs.rsplitn(0, |x: &i32| *x % 2 == 0).next().is_none());
 }
 
 #[test]
@@ -1209,14 +1210,14 @@ fn test_ends_with() {
 #[test]
 fn test_mut_splitator() {
     let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
-    assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
-    for slice in xs.split_mut(|x| *x == 0) {
+    assert_eq!(xs.split_mut(|x: &i32| *x == 0).count(), 6);
+    for slice in xs.split_mut(|x: &i32| *x == 0) {
         slice.reverse();
     }
     assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]);
 
     let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7];
-    for slice in xs.split_mut(|x| *x == 0).take(5) {
+    for slice in xs.split_mut(|x: &i32| *x == 0).take(5) {
         slice.reverse();
     }
     assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]);
@@ -1225,7 +1226,7 @@ fn test_mut_splitator() {
 #[test]
 fn test_mut_splitator_rev() {
     let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
-    for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
+    for slice in xs.split_mut(|x: &i32| *x == 0).rev().take(4) {
         slice.reverse();
     }
     assert!(xs == [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]);
@@ -1646,3 +1647,56 @@ fn repeat_generic_slice() {
         vec![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]
     );
 }
+
+#[test]
+fn test_match_indices_simple() {
+    let haystack = &[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 2.0, 3.0, 2.0, 4.0, 8.0][..];
+    let needle = &[2.0, 3.0][..];
+
+    assert_eq!(haystack.match_indices(needle).collect::<Vec<_>>(), vec![
+        (1, needle),
+        (8, needle),
+    ]);
+}
+
+#[test]
+fn test_match_indices_nan_haystack() {
+    let haystack = &[1.0, 2.0, NAN, 1.0, 2.0, NAN, 1.0, NAN, NAN, NAN, 2.0, 1.0, 2.0][..];
+    let needle = &[1.0, 2.0][..];
+
+    assert_eq!(haystack.match_indices(needle).collect::<Vec<_>>(), vec![
+        (0, needle),
+        (3, needle),
+        (11, needle),
+    ]);
+}
+
+#[test]
+fn test_match_indices_nan_needle() {
+    let haystack = &[1.0, 2.0, NAN, 1.0, 2.0, NAN, 1.0, NAN, NAN, NAN, 2.0, 1.0, 2.0][..];
+    let needle = &[2.0, NAN][..];
+
+    assert_eq!(haystack.match_indices(needle).collect::<Vec<_>>(), vec![
+    ]);
+}
+
+#[test]
+fn test_match_indices_negative_zero() {
+    let haystack = &[-0.0, 0.0, 0.0, -0.0, 0.0][..];
+    let needle = &[0.0, -0.0][..];
+
+    assert_eq!(haystack.match_indices(needle).collect::<Vec<_>>(), vec![
+        (0, needle),
+        (2, needle),
+    ]);
+}
+
+#[test]
+fn test_replace() {
+    let haystack = &b" empowering everyone to build reliable and efficient software."[..];
+
+    assert_eq!(
+        haystack.replace(&b" e"[..], b" **E**"),
+        b" **E**mpowering **E**veryone to build reliable and **E**fficient software.".to_vec()
+    );
+}

src/liballoc/tests/str.rs

@@ -1606,145 +1606,6 @@ fn test_repeat() {
     assert_eq!("α".repeat(3), "ααα");
 }
 
-mod pattern {
-    use std::str::pattern::{Pattern, Searcher, ReverseSearcher};
-    use std::str::pattern::SearchStep::{self, Match, Reject, Done};
-
-    macro_rules! make_test {
-        ($name:ident, $p:expr, $h:expr, [$($e:expr,)*]) => {
-            #[allow(unused_imports)]
-            mod $name {
-                use std::str::pattern::SearchStep::{Match, Reject};
-                use super::{cmp_search_to_vec};
-                #[test]
-                fn fwd() {
-                    cmp_search_to_vec(false, $p, $h, vec![$($e),*]);
-                }
-                #[test]
-                fn bwd() {
-                    cmp_search_to_vec(true, $p, $h, vec![$($e),*]);
-                }
-            }
-        }
-    }
-
-    fn cmp_search_to_vec<'a, P: Pattern<'a>>(rev: bool, pat: P, haystack: &'a str,
-                                             right: Vec<SearchStep>)
-    where P::Searcher: ReverseSearcher<'a>
-    {
-        let mut searcher = pat.into_searcher(haystack);
-        let mut v = vec![];
-        loop {
-            match if !rev {searcher.next()} else {searcher.next_back()} {
-                Match(a, b) => v.push(Match(a, b)),
-                Reject(a, b) => v.push(Reject(a, b)),
-                Done => break,
-            }
-        }
-        if rev {
-            v.reverse();
-        }
-
-        let mut first_index = 0;
-        let mut err = None;
-
-        for (i, e) in right.iter().enumerate() {
-            match *e {
-                Match(a, b) | Reject(a, b)
-                if a <= b && a == first_index => {
-                    first_index = b;
-                }
-                _ => {
-                    err = Some(i);
-                    break;
-                }
-            }
-        }
-
-        if let Some(err) = err {
-            panic!("Input skipped range at {}", err);
-        }
-
-        if first_index != haystack.len() {
-            panic!("Did not cover whole input");
-        }
-
-        assert_eq!(v, right);
-    }
-
-    make_test!(str_searcher_ascii_haystack, "bb", "abbcbbd", [
-        Reject(0, 1),
-        Match (1, 3),
-        Reject(3, 4),
-        Match (4, 6),
-        Reject(6, 7),
-    ]);
-    make_test!(str_searcher_ascii_haystack_seq, "bb", "abbcbbbbd", [
-        Reject(0, 1),
-        Match (1, 3),
-        Reject(3, 4),
-        Match (4, 6),
-        Match (6, 8),
-        Reject(8, 9),
-    ]);
-    make_test!(str_searcher_empty_needle_ascii_haystack, "", "abbcbbd", [
-        Match (0, 0),
-        Reject(0, 1),
-        Match (1, 1),
-        Reject(1, 2),
-        Match (2, 2),
-        Reject(2, 3),
-        Match (3, 3),
-        Reject(3, 4),
-        Match (4, 4),
-        Reject(4, 5),
-        Match (5, 5),
-        Reject(5, 6),
-        Match (6, 6),
-        Reject(6, 7),
-        Match (7, 7),
-    ]);
-    make_test!(str_searcher_multibyte_haystack, " ", "├──", [
-        Reject(0, 3),
-        Reject(3, 6),
-        Reject(6, 9),
-    ]);
-    make_test!(str_searcher_empty_needle_multibyte_haystack, "", "├──", [
-        Match (0, 0),
-        Reject(0, 3),
-        Match (3, 3),
-        Reject(3, 6),
-        Match (6, 6),
-        Reject(6, 9),
-        Match (9, 9),
-    ]);
-    make_test!(str_searcher_empty_needle_empty_haystack, "", "", [
-        Match(0, 0),
-    ]);
-    make_test!(str_searcher_nonempty_needle_empty_haystack, "├", "", [
-    ]);
-    make_test!(char_searcher_ascii_haystack, 'b', "abbcbbd", [
-        Reject(0, 1),
-        Match (1, 2),
-        Match (2, 3),
-        Reject(3, 4),
-        Match (4, 5),
-        Match (5, 6),
-        Reject(6, 7),
-    ]);
-    make_test!(char_searcher_multibyte_haystack, ' ', "├──", [
-        Reject(0, 3),
-        Reject(3, 6),
-        Reject(6, 9),
-    ]);
-    make_test!(char_searcher_short_haystack, '\u{1F4A9}', "* \t", [
-        Reject(0, 1),
-        Reject(1, 2),
-        Reject(2, 3),
-    ]);
-
-}
-
 macro_rules! generate_iterator_test {
     {
         $name:ident {
@@ -1837,13 +1698,51 @@ generate_iterator_test! {
 
 #[test]
 fn different_str_pattern_forwarding_lifetimes() {
-    use std::str::pattern::Pattern;
+    // FIXME: The generic form (see PR 31989) causes a strange "trait bound not satisfied" error.
+    // revisit this after RFC 2089 is implemented.
 
-    fn foo<'a, P>(p: P) where for<'b> &'b P: Pattern<'a> {
+    fn foo(p: &str) {
         for _ in 0..3 {
             "asdf".find(&p);
         }
     }
 
-    foo::<&str>("x");
+    foo("x");
+}
+
+#[test]
+fn test_mut_str() {
+    use std::ops::Range;
+
+    let mut s = String::from("a1b2c3d4e");
+    {
+        let res: &mut str = s.trim_matches_mut(|c: char| c.is_ascii_alphabetic());
+        assert_eq!(res, "1b2c3d4");
+    }
+    {
+        let res: Vec<&mut str> = s.split_mut(|c: char| c.is_ascii_digit()).collect();
+        assert_eq!(res, vec!["a", "b", "c", "d", "e"]);
+    }
+    {
+        let res: Vec<(Range<usize>, &mut str)> =
+            s.match_ranges_mut(|c: char| c.is_ascii_digit()).collect();
+        let res = res.into_iter().map(|(r, ss)| (r, &*ss)).collect::<Vec<_>>();
+        assert_eq!(res, vec![
+            (1..2, "1"),
+            (3..4, "2"),
+            (5..6, "3"),
+            (7..8, "4"),
+        ]);
+    }
+    {
+        let res: Vec<(Range<usize>, &mut str)> =
+            s.rmatch_ranges_mut(|c: char| c.is_ascii_digit()).collect();
+        let res = res.into_iter().map(|(r, ss)| (r, &*ss)).collect::<Vec<_>>();
+        assert_eq!(res, vec![
+            (7..8, "4"),
+            (5..6, "3"),
+            (3..4, "2"),
+            (1..2, "1"),
+        ]);
+    }
 }

src/liballoc/vec.rs

@@ -67,6 +67,7 @@ use core::ops::{self, Index, IndexMut, RangeBounds};
 use core::ops::Bound::{Excluded, Included, Unbounded};
 use core::ptr::{self, NonNull};
 use core::slice::{self, SliceIndex};
+use core::needle::Needle;
 
 use crate::borrow::{ToOwned, Cow};
 use crate::collections::CollectionAllocErr;
@@ -2724,3 +2725,35 @@ impl<T, F> Drop for DrainFilter<'_, T, F>
         }
     }
 }
+
+#[unstable(feature = "needle", issue = "56345")]
+impl<'p, 'h, T: PartialEq + 'p + 'h> Needle<&'h [T]> for &'p Vec<T> {
+    type Searcher = <&'p [T] as Needle<&'h [T]>>::Searcher;
+    type Consumer = <&'p [T] as Needle<&'h [T]>>::Consumer;
+
+    #[inline]
+    fn into_searcher(self) -> Self::Searcher {
+        <&'p [T] as Needle<&'h [T]>>::into_searcher(&**self)
+    }
+
+    #[inline]
+    fn into_consumer(self) -> Self::Consumer {
+        <&'p [T] as Needle<&'h [T]>>::into_consumer(&**self)
+    }
+}
+
+#[unstable(feature = "needle", issue = "56345")]
+impl<'p, 'h, T: PartialEq + 'p + 'h> Needle<&'h mut [T]> for &'p Vec<T> {
+    type Searcher = <&'p [T] as Needle<&'h mut [T]>>::Searcher;
+    type Consumer = <&'p [T] as Needle<&'h mut [T]>>::Consumer;
+
+    #[inline]
+    fn into_searcher(self) -> Self::Searcher {
+        <&'p [T] as Needle<&'h mut [T]>>::into_searcher(&**self)
+    }
+
+    #[inline]
+    fn into_consumer(self) -> Self::Consumer {
+        <&'p [T] as Needle<&'h mut [T]>>::into_consumer(&**self)
+    }
+}

src/libcore/lib.rs

@@ -208,6 +208,7 @@ pub mod fmt;
 pub mod time;
 
 pub mod unicode;
+pub mod needle;
 
 /* Async */
 pub mod future;

src/libcore/needle/ext.rs

@@ -0,0 +1,39 @@
+#![unstable(feature = "needle", issue = "56345")]
+
+//! The Needle API, support generalized searching on strings, arrays and more.
+//!
+//! This module provides traits to facilitate searching [`Needle`] in a [`Haystack`].
+//!
+//! [`Needle`]: trait.Needle.html
+//! [`Haystack`]: trait.Haystack.html
+//!
+//! Haystacks
+//! =========
+//!
+//! A *haystack* refers to any linear structure which can be split or sliced
+//! into smaller, non-overlapping parts. Examples are strings and vectors.
+//!
+//! ```rust
+//! let haystack: &str = "hello";       // a string slice (`&str`) is a haystack.
+//! let (a, b) = haystack.split_at(4);  // it can be split into two strings.
+//! let c = &a[1..3];                   // it can be sliced.
+//! ```
+//!
+//! The minimal haystack which cannot be further sliced is called a *codeword*.
+//! For instance, the codeword of a string would be a UTF-8 sequence. A haystack
+//! can therefore be viewed as a consecutive list of codewords.
+//!
+//! The boundary between codewords can be addressed using an *index*. The
+//! numbers 1, 3 and 4 in the snippet above are sample indices of a string. An
+//! index is usually a `usize`.
+//!
+//! An arbitrary number may point outside of a haystack, or in the interior of a
+//! codeword. These indices are invalid. A *valid index* of a certain haystack
+//! would only point to the boundaries.
+
+mod haystack;
+mod needle;
+pub mod ext;
+
+pub use self::haystack::*;
+pub use self::needle::*;

src/libcore/needle/haystack.rs

@@ -0,0 +1,365 @@
+use needle::*;
+use ops::Range;
+use slice::needles::{SliceSearcher, NaiveSearcher, TwoWaySearcher};
+use slice::memchr::{memchr, memrchr};
+use fmt;
+
+//------------------------------------------------------------------------------
+// Character function searcher
+//------------------------------------------------------------------------------
+
+#[derive(Copy, Clone, Debug)]
+pub struct MultiCharEq<'p>(&'p [char]);
+
+impl<'p> FnOnce<(char,)> for MultiCharEq<'p> {
+    type Output = bool;
+    #[inline]
+    extern "rust-call" fn call_once(self, args: (char,)) -> bool {
+        self.call(args)
+    }
+}
+
+impl<'p> FnMut<(char,)> for MultiCharEq<'p> {
+    #[inline]
+    extern "rust-call" fn call_mut(&mut self, args: (char,)) -> bool {
+        self.call(args)
+    }
+}
+
+impl<'p> Fn<(char,)> for MultiCharEq<'p> {
+    #[inline]
+    extern "rust-call" fn call(&self, (c,): (char,)) -> bool {
+        self.0.iter().any(|ch| *ch == c)
+    }
+}
+
+#[derive(Clone)]
+pub struct MultiCharSearcher<F> {
+    predicate: F,
+}
+
+// we need to impl Debug for everything due to stability guarantee.
+impl<F> fmt::Debug for MultiCharSearcher<F> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("MultiCharSearcher").finish()
+    }
+}
+
+unsafe impl<F: FnMut(char) -> bool> Searcher<str> for MultiCharSearcher<F> {
+    #[inline]
+    fn search(&mut self, span: Span<&str>) -> Option<Range<usize>> {
+        let (hay, range) = span.into_parts();
+        let st = range.start;
+        let h = &hay[range];
+        let mut chars = h.chars();
+        let c = chars.find(|c| (self.predicate)(*c))?;
+        let end = chars.as_str().as_ptr();
+        let end = unsafe { end.offset_from(h.as_ptr()) as usize } + st;
+        Some((end - c.len_utf8())..end)
+    }
+}
+
+unsafe impl<F: FnMut(char) -> bool> Consumer<str> for MultiCharSearcher<F> {
+    #[inline]
+    fn consume(&mut self, hay: Span<&str>) -> Option<usize> {
+        let (hay, range) = hay.into_parts();
+        let start = range.start;
+        if start == range.end {
+            return None;
+        }
+        let c = unsafe { hay.get_unchecked(start..) }.chars().next().unwrap();
+        if (self.predicate)(c) {
+            Some(start + c.len_utf8())
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn trim_start(&mut self, hay: &str) -> usize {
+        let mut chars = hay.chars();
+        let unconsume_amount = chars
+            .find_map(|c| if !(self.predicate)(c) { Some(c.len_utf8()) } else { None })
+            .unwrap_or(0);
+        let consumed = unsafe { chars.as_str().as_ptr().offset_from(hay.as_ptr()) as usize };
+        consumed.wrapping_sub(unconsume_amount)
+    }
+}
+
+unsafe impl<F: FnMut(char) -> bool> ReverseSearcher<str> for MultiCharSearcher<F> {
+    #[inline]
+    fn rsearch(&mut self, span: Span<&str>) -> Option<Range<usize>> {
+        let (hay, range) = span.into_parts();
+        let st = range.start;
+        let h = &hay[range];
+        let mut chars = h.chars();
+        let c = chars.rfind(|c| (self.predicate)(*c))?;
+        let start = chars.as_str().len() + st;
+        Some(start..(start + c.len_utf8()))
+    }
+}
+
+unsafe impl<F: FnMut(char) -> bool> ReverseConsumer<str> for MultiCharSearcher<F> {
+    #[inline]
+    fn rconsume(&mut self, hay: Span<&str>) -> Option<usize> {
+        let (hay, range) = hay.into_parts();
+        let end = range.end;
+        if range.start == end {
+            return None;
+        }
+        let c = unsafe { hay.get_unchecked(..end) }.chars().next_back().unwrap();
+        if (self.predicate)(c) {
+            Some(end - c.len_utf8())
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    fn trim_end(&mut self, hay: &str) -> usize {
+        // `find.map_or` is faster in trim_end in the microbenchmark, while
+        // `find.unwrap_or` is faster in trim_start. Don't ask me why.
+        let mut chars = hay.chars();
+        let unconsume_amount = chars
+            .by_ref()
+            .rev() // btw, `rev().find()` is faster than `rfind()`
+            .find(|c| !(self.predicate)(*c))
+            .map_or(0, |c| c.len_utf8());
+        chars.as_str().len() + unconsume_amount
+    }
+}
+
+unsafe impl<F: FnMut(char) -> bool> DoubleEndedSearcher<str> for MultiCharSearcher<F> {}
+unsafe impl<F: FnMut(char) -> bool> DoubleEndedConsumer<str> for MultiCharSearcher<F> {}
+
+macro_rules! impl_needle_with_multi_char_searcher {
+    ($ty:ty) => {
+        impl<'h, F: FnMut(char) -> bool> Needle<$ty> for F {
+            type Searcher = MultiCharSearcher<F>;
+            type Consumer = MultiCharSearcher<F>;
+
+            #[inline]
+            fn into_searcher(self) -> Self::Searcher {
+                MultiCharSearcher { predicate: self }
+            }
+
+            #[inline]
+            fn into_consumer(self) -> Self::Consumer {
+                MultiCharSearcher { predicate: self }
+            }
+        }
+
+        impl<'h, 'p> Needle<$ty> for &'p [char] {
+            type Searcher = MultiCharSearcher<MultiCharEq<'p>>;
+            type Consumer = MultiCharSearcher<MultiCharEq<'p>>;
+
+            #[inline]
+            fn into_searcher(self) -> Self::Searcher {
+                MultiCharSearcher { predicate: MultiCharEq(self) }
+            }
+
+            #[inline]
+            fn into_consumer(self) -> Self::Consumer {
+                MultiCharSearcher { predicate: MultiCharEq(self) }
+            }
+        }
+    }
+}
+
+impl_needle_with_multi_char_searcher!(&'h str);
+impl_needle_with_multi_char_searcher!(&'h mut str);
+
+//------------------------------------------------------------------------------
+// Character searcher
+//------------------------------------------------------------------------------
+
+#[derive(Debug, Clone)]
+pub struct CharSearcher {
+    // safety invariant: `utf8_size` must be less than 5
+    utf8_size: usize,
+
+    /// A utf8 encoded copy of the `needle`
+    utf8_encoded: [u8; 4],
+
+    /// The character currently being searched.
+    c: char,
+}
+
+impl CharSearcher {
+    #[inline]
+    fn as_bytes(&self) -> &[u8] {
+        &self.utf8_encoded[..self.utf8_size]
+    }
+
+    #[inline]
+    fn last_byte(&self) -> u8 {
+        self.utf8_encoded[self.utf8_size - 1]
+    }
+
+    #[inline]
+    fn new(c: char) -> Self {
+        let mut utf8_encoded = [0u8; 4];
+        let utf8_size = c.encode_utf8(&mut utf8_encoded).len();
+        CharSearcher {
+            utf8_size,
+            utf8_encoded,
+            c,
+        }
+    }
+}
+
+unsafe impl Searcher<str> for CharSearcher {
+    #[inline]
+    fn search(&mut self, span: Span<&str>) -> Option<Range<usize>> {
+        let (hay, range) = span.into_parts();
+        let mut finger = range.start;
+        let bytes = hay.as_bytes();
+        loop {
+            let index = memchr(self.last_byte(), &bytes[finger..range.end])?;
+            finger += index + 1;
+            if finger >= self.utf8_size {
+                let found = &bytes[(finger - self.utf8_size)..finger];
+                if found == self.as_bytes() {
+                    return Some((finger - self.utf8_size)..finger);
+                }
+            }
+        }
+    }
+}
+
+unsafe impl Consumer<str> for CharSearcher {
+    #[inline]
+    fn consume(&mut self, span: Span<&str>) -> Option<usize> {
+        let mut consumer = Needle::<&[u8]>::into_consumer(self.as_bytes());
+        consumer.consume(span.as_bytes())
+    }
+
+    #[inline]
+    fn trim_start(&mut self, hay: &str) -> usize {
+        let mut consumer = Needle::<&str>::into_consumer(|c: char| c == self.c);
+        consumer.trim_start(hay)
+    }
+}
+
+unsafe impl ReverseSearcher<str> for CharSearcher {
+    #[inline]
+    fn rsearch(&mut self, span: Span<&str>) -> Option<Range<usize>> {
+        let (hay, range) = span.into_parts();
+        let start = range.start;
+        let mut bytes = hay[range].as_bytes();
+        loop {
+            let index = memrchr(self.last_byte(), bytes)? + 1;
+            if index >= self.utf8_size {
+                let found = &bytes[(index - self.utf8_size)..index];
+                if found == self.as_bytes() {
+                    let index = index + start;
+                    return Some((index - self.utf8_size)..index);
+                }
+            }
+            bytes = &bytes[..(index - 1)];
+        }
+    }
+}
+
+unsafe impl ReverseConsumer<str> for CharSearcher {
+    #[inline]
+    fn rconsume(&mut self, span: Span<&str>) -> Option<usize> {
+        if self.utf8_size == 1 {
+            let mut consumer = Needle::<&[u8]>::into_consumer(|b: &u8| *b == self.c as u8);
+            consumer.rconsume(span.as_bytes())
+        } else {
+            let mut consumer = Needle::<&str>::into_consumer(|c: char| c == self.c);
+            consumer.rconsume(span)
+        }
+    }
+
+    #[inline]
+    fn trim_end(&mut self, haystack: &str) -> usize {
+        let mut consumer = Needle::<&str>::into_consumer(|c: char| c == self.c);
+        consumer.trim_end(haystack)
+    }
+}
+
+unsafe impl DoubleEndedSearcher<str> for CharSearcher {}
+unsafe impl DoubleEndedConsumer<str> for CharSearcher {}
+
+impl<H: Haystack<Target = str>> Needle<H> for char {
+    type Searcher = CharSearcher;
+    type Consumer = CharSearcher;
+
+    #[inline]
+    fn into_searcher(self) -> Self::Searcher {
+        CharSearcher::new(self)
+    }
+
+    #[inline]
+    fn into_consumer(self) -> Self::Consumer {
+        CharSearcher::new(self)
+    }
+}
+
+//------------------------------------------------------------------------------
+// String searcher
+//------------------------------------------------------------------------------
+
+unsafe impl<'p> Searcher<str> for TwoWaySearcher<'p, u8> {
+    #[inline]
+    fn search(&mut self, span: Span<&str>) -> Option<Range<usize>> {
+        let (hay, range) = span.into_parts();
+        self.next(hay.as_bytes(), range)
+    }
+}
+
+unsafe impl<'p> ReverseSearcher<str> for TwoWaySearcher<'p, u8> {
+    #[inline]
+    fn rsearch(&mut self, span: Span<&str>) -> Option<Range<usize>> {
+        let (hay, range) = span.into_parts();
+        self.next_back(hay.as_bytes(), range)
+    }
+}
+
+unsafe impl<'p> Consumer<str> for NaiveSearcher<'p, u8> {
+    #[inline]
+    fn consume(&mut self, span: Span<&str>) -> Option<usize> {
+        self.consume(span.as_bytes())
+    }
+
+    #[inline]
+    fn trim_start(&mut self, hay: &str) -> usize {
+        self.trim_start(hay.as_bytes())
+    }
+}
+
+unsafe impl<'p> ReverseConsumer<str> for NaiveSearcher<'p, u8> {
+    #[inline]
+    fn rconsume(&mut self, span: Span<&str>) -> Option<usize> {
+        self.rconsume(span.as_bytes())
+    }
+
+    #[inline]
+    fn trim_end(&mut self, hay: &str) -> usize {
+        self.trim_end(hay.as_bytes())
+    }
+}
+
+macro_rules! impl_needle_for_str_searcher {
+    (<[$($gen:tt)*]> for $pat:ty) => {
+        impl<$($gen)*, H: Haystack<Target = str>> Needle<H> for $pat {
+            type Searcher = SliceSearcher<'p, u8>;
+            type Consumer = NaiveSearcher<'p, u8>;
+
+            #[inline]
+            fn into_searcher(self) -> Self::Searcher {
+                SliceSearcher::new(self.as_bytes())
+            }
+
+            #[inline]
+            fn into_consumer(self) -> Self::Consumer {
+                NaiveSearcher::new(self.as_bytes())
+            }
+        }
+    }
+}
+
+impl_needle_for_str_searcher!(<['p]> for &'p str);
+impl_needle_for_str_searcher!(<['q, 'p]> for &'q &'p str);

src/libcore/needle/mod.rs

@@ -13,7 +13,7 @@
 #![feature(iter_copied)]
 #![feature(iter_nth_back)]
 #![feature(iter_once_with)]
-#![feature(pattern)]
+#![feature(needle)]
 #![feature(range_is_empty)]
 #![feature(raw)]
 #![feature(slice_patterns)]

src/libcore/needle/needle.rs

@@ -274,6 +274,7 @@
 #![feature(link_args)]
 #![feature(linkage)]
 #![feature(maybe_uninit)]
+#![feature(needle)]
 #![feature(needs_panic_runtime)]
 #![feature(never_type)]
 #![feature(nll)]
@@ -285,6 +286,7 @@
 #![feature(panic_unwind)]
 #![feature(prelude_import)]
 #![feature(ptr_internals)]
+#![feature(ptr_offset_from)]
 #![feature(raw)]
 #![feature(renamed_spin_loop)]
 #![feature(rustc_attrs)]
@@ -293,6 +295,7 @@
 #![feature(shrink_to)]
 #![feature(slice_concat_ext)]
 #![feature(slice_internals)]
+#![feature(slice_needle_methods)]
 #![feature(slice_patterns)]
 #![feature(staged_api)]
 #![feature(std_internals)]
@@ -436,6 +439,8 @@ pub use core::char;
 pub use core::u128;
 #[stable(feature = "core_hint", since = "1.27.0")]
 pub use core::hint;
+#[unstable(feature = "needle", issue = "56345")]
+pub use core::needle;
 
 pub mod f32;
 pub mod f64;

src/libcore/slice/mod.rs

@@ -315,7 +315,7 @@ unsafe fn u8_slice_as_os_str(s: &[u8]) -> &OsStr {
 
 // Detect scheme on Redox
 fn has_redox_scheme(s: &[u8]) -> bool {
-    cfg!(target_os = "redox") && s.split(|b| *b == b'/').next().unwrap_or(b"").contains(&b':')
+    cfg!(target_os = "redox") && s.split_match(b"/").next().unwrap_or(b"").contains(&b':')
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -344,7 +344,7 @@ fn split_file_at_dot(file: &OsStr) -> (Option<&OsStr>, Option<&OsStr>) {
         // contents of the encoding and (2) new &OsStr values are produced
         // only from ASCII-bounded slices of existing &OsStr values.
 
-        let mut iter = os_str_as_u8_slice(file).rsplitn(2, |b| *b == b'.');
+        let mut iter = os_str_as_u8_slice(file).rsplitn_match(2, b".");
         let after = iter.next();
         let before = iter.next();
         if before == Some(b"") {

src/libcore/slice/needles.rs

@@ -64,7 +64,7 @@ unsafe fn parse_lp_cmd_line<F: Fn() -> OsString>(lp_cmd_line: *const u16, exe_na
         // no matter what.
         QUOTE => {
             let args = {
-                let mut cut = cmd_line[1..].splitn(2, |&c| c == QUOTE);
+                let mut cut = cmd_line[1..].splitn(2, |&c: &u16| c == QUOTE);
                 if let Some(exe) = cut.next() {
                     ret_val.push(OsString::from_wide(exe));
                 }
@@ -89,7 +89,7 @@ unsafe fn parse_lp_cmd_line<F: Fn() -> OsString>(lp_cmd_line: *const u16, exe_na
         // no matter what.
         _ => {
             let args = {
-                let mut cut = cmd_line.splitn(2, |&c| c > 0 && c <= SPACE);
+                let mut cut = cmd_line.splitn(2, |&c: &u16| c > 0 && c <= SPACE);
                 if let Some(exe) = cut.next() {
                     ret_val.push(OsString::from_wide(exe));
                 }

src/libcore/str/mod.rs

@@ -3,11 +3,14 @@
 
 use crate::borrow::Cow;
 use crate::fmt;
-use crate::sys_common::wtf8::{Wtf8, Wtf8Buf};
+use crate::sys_common::wtf8::{self, Wtf8, Wtf8Buf};
 use crate::mem;
 use crate::rc::Rc;
 use crate::sync::Arc;
+use crate::ops::{Index, Range, RangeFrom, RangeTo};
 use crate::sys_common::{AsInner, IntoInner, FromInner};
+use core::slice::needles::{SliceSearcher, NaiveSearcher};
+use crate::needle::Hay;
 
 #[derive(Clone, Hash)]
 pub struct Buf {
@@ -44,6 +47,7 @@ impl fmt::Display for Buf {
     }
 }
 
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Slice {
     pub inner: Wtf8
 }
@@ -60,6 +64,30 @@ impl fmt::Display for Slice {
     }
 }
 
+impl Index<Range<usize>> for Slice {
+    type Output = Slice;
+
+    fn index(&self, range: Range<usize>) -> &Slice {
+        unsafe { mem::transmute(&self.inner[range]) }
+    }
+}
+
+impl Index<RangeFrom<usize>> for Slice {
+    type Output = Slice;
+
+    fn index(&self, range: RangeFrom<usize>) -> &Slice {
+        unsafe { mem::transmute(&self.inner[range]) }
+    }
+}
+
+impl Index<RangeTo<usize>> for Slice {
+    type Output = Slice;
+
+    fn index(&self, range: RangeTo<usize>) -> &Slice {
+        unsafe { mem::transmute(&self.inner[range]) }
+    }
+}
+
 impl Buf {
     pub fn with_capacity(capacity: usize) -> Buf {
         Buf {
@@ -169,4 +197,26 @@ impl Slice {
         let rc = self.inner.into_rc();
         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Slice) }
     }
+
+    pub unsafe fn next_index(&self, index: usize) -> usize {
+        self.inner.next_index(index)
+    }
+
+    pub unsafe fn prev_index(&self, index: usize) -> usize {
+        self.inner.prev_index(index)
+    }
+
+    pub fn into_searcher(&self) -> InnerSearcher<SliceSearcher<'_, u8>> {
+        wtf8::new_wtf8_searcher(&self.inner)
+    }
+
+    pub fn into_consumer(&self) -> InnerSearcher<NaiveSearcher<'_, u8>> {
+        wtf8::new_wtf8_consumer(&self.inner)
+    }
+
+    pub fn as_bytes_for_searcher(&self) -> &[u8] {
+        self.inner.as_inner()
+    }
 }
+
+pub use crate::sys_common::wtf8::Wtf8Searcher as InnerSearcher;

src/libcore/str/needles.rs

@@ -6,18 +6,22 @@ use crate::ffi::{OsStr, OsString};
 use crate::fmt;
 use crate::str;
 use crate::mem;
+use crate::ops::{Index, Range, RangeFrom, RangeTo};
 use crate::rc::Rc;
 use crate::sync::Arc;
 use crate::sys_common::{FromInner, IntoInner, AsInner};
 use crate::sys_common::bytestring::debug_fmt_bytestring;
 
 use core::str::lossy::Utf8Lossy;
+use core::slice::needles::{SliceSearcher, NaiveSearcher};
+use crate::needle::Hay;
 
 #[derive(Clone, Hash)]
 pub(crate) struct Buf {
     pub inner: Vec<u8>
 }
 
+#[derive(PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub(crate) struct Slice {
     pub inner: [u8]
 }
@@ -34,6 +38,30 @@ impl fmt::Display for Slice {
     }
 }
 
+impl Index<Range<usize>> for Slice {
+    type Output = Slice;
+
+    fn index(&self, range: Range<usize>) -> &Slice {
+        Slice::from_u8_slice(&self.inner[range])
+    }
+}
+
+impl Index<RangeFrom<usize>> for Slice {
+    type Output = Slice;
+
+    fn index(&self, range: RangeFrom<usize>) -> &Slice {
+        Slice::from_u8_slice(&self.inner[range])
+    }
+}
+
+impl Index<RangeTo<usize>> for Slice {
+    type Output = Slice;
+
+    fn index(&self, range: RangeTo<usize>) -> &Slice {
+        Slice::from_u8_slice(&self.inner[range])
+    }
+}
+
 impl fmt::Debug for Buf {
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(self.as_slice(), formatter)
@@ -178,8 +206,31 @@ impl Slice {
         let rc: Rc<[u8]> = Rc::from(&self.inner);
         unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Slice) }
     }
+
+    pub unsafe fn next_index(&self, index: usize) -> usize {
+        self.inner.next_index(index)
+    }
+
+    pub unsafe fn prev_index(&self, index: usize) -> usize {
+        self.inner.prev_index(index)
+    }
+
+    pub fn into_searcher(&self) -> SliceSearcher<'_, u8> {
+        SliceSearcher::new(&self.inner)
+    }
+
+    pub fn into_consumer(&self) -> NaiveSearcher<'_, u8> {
+        NaiveSearcher::new(&self.inner)
+    }
+
+    pub fn as_bytes_for_searcher(&self) -> &[u8] {
+        &self.inner
+    }
 }
 
+#[unstable(feature = "needle", issue = "56345")]
+pub type InnerSearcher<S> = S;
+
 /// Platform-specific extensions to [`OsString`].
 ///
 /// [`OsString`]: ../../../../std/ffi/struct.OsString.html

src/libcore/str/pattern.rs

@@ -10,7 +10,7 @@ error[E0599]: no method named `bind` found for type `[&str; 1]` in the current s
   --> $DIR/issue-2149.rs:13:12
    |
 LL |     ["hi"].bind(|x| [x] );
-   |            ^^^^
+   |            ^^^^ help: did you mean: `find`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
    = note: the following trait defines an item `bind`, perhaps you need to implement it:

src/libcore/tests/lib.rs

@@ -1,5 +1,5 @@
 fn foo() -> bool {
-    b"".starts_with(stringify!(foo))
+    b"".eq_ignore_ascii_case(stringify!(foo))
     //~^ ERROR mismatched types
 }
 

src/libcore/tests/pattern.rs

@@ -1,8 +1,8 @@
 error[E0308]: mismatched types
-  --> $DIR/issue-48364.rs:2:21
+  --> $DIR/issue-48364.rs:2:30
    |
-LL |     b"".starts_with(stringify!(foo))
-   |                     ^^^^^^^^^^^^^^^ expected slice, found str
+LL |     b"".eq_ignore_ascii_case(stringify!(foo))
+   |                              ^^^^^^^^^^^^^^^ expected slice, found str
    |
    = note: expected type `&[u8]`
               found type `&'static str`