diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs
index afbe5cfaf8ef9..c1447fdc967f7 100644
--- a/library/alloc/src/str.rs
+++ b/library/alloc/src/str.rs
@@ -268,7 +268,7 @@ 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 {
+    pub fn replace<'a, P: Pattern<&'a str>>(&'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) {
@@ -308,7 +308,7 @@ 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<'a, P: Pattern<&'a str>>(&'a self, pat: P, to: &str, count: usize) -> String {
         // Hope to reduce the times of re-allocation
         let mut result = String::with_capacity(32);
         let mut last_end = 0;
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 2b843647dd510..9d41049d1a81e 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -1371,7 +1371,7 @@ impl String {
     #[unstable(feature = "string_remove_matches", reason = "new API", issue = "72826")]
     pub fn remove_matches<'a, P>(&'a mut self, pat: P)
     where
-        P: for<'x> Pattern<'x>,
+        P: for<'x> Pattern<&'x str>,
     {
         use core::str::pattern::Searcher;
 
@@ -2174,10 +2174,10 @@ impl<'a> Extend<Cow<'a, str>> for String {
     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;
+impl<'a, 'b> Pattern<&'a str> for &'b String {
+    type Searcher = <&'b str as Pattern<&'a str>>::Searcher;
 
-    fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher {
+    fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<&'a str>>::Searcher {
         self[..].into_searcher(haystack)
     }
 
diff --git a/library/alloc/tests/str.rs b/library/alloc/tests/str.rs
index 4d182be02c9e9..cc2110f5673a0 100644
--- a/library/alloc/tests/str.rs
+++ b/library/alloc/tests/str.rs
@@ -1879,7 +1879,7 @@ mod pattern {
 
     fn cmp_search_to_vec<'a>(
         rev: bool,
-        pat: impl Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        pat: impl Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
         haystack: &'a str,
         right: Vec<SearchStep>,
     ) {
@@ -2143,7 +2143,7 @@ fn different_str_pattern_forwarding_lifetimes() {
 
     fn foo<'a, P>(p: P)
     where
-        for<'b> &'b P: Pattern<'a>,
+        for<'b> &'b P: Pattern<&'a str>,
     {
         for _ in 0..3 {
             "asdf".find(&p);
diff --git a/library/core/src/str/iter.rs b/library/core/src/str/iter.rs
index 95c682f42d0c9..bdb1f1d297af6 100644
--- a/library/core/src/str/iter.rs
+++ b/library/core/src/str/iter.rs
@@ -361,7 +361,7 @@ macro_rules! derive_pattern_clone {
     (clone $t:ident with |$s:ident| $e:expr) => {
         impl<'a, P> Clone for $t<'a, P>
         where
-            P: Pattern<'a, Searcher: Clone>,
+            P: Pattern<&'a str, Searcher: Clone>,
         {
             fn clone(&self) -> Self {
                 let $s = self;
@@ -374,7 +374,7 @@ macro_rules! derive_pattern_clone {
 /// This macro generates two public iterator structs
 /// wrapping a private internal one that makes use of the `Pattern` API.
 ///
-/// For all patterns `P: Pattern<'a>` the following items will be
+/// For all patterns `P: Pattern<&'a str>` the following items will be
 /// generated (generics omitted):
 ///
 /// struct $forward_iterator($internal_iterator);
@@ -434,12 +434,14 @@ macro_rules! generate_pattern_iterators {
     } => {
         $(#[$forward_iterator_attribute])*
         $(#[$common_stability_attribute])*
-        pub struct $forward_iterator<'a, P: Pattern<'a>>(pub(super) $internal_iterator<'a, P>);
+        pub struct $forward_iterator<'a, P: Pattern<&'a str>>(
+            pub(super) $internal_iterator<'a, P>
+        );
 
         $(#[$common_stability_attribute])*
         impl<'a, P> fmt::Debug for $forward_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: fmt::Debug>,
+            P: Pattern<&'a str, Searcher: fmt::Debug>,
         {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 f.debug_tuple(stringify!($forward_iterator))
@@ -449,7 +451,7 @@ macro_rules! generate_pattern_iterators {
         }
 
         $(#[$common_stability_attribute])*
-        impl<'a, P: Pattern<'a>> Iterator for $forward_iterator<'a, P> {
+        impl<'a, P: Pattern<&'a str>> Iterator for $forward_iterator<'a, P> {
             type Item = $iterty;
 
             #[inline]
@@ -461,7 +463,7 @@ macro_rules! generate_pattern_iterators {
         $(#[$common_stability_attribute])*
         impl<'a, P> Clone for $forward_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: Clone>,
+            P: Pattern<&'a str, Searcher: Clone>,
         {
             fn clone(&self) -> Self {
                 $forward_iterator(self.0.clone())
@@ -470,12 +472,14 @@ macro_rules! generate_pattern_iterators {
 
         $(#[$reverse_iterator_attribute])*
         $(#[$common_stability_attribute])*
-        pub struct $reverse_iterator<'a, P: Pattern<'a>>(pub(super) $internal_iterator<'a, P>);
+        pub struct $reverse_iterator<'a, P: Pattern<&'a str>>(
+            pub(super) $internal_iterator<'a, P>
+        );
 
         $(#[$common_stability_attribute])*
         impl<'a, P> fmt::Debug for $reverse_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: fmt::Debug>,
+            P: Pattern<&'a str, Searcher: fmt::Debug>,
         {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 f.debug_tuple(stringify!($reverse_iterator))
@@ -487,7 +491,7 @@ macro_rules! generate_pattern_iterators {
         $(#[$common_stability_attribute])*
         impl<'a, P> Iterator for $reverse_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+            P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
         {
             type Item = $iterty;
 
@@ -500,7 +504,7 @@ macro_rules! generate_pattern_iterators {
         $(#[$common_stability_attribute])*
         impl<'a, P> Clone for $reverse_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: Clone>,
+            P: Pattern<&'a str, Searcher: Clone>,
         {
             fn clone(&self) -> Self {
                 $reverse_iterator(self.0.clone())
@@ -508,12 +512,12 @@ macro_rules! generate_pattern_iterators {
         }
 
         #[stable(feature = "fused", since = "1.26.0")]
-        impl<'a, P: Pattern<'a>> FusedIterator for $forward_iterator<'a, P> {}
+        impl<'a, P: Pattern<&'a str>> FusedIterator for $forward_iterator<'a, P> {}
 
         #[stable(feature = "fused", since = "1.26.0")]
         impl<'a, P> FusedIterator for $reverse_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+            P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
         {}
 
         generate_pattern_iterators!($($t)* with $(#[$common_stability_attribute])*,
@@ -528,7 +532,7 @@ macro_rules! generate_pattern_iterators {
         $(#[$common_stability_attribute])*
         impl<'a, P> DoubleEndedIterator for $forward_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: DoubleEndedSearcher<'a>>,
+            P: Pattern<&'a str, Searcher: DoubleEndedSearcher<&'a str>>,
         {
             #[inline]
             fn next_back(&mut self) -> Option<$iterty> {
@@ -539,7 +543,7 @@ macro_rules! generate_pattern_iterators {
         $(#[$common_stability_attribute])*
         impl<'a, P> DoubleEndedIterator for $reverse_iterator<'a, P>
         where
-            P: Pattern<'a, Searcher: DoubleEndedSearcher<'a>>,
+            P: Pattern<&'a str, Searcher: DoubleEndedSearcher<&'a str>>,
         {
             #[inline]
             fn next_back(&mut self) -> Option<$iterty> {
@@ -559,7 +563,7 @@ derive_pattern_clone! {
     with |s| SplitInternal { matcher: s.matcher.clone(), ..*s }
 }
 
-pub(super) struct SplitInternal<'a, P: Pattern<'a>> {
+pub(super) struct SplitInternal<'a, P: Pattern<&'a str>> {
     pub(super) start: usize,
     pub(super) end: usize,
     pub(super) matcher: P::Searcher,
@@ -569,7 +573,7 @@ pub(super) struct SplitInternal<'a, P: Pattern<'a>> {
 
 impl<'a, P> fmt::Debug for SplitInternal<'a, P>
 where
-    P: Pattern<'a, Searcher: fmt::Debug>,
+    P: Pattern<&'a str, Searcher: fmt::Debug>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SplitInternal")
@@ -582,7 +586,7 @@ where
     }
 }
 
-impl<'a, P: Pattern<'a>> SplitInternal<'a, P> {
+impl<'a, P: Pattern<&'a str>> SplitInternal<'a, P> {
     #[inline]
     fn get_end(&mut self) -> Option<&'a str> {
         if !self.finished {
@@ -639,7 +643,7 @@ impl<'a, P: Pattern<'a>> SplitInternal<'a, P> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str>
     where
-        P::Searcher: ReverseSearcher<'a>,
+        P::Searcher: ReverseSearcher<&'a str>,
     {
         if self.finished {
             return None;
@@ -676,7 +680,7 @@ impl<'a, P: Pattern<'a>> SplitInternal<'a, P> {
     #[inline]
     fn next_back_inclusive(&mut self) -> Option<&'a str>
     where
-        P::Searcher: ReverseSearcher<'a>,
+        P::Searcher: ReverseSearcher<&'a str>,
     {
         if self.finished {
             return None;
@@ -746,7 +750,7 @@ generate_pattern_iterators! {
     delegate double ended;
 }
 
-impl<'a, P: Pattern<'a>> Split<'a, P> {
+impl<'a, P: Pattern<&'a str>> Split<'a, P> {
     /// Returns remainder of the split string.
     ///
     /// If the iterator is empty, returns `None`.
@@ -769,7 +773,7 @@ impl<'a, P: Pattern<'a>> Split<'a, P> {
     }
 }
 
-impl<'a, P: Pattern<'a>> RSplit<'a, P> {
+impl<'a, P: Pattern<&'a str>> RSplit<'a, P> {
     /// Returns remainder of the split string.
     ///
     /// If the iterator is empty, returns `None`.
@@ -810,7 +814,7 @@ generate_pattern_iterators! {
     delegate double ended;
 }
 
-impl<'a, P: Pattern<'a>> SplitTerminator<'a, P> {
+impl<'a, P: Pattern<&'a str>> SplitTerminator<'a, P> {
     /// Returns remainder of the split string.
     ///
     /// If the iterator is empty, returns `None`.
@@ -833,7 +837,7 @@ impl<'a, P: Pattern<'a>> SplitTerminator<'a, P> {
     }
 }
 
-impl<'a, P: Pattern<'a>> RSplitTerminator<'a, P> {
+impl<'a, P: Pattern<&'a str>> RSplitTerminator<'a, P> {
     /// Returns remainder of the split string.
     ///
     /// If the iterator is empty, returns `None`.
@@ -861,7 +865,7 @@ derive_pattern_clone! {
     with |s| SplitNInternal { iter: s.iter.clone(), ..*s }
 }
 
-pub(super) struct SplitNInternal<'a, P: Pattern<'a>> {
+pub(super) struct SplitNInternal<'a, P: Pattern<&'a str>> {
     pub(super) iter: SplitInternal<'a, P>,
     /// The number of splits remaining
     pub(super) count: usize,
@@ -869,7 +873,7 @@ pub(super) struct SplitNInternal<'a, P: Pattern<'a>> {
 
 impl<'a, P> fmt::Debug for SplitNInternal<'a, P>
 where
-    P: Pattern<'a, Searcher: fmt::Debug>,
+    P: Pattern<&'a str, Searcher: fmt::Debug>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SplitNInternal")
@@ -879,7 +883,7 @@ where
     }
 }
 
-impl<'a, P: Pattern<'a>> SplitNInternal<'a, P> {
+impl<'a, P: Pattern<&'a str>> SplitNInternal<'a, P> {
     #[inline]
     fn next(&mut self) -> Option<&'a str> {
         match self.count {
@@ -898,7 +902,7 @@ impl<'a, P: Pattern<'a>> SplitNInternal<'a, P> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str>
     where
-        P::Searcher: ReverseSearcher<'a>,
+        P::Searcher: ReverseSearcher<&'a str>,
     {
         match self.count {
             0 => None,
@@ -937,7 +941,7 @@ generate_pattern_iterators! {
     delegate single ended;
 }
 
-impl<'a, P: Pattern<'a>> SplitN<'a, P> {
+impl<'a, P: Pattern<&'a str>> SplitN<'a, P> {
     /// Returns remainder of the split string.
     ///
     /// If the iterator is empty, returns `None`.
@@ -960,7 +964,7 @@ impl<'a, P: Pattern<'a>> SplitN<'a, P> {
     }
 }
 
-impl<'a, P: Pattern<'a>> RSplitN<'a, P> {
+impl<'a, P: Pattern<&'a str>> RSplitN<'a, P> {
     /// Returns remainder of the split string.
     ///
     /// If the iterator is empty, returns `None`.
@@ -988,18 +992,18 @@ derive_pattern_clone! {
     with |s| MatchIndicesInternal(s.0.clone())
 }
 
-pub(super) struct MatchIndicesInternal<'a, P: Pattern<'a>>(pub(super) P::Searcher);
+pub(super) struct MatchIndicesInternal<'a, P: Pattern<&'a str>>(pub(super) P::Searcher);
 
 impl<'a, P> fmt::Debug for MatchIndicesInternal<'a, P>
 where
-    P: Pattern<'a, Searcher: fmt::Debug>,
+    P: Pattern<&'a str, Searcher: fmt::Debug>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("MatchIndicesInternal").field(&self.0).finish()
     }
 }
 
-impl<'a, P: Pattern<'a>> MatchIndicesInternal<'a, P> {
+impl<'a, P: Pattern<&'a str>> MatchIndicesInternal<'a, P> {
     #[inline]
     fn next(&mut self) -> Option<(usize, &'a str)> {
         self.0
@@ -1011,7 +1015,7 @@ impl<'a, P: Pattern<'a>> MatchIndicesInternal<'a, P> {
     #[inline]
     fn next_back(&mut self) -> Option<(usize, &'a str)>
     where
-        P::Searcher: ReverseSearcher<'a>,
+        P::Searcher: ReverseSearcher<&'a str>,
     {
         self.0
             .next_match_back()
@@ -1043,18 +1047,18 @@ derive_pattern_clone! {
     with |s| MatchesInternal(s.0.clone())
 }
 
-pub(super) struct MatchesInternal<'a, P: Pattern<'a>>(pub(super) P::Searcher);
+pub(super) struct MatchesInternal<'a, P: Pattern<&'a str>>(pub(super) P::Searcher);
 
 impl<'a, P> fmt::Debug for MatchesInternal<'a, P>
 where
-    P: Pattern<'a, Searcher: fmt::Debug>,
+    P: Pattern<&'a str, Searcher: fmt::Debug>,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("MatchesInternal").field(&self.0).finish()
     }
 }
 
-impl<'a, P: Pattern<'a>> MatchesInternal<'a, P> {
+impl<'a, P: Pattern<&'a str>> MatchesInternal<'a, P> {
     #[inline]
     fn next(&mut self) -> Option<&'a str> {
         // SAFETY: `Searcher` guarantees that `start` and `end` lie on unicode boundaries.
@@ -1067,7 +1071,7 @@ impl<'a, P: Pattern<'a>> MatchesInternal<'a, P> {
     #[inline]
     fn next_back(&mut self) -> Option<&'a str>
     where
-        P::Searcher: ReverseSearcher<'a>,
+        P::Searcher: ReverseSearcher<&'a str>,
     {
         // SAFETY: `Searcher` guarantees that `start` and `end` lie on unicode boundaries.
         self.0.next_match_back().map(|(a, b)| unsafe {
@@ -1213,7 +1217,7 @@ pub struct SplitAsciiWhitespace<'a> {
 ///
 /// [`split_inclusive`]: str::split_inclusive
 #[stable(feature = "split_inclusive", since = "1.51.0")]
-pub struct SplitInclusive<'a, P: Pattern<'a>>(pub(super) SplitInternal<'a, P>);
+pub struct SplitInclusive<'a, P: Pattern<&'a str>>(pub(super) SplitInternal<'a, P>);
 
 #[stable(feature = "split_whitespace", since = "1.1.0")]
 impl<'a> Iterator for SplitWhitespace<'a> {
@@ -1335,7 +1339,7 @@ impl<'a> SplitAsciiWhitespace<'a> {
 }
 
 #[stable(feature = "split_inclusive", since = "1.51.0")]
-impl<'a, P: Pattern<'a>> Iterator for SplitInclusive<'a, P> {
+impl<'a, P: Pattern<&'a str>> Iterator for SplitInclusive<'a, P> {
     type Item = &'a str;
 
     #[inline]
@@ -1345,7 +1349,7 @@ impl<'a, P: Pattern<'a>> Iterator for SplitInclusive<'a, P> {
 }
 
 #[stable(feature = "split_inclusive", since = "1.51.0")]
-impl<'a, P: Pattern<'a, Searcher: fmt::Debug>> fmt::Debug for SplitInclusive<'a, P> {
+impl<'a, P: Pattern<&'a str, Searcher: fmt::Debug>> fmt::Debug for SplitInclusive<'a, P> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("SplitInclusive").field("0", &self.0).finish()
     }
@@ -1353,14 +1357,14 @@ impl<'a, P: Pattern<'a, Searcher: fmt::Debug>> fmt::Debug for SplitInclusive<'a,
 
 // FIXME(#26925) Remove in favor of `#[derive(Clone)]`
 #[stable(feature = "split_inclusive", since = "1.51.0")]
-impl<'a, P: Pattern<'a, Searcher: Clone>> Clone for SplitInclusive<'a, P> {
+impl<'a, P: Pattern<&'a str, Searcher: Clone>> Clone for SplitInclusive<'a, P> {
     fn clone(&self) -> Self {
         SplitInclusive(self.0.clone())
     }
 }
 
 #[stable(feature = "split_inclusive", since = "1.51.0")]
-impl<'a, P: Pattern<'a, Searcher: ReverseSearcher<'a>>> DoubleEndedIterator
+impl<'a, P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>> DoubleEndedIterator
     for SplitInclusive<'a, P>
 {
     #[inline]
@@ -1370,9 +1374,9 @@ impl<'a, P: Pattern<'a, Searcher: ReverseSearcher<'a>>> DoubleEndedIterator
 }
 
 #[stable(feature = "split_inclusive", since = "1.51.0")]
-impl<'a, P: Pattern<'a>> FusedIterator for SplitInclusive<'a, P> {}
+impl<'a, P: Pattern<&'a str>> FusedIterator for SplitInclusive<'a, P> {}
 
-impl<'a, P: Pattern<'a>> SplitInclusive<'a, P> {
+impl<'a, P: Pattern<&'a str>> SplitInclusive<'a, P> {
     /// Returns remainder of the split string.
     ///
     /// If the iterator is empty, returns `None`.
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index ab2f8520ecb33..d2ad655b42af8 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -1067,7 +1067,7 @@ impl str {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
+    pub fn contains<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> bool {
         pat.is_contained_in(self)
     }
 
@@ -1093,7 +1093,7 @@ impl str {
     /// assert!(!bananas.starts_with("nana"));
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
+    pub fn starts_with<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> bool {
         pat.is_prefix_of(self)
     }
 
@@ -1121,7 +1121,7 @@ impl str {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn ends_with<'a, P>(&'a self, pat: P) -> bool
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         pat.is_suffix_of(self)
     }
@@ -1170,7 +1170,7 @@ impl str {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize> {
+    pub fn find<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> Option<usize> {
         pat.into_searcher(self).next_match().map(|(i, _)| i)
     }
 
@@ -1218,7 +1218,7 @@ impl str {
     #[inline]
     pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         pat.into_searcher(self).next_match_back().map(|(i, _)| i)
     }
@@ -1338,7 +1338,7 @@ impl str {
     /// [`split_whitespace`]: str::split_whitespace
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> {
+    pub fn split<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> Split<'a, P> {
         Split(SplitInternal {
             start: 0,
             end: self.len(),
@@ -1378,7 +1378,7 @@ impl str {
     /// ```
     #[stable(feature = "split_inclusive", since = "1.51.0")]
     #[inline]
-    pub fn split_inclusive<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitInclusive<'a, P> {
+    pub fn split_inclusive<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> SplitInclusive<'a, P> {
         SplitInclusive(SplitInternal {
             start: 0,
             end: self.len(),
@@ -1435,7 +1435,7 @@ impl str {
     #[inline]
     pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P>
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         RSplit(self.split(pat).0)
     }
@@ -1484,7 +1484,7 @@ impl str {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> {
+    pub fn split_terminator<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> SplitTerminator<'a, P> {
         SplitTerminator(SplitInternal { allow_trailing_empty: false, ..self.split(pat).0 })
     }
 
@@ -1532,7 +1532,7 @@ impl str {
     #[inline]
     pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P>
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         RSplitTerminator(self.split_terminator(pat).0)
     }
@@ -1585,7 +1585,7 @@ impl str {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn splitn<'a, P: Pattern<'a>>(&'a self, n: usize, pat: P) -> SplitN<'a, P> {
+    pub fn splitn<'a, P: Pattern<&'a str>>(&'a self, n: usize, pat: P) -> SplitN<'a, P> {
         SplitN(SplitNInternal { iter: self.split(pat).0, count: n })
     }
 
@@ -1636,7 +1636,7 @@ impl str {
     #[inline]
     pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P>
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         RSplitN(self.splitn(n, pat).0)
     }
@@ -1654,7 +1654,7 @@ impl str {
     /// ```
     #[stable(feature = "str_split_once", since = "1.52.0")]
     #[inline]
-    pub fn split_once<'a, P: Pattern<'a>>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)> {
+    pub fn split_once<'a, P: Pattern<&'a str>>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)> {
         let (start, end) = delimiter.into_searcher(self).next_match()?;
         // SAFETY: `Searcher` is known to return valid indices.
         unsafe { Some((self.get_unchecked(..start), self.get_unchecked(end..))) }
@@ -1674,7 +1674,7 @@ impl str {
     #[inline]
     pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         let (start, end) = delimiter.into_searcher(self).next_match_back()?;
         // SAFETY: `Searcher` is known to return valid indices.
@@ -1714,7 +1714,7 @@ impl str {
     /// ```
     #[stable(feature = "str_matches", since = "1.2.0")]
     #[inline]
-    pub fn matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> Matches<'a, P> {
+    pub fn matches<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> Matches<'a, P> {
         Matches(MatchesInternal(pat.into_searcher(self)))
     }
 
@@ -1752,7 +1752,7 @@ impl str {
     #[inline]
     pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P>
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         RMatches(self.matches(pat).0)
     }
@@ -1796,7 +1796,7 @@ impl str {
     /// ```
     #[stable(feature = "str_match_indices", since = "1.5.0")]
     #[inline]
-    pub fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P> {
+    pub fn match_indices<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> MatchIndices<'a, P> {
         MatchIndices(MatchIndicesInternal(pat.into_searcher(self)))
     }
 
@@ -1840,7 +1840,7 @@ impl str {
     #[inline]
     pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P>
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         RMatchIndices(self.match_indices(pat).0)
     }
@@ -2057,7 +2057,7 @@ impl str {
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str
     where
-        P: Pattern<'a, Searcher: DoubleEndedSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: DoubleEndedSearcher<&'a str>>,
     {
         let mut i = 0;
         let mut j = 0;
@@ -2104,7 +2104,7 @@ impl str {
     #[must_use = "this returns the trimmed string as a new slice, \
                   without modifying the original"]
     #[stable(feature = "trim_direction", since = "1.30.0")]
-    pub fn trim_start_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str {
+    pub fn trim_start_matches<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> &'a str {
         let mut i = self.len();
         let mut matcher = pat.into_searcher(self);
         if let Some((a, _)) = matcher.next_reject() {
@@ -2137,7 +2137,7 @@ impl str {
     #[must_use = "this returns the remaining substring as a new slice, \
                   without modifying the original"]
     #[stable(feature = "str_strip", since = "1.45.0")]
-    pub fn strip_prefix<'a, P: Pattern<'a>>(&'a self, prefix: P) -> Option<&'a str> {
+    pub fn strip_prefix<'a, P: Pattern<&'a str>>(&'a self, prefix: P) -> Option<&'a str> {
         prefix.strip_prefix_of(self)
     }
 
@@ -2166,8 +2166,8 @@ impl str {
     #[stable(feature = "str_strip", since = "1.45.0")]
     pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a str>
     where
-        P: Pattern<'a>,
-        <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
+        P: Pattern<&'a str>,
+        <P as Pattern<&'a str>>::Searcher: ReverseSearcher<&'a str>,
     {
         suffix.strip_suffix_of(self)
     }
@@ -2210,7 +2210,7 @@ impl str {
     #[stable(feature = "trim_direction", since = "1.30.0")]
     pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         let mut j = 0;
         let mut matcher = pat.into_searcher(self);
@@ -2254,7 +2254,7 @@ impl str {
         note = "superseded by `trim_start_matches`",
         suggestion = "trim_start_matches"
     )]
-    pub fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str {
+    pub fn trim_left_matches<'a, P: Pattern<&'a str>>(&'a self, pat: P) -> &'a str {
         self.trim_start_matches(pat)
     }
 
@@ -2299,7 +2299,7 @@ impl str {
     )]
     pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str
     where
-        P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
+        P: Pattern<&'a str, Searcher: ReverseSearcher<&'a str>>,
     {
         self.trim_end_matches(pat)
     }
diff --git a/library/core/src/str/pattern.rs b/library/core/src/str/pattern.rs
index 19da6d2fbecbc..b891fd9a4d337 100644
--- a/library/core/src/str/pattern.rs
+++ b/library/core/src/str/pattern.rs
@@ -45,13 +45,13 @@ use crate::slice::memchr;
 
 // Pattern
 
-/// A string pattern.
+/// A pattern which can be matched against a [`Haystack`].
 ///
-/// A `Pattern<'a>` expresses that the implementing type
-/// can be used as a string pattern for searching in a [`&'a str`][str].
+/// A `Pattern<H>` expresses that the implementing type can be used as a pattern
+/// for searching in a `H`.
 ///
-/// For example, both `'a'` and `"aa"` are patterns that
-/// would match at index `1` in the string `"baaaab"`.
+/// For example, character `'a'` and string `"aa"` are patterns that would match
+/// at index `1` in the string `"baaaab"`.
 ///
 /// The trait itself acts as a builder for an associated
 /// [`Searcher`] type, which does the actual work of finding
@@ -96,46 +96,49 @@ use crate::slice::memchr;
 /// assert_eq!("abcdef_z".find(|ch| ch > 'd' && ch < 'y'), Some(4));
 /// assert_eq!("abcddd_z".find(|ch| ch > 'd' && ch < 'y'), None);
 /// ```
-pub trait Pattern<'a>: Sized {
+pub trait Pattern<H: Haystack>: Sized {
     /// Associated searcher for this pattern
-    type Searcher: Searcher<'a>;
+    type Searcher: Searcher<H>;
 
     /// Constructs the associated searcher from
     /// `self` and the `haystack` to search in.
-    fn into_searcher(self, haystack: &'a str) -> Self::Searcher;
+    fn into_searcher(self, haystack: H) -> Self::Searcher;
 
     /// Checks whether the pattern matches anywhere in the haystack
     #[inline]
-    fn is_contained_in(self, haystack: &'a str) -> bool {
+    fn is_contained_in(self, haystack: H) -> bool {
         self.into_searcher(haystack).next_match().is_some()
     }
 
     /// Checks whether the pattern matches at the front of the haystack
     #[inline]
-    fn is_prefix_of(self, haystack: &'a str) -> bool {
-        matches!(self.into_searcher(haystack).next(), SearchStep::Match(0, _))
+    fn is_prefix_of(self, haystack: H) -> bool {
+        matches!(
+            self.into_searcher(haystack).next(),
+            SearchStep::Match(start, _) if start == haystack.cursor_at_front()
+        )
     }
 
     /// Checks whether the pattern matches at the back of the haystack
     #[inline]
-    fn is_suffix_of(self, haystack: &'a str) -> bool
-    where
-        Self::Searcher: ReverseSearcher<'a>,
-    {
-        matches!(self.into_searcher(haystack).next_back(), SearchStep::Match(_, j) if haystack.len() == j)
+    fn is_suffix_of(self, haystack: H) -> bool
+    where Self::Searcher: ReverseSearcher<H> {
+        matches!(
+            self.into_searcher(haystack).next_back(),
+            SearchStep::Match(_, end) if end == haystack.cursor_at_back()
+        )
     }
 
     /// Removes the pattern from the front of haystack, if it matches.
     #[inline]
-    fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str> {
-        if let SearchStep::Match(start, len) = self.into_searcher(haystack).next() {
-            debug_assert_eq!(
-                start, 0,
-                "The first search step from Searcher \
-                 must include the first character"
-            );
+    fn strip_prefix_of(self, haystack: H) -> Option<H> {
+        if let SearchStep::Match(start, end) = self.into_searcher(haystack).next() {
+            // This cannot be debug_assert_eq because StartCursor isn’t Debug.
+            debug_assert!(start == haystack.cursor_at_front(),
+                          "The first search step from Searcher \
+                           must include the first character");
             // SAFETY: `Searcher` is known to return valid indices.
-            unsafe { Some(haystack.get_unchecked(len..)) }
+            Some(unsafe { haystack.split_at_cursor_unchecked(end) }.1)
         } else {
             None
         }
@@ -143,39 +146,60 @@ pub trait Pattern<'a>: Sized {
 
     /// Removes the pattern from the back of haystack, if it matches.
     #[inline]
-    fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
-    where
-        Self::Searcher: ReverseSearcher<'a>,
-    {
+    fn strip_suffix_of(self, haystack: H) -> Option<H>
+    where Self::Searcher: ReverseSearcher<H> {
         if let SearchStep::Match(start, end) = self.into_searcher(haystack).next_back() {
-            debug_assert_eq!(
-                end,
-                haystack.len(),
-                "The first search step from ReverseSearcher \
-                 must include the last character"
-            );
+            // This cannot be debug_assert_eq because StartCursor isn’t Debug.
+            debug_assert!(end == haystack.cursor_at_back(),
+                          "The first search step from ReverseSearcher \
+                           must include the last character");
             // SAFETY: `Searcher` is known to return valid indices.
-            unsafe { Some(haystack.get_unchecked(..start)) }
+            Some(unsafe { haystack.split_at_cursor_unchecked(start) }.0)
         } else {
             None
         }
     }
 }
 
+// Haystack
+
+/// A type which can be searched in using a [`Pattern`].
+///
+/// The trait is used in combination with [`Pattern`] trait to express a pattern
+/// that can be used to search for elements in given haystack.
+pub trait Haystack: Sized + Copy {
+    /// A cursor representing position in the haystack or its end.
+    type Cursor: Copy + PartialOrd;
+
+    /// Returns cursor pointing at the beginning of the haystack.
+    fn cursor_at_front(&self) -> Self::Cursor;
+
+    /// Returns cursor pointing at the end of the haystack.
+    fn cursor_at_back(&self) -> Self::Cursor;
+
+    /// Splits haystack into two at given cursor position.
+    ///
+    /// Note that splitting a haystack isn’t guaranteed to preserve total
+    /// length.  That is, each separate part’s length may be longer than length
+    /// of the original haystack.  This property is preserved for `&str` and
+    /// `&[T]` haystacks but not for `&OsStr`.
+    unsafe fn split_at_cursor_unchecked(self, cursor: Self::Cursor) -> (Self, Self);
+}
+
 // Searcher
 
 /// Result of calling [`Searcher::next()`] or [`ReverseSearcher::next_back()`].
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
-pub enum SearchStep {
+pub enum SearchStep<T = usize> {
     /// Expresses that a match of the pattern has been found at
     /// `haystack[a..b]`.
-    Match(usize, usize),
+    Match(T, T),
     /// Expresses that `haystack[a..b]` has been rejected as a possible match
     /// of the pattern.
     ///
     /// Note that there might be more than one `Reject` between two `Match`es,
     /// there is no requirement for them to be combined into one.
-    Reject(usize, usize),
+    Reject(T, T),
     /// Expresses that every byte of the haystack has been visited, ending
     /// the iteration.
     Done,
@@ -193,11 +217,11 @@ pub enum SearchStep {
 /// [`next()`][Searcher::next] methods are required to lie on valid utf8
 /// boundaries in the haystack. This enables consumers of this trait to
 /// slice the haystack without additional runtime checks.
-pub unsafe trait Searcher<'a> {
+pub unsafe trait Searcher<H: Haystack> {
     /// Getter for the underlying string to be searched in
     ///
     /// Will always return the same [`&str`][str].
-    fn haystack(&self) -> &'a str;
+    fn haystack(&self) -> H;
 
     /// Performs the next search step starting from the front.
     ///
@@ -220,7 +244,7 @@ pub unsafe trait Searcher<'a> {
     /// As an example, the pattern `"aaa"` and the haystack `"cbaaaaab"`
     /// might produce the stream
     /// `[Reject(0, 1), Reject(1, 2), Match(2, 5), Reject(5, 8)]`
-    fn next(&mut self) -> SearchStep;
+    fn next(&mut self) -> SearchStep<H::Cursor>;
 
     /// Finds the next [`Match`][SearchStep::Match] result. See [`next()`][Searcher::next].
     ///
@@ -229,7 +253,7 @@ pub unsafe trait Searcher<'a> {
     /// `(start_match, end_match)`, where start_match is the index of where
     /// the match begins, and end_match is the index after the end of the match.
     #[inline]
-    fn next_match(&mut self) -> Option<(usize, usize)> {
+    fn next_match(&mut self) -> Option<(H::Cursor, H::Cursor)> {
         loop {
             match self.next() {
                 SearchStep::Match(a, b) => return Some((a, b)),
@@ -245,7 +269,7 @@ pub unsafe trait Searcher<'a> {
     /// Unlike [`next()`][Searcher::next], there is no guarantee that the returned ranges
     /// of this and [`next_match`][Searcher::next_match] will overlap.
     #[inline]
-    fn next_reject(&mut self) -> Option<(usize, usize)> {
+    fn next_reject(&mut self) -> Option<(H::Cursor, H::Cursor)> {
         loop {
             match self.next() {
                 SearchStep::Reject(a, b) => return Some((a, b)),
@@ -270,7 +294,7 @@ pub unsafe trait Searcher<'a> {
 ///
 /// For the reason why this trait is marked unsafe, see the
 /// parent trait [`Searcher`].
-pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
+pub unsafe trait ReverseSearcher<H: Haystack>: Searcher<H> {
     /// Performs the next search step starting from the back.
     ///
     /// - Returns [`Match(a, b)`][SearchStep::Match] if `haystack[a..b]`
@@ -292,12 +316,12 @@ pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
     /// As an example, the pattern `"aaa"` and the haystack `"cbaaaaab"`
     /// might produce the stream
     /// `[Reject(7, 8), Match(4, 7), Reject(1, 4), Reject(0, 1)]`.
-    fn next_back(&mut self) -> SearchStep;
+    fn next_back(&mut self) -> SearchStep<H::Cursor>;
 
     /// Finds the next [`Match`][SearchStep::Match] result.
     /// See [`next_back()`][ReverseSearcher::next_back].
     #[inline]
-    fn next_match_back(&mut self) -> Option<(usize, usize)> {
+    fn next_match_back(&mut self) -> Option<(H::Cursor, H::Cursor)> {
         loop {
             match self.next_back() {
                 SearchStep::Match(a, b) => return Some((a, b)),
@@ -310,7 +334,7 @@ pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
     /// Finds the next [`Reject`][SearchStep::Reject] result.
     /// See [`next_back()`][ReverseSearcher::next_back].
     #[inline]
-    fn next_reject_back(&mut self) -> Option<(usize, usize)> {
+    fn next_reject_back(&mut self) -> Option<(H::Cursor, H::Cursor)> {
         loop {
             match self.next_back() {
                 SearchStep::Reject(a, b) => return Some((a, b)),
@@ -342,16 +366,35 @@ pub unsafe trait ReverseSearcher<'a>: Searcher<'a> {
 /// `(&str)::Searcher` is not a `DoubleEndedSearcher` because
 /// the pattern `"aa"` in the haystack `"aaa"` matches as either
 /// `"[aa]a"` or `"a[aa]"`, depending from which side it is searched.
-pub trait DoubleEndedSearcher<'a>: ReverseSearcher<'a> {}
+pub trait DoubleEndedSearcher<H: Haystack>: ReverseSearcher<H> {}
+
+/////////////////////////////////////////////////////////////////////////////
+// Impl for Haystack
+/////////////////////////////////////////////////////////////////////////////
+
+impl<'a> Haystack for &'a str {
+    type Cursor = usize;
+
+    #[inline(always)]
+    fn cursor_at_front(&self) -> usize { 0 }
+    #[inline(always)]
+    fn cursor_at_back(&self) -> usize { self.len() }
+
+    #[inline(always)]
+    unsafe fn split_at_cursor_unchecked(self, cursor: usize) -> (Self, Self) {
+        // SAFETY: Caller promises position is a character boundary.
+        unsafe { (self.get_unchecked(..cursor), self.get_unchecked(cursor..)) }
+    }
+}
 
 /////////////////////////////////////////////////////////////////////////////
 // Impl for char
 /////////////////////////////////////////////////////////////////////////////
 
-/// Associated type for `<char as Pattern<'a>>::Searcher`.
+/// Associated type for `<char as Pattern<H>>::Searcher`.
 #[derive(Clone, Debug)]
-pub struct CharSearcher<'a> {
-    haystack: &'a str,
+pub struct CharSearcher<H: Haystack> {
+    haystack: H,
     // safety invariant: `finger`/`finger_back` must be a valid utf8 byte index of `haystack`
     // This invariant can be broken *within* next_match and next_match_back, however
     // they must exit with fingers on valid code point boundaries.
@@ -359,12 +402,12 @@ pub struct CharSearcher<'a> {
     /// Imagine that it exists before the byte at its index, i.e.
     /// `haystack[finger]` is the first byte of the slice we must inspect during
     /// forward searching
-    finger: usize,
+    finger: H::Cursor,
     /// `finger_back` is the current byte index of the reverse search.
     /// Imagine that it exists after the byte at its index, i.e.
     /// haystack[finger_back - 1] is the last byte of the slice we must inspect during
     /// forward searching (and thus the first byte to be inspected when calling next_back()).
-    finger_back: usize,
+    finger_back: H::Cursor,
     /// The character being searched for
     needle: char,
 
@@ -375,7 +418,7 @@ pub struct CharSearcher<'a> {
     utf8_encoded: [u8; 4],
 }
 
-unsafe impl<'a> Searcher<'a> for CharSearcher<'a> {
+unsafe impl<'a> Searcher<&'a str> for CharSearcher<&'a str> {
     #[inline]
     fn haystack(&self) -> &'a str {
         self.haystack
@@ -453,7 +496,7 @@ unsafe impl<'a> Searcher<'a> for CharSearcher<'a> {
     // let next_reject use the default implementation from the Searcher trait
 }
 
-unsafe impl<'a> ReverseSearcher<'a> for CharSearcher<'a> {
+unsafe impl<'a> ReverseSearcher<&'a str> for CharSearcher<&'a str> {
     #[inline]
     fn next_back(&mut self) -> SearchStep {
         let old_finger = self.finger_back;
@@ -527,7 +570,7 @@ unsafe impl<'a> ReverseSearcher<'a> for CharSearcher<'a> {
     // let next_reject_back use the default implementation from the Searcher trait
 }
 
-impl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a> {}
+impl<'a> DoubleEndedSearcher<&'a str> for CharSearcher<&'a str> {}
 
 /// Searches for chars that are equal to a given [`char`].
 ///
@@ -536,8 +579,8 @@ impl<'a> DoubleEndedSearcher<'a> for CharSearcher<'a> {}
 /// ```
 /// assert_eq!("Hello world".find('o'), Some(4));
 /// ```
-impl<'a> Pattern<'a> for char {
-    type Searcher = CharSearcher<'a>;
+impl<'a> Pattern<&'a str> for char {
+    type Searcher = CharSearcher<&'a str>;
 
     #[inline]
     fn into_searcher(self, haystack: &'a str) -> Self::Searcher {
@@ -576,7 +619,7 @@ impl<'a> Pattern<'a> for char {
     #[inline]
     fn is_suffix_of(self, haystack: &'a str) -> bool
     where
-        Self::Searcher: ReverseSearcher<'a>,
+        Self::Searcher: ReverseSearcher<&'a str>,
     {
         self.encode_utf8(&mut [0u8; 4]).is_suffix_of(haystack)
     }
@@ -584,7 +627,7 @@ impl<'a> Pattern<'a> for char {
     #[inline]
     fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
     where
-        Self::Searcher: ReverseSearcher<'a>,
+        Self::Searcher: ReverseSearcher<&'a str>,
     {
         self.encode_utf8(&mut [0u8; 4]).strip_suffix_of(haystack)
     }
@@ -639,7 +682,7 @@ struct MultiCharEqSearcher<'a, C: MultiCharEq> {
     char_indices: super::CharIndices<'a>,
 }
 
-impl<'a, C: MultiCharEq> Pattern<'a> for MultiCharEqPattern<C> {
+impl<'a, C: MultiCharEq> Pattern<&'a str> for MultiCharEqPattern<C> {
     type Searcher = MultiCharEqSearcher<'a, C>;
 
     #[inline]
@@ -648,7 +691,7 @@ impl<'a, C: MultiCharEq> Pattern<'a> for MultiCharEqPattern<C> {
     }
 }
 
-unsafe impl<'a, C: MultiCharEq> Searcher<'a> for MultiCharEqSearcher<'a, C> {
+unsafe impl<'a, C: MultiCharEq> Searcher<&'a str> for MultiCharEqSearcher<'a, C> {
     #[inline]
     fn haystack(&self) -> &'a str {
         self.haystack
@@ -673,7 +716,7 @@ unsafe impl<'a, C: MultiCharEq> Searcher<'a> for MultiCharEqSearcher<'a, C> {
     }
 }
 
-unsafe impl<'a, C: MultiCharEq> ReverseSearcher<'a> for MultiCharEqSearcher<'a, C> {
+unsafe impl<'a, C: MultiCharEq> ReverseSearcher<&'a str> for MultiCharEqSearcher<'a, C> {
     #[inline]
     fn next_back(&mut self) -> SearchStep {
         let s = &mut self.char_indices;
@@ -693,7 +736,7 @@ unsafe impl<'a, C: MultiCharEq> ReverseSearcher<'a> for MultiCharEqSearcher<'a,
     }
 }
 
-impl<'a, C: MultiCharEq> DoubleEndedSearcher<'a> for MultiCharEqSearcher<'a, C> {}
+impl<'a, C: MultiCharEq> DoubleEndedSearcher<&'a str> for MultiCharEqSearcher<'a, C> {}
 
 /////////////////////////////////////////////////////////////////////////////
 
@@ -724,7 +767,7 @@ macro_rules! pattern_methods {
         #[inline]
         fn is_suffix_of(self, haystack: &'a str) -> bool
         where
-            $t: ReverseSearcher<'a>,
+            $t: ReverseSearcher<&'a str>,
         {
             ($pmap)(self).is_suffix_of(haystack)
         }
@@ -732,7 +775,7 @@ macro_rules! pattern_methods {
         #[inline]
         fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
         where
-            $t: ReverseSearcher<'a>,
+            $t: ReverseSearcher<&'a str>,
         {
             ($pmap)(self).strip_suffix_of(haystack)
         }
@@ -774,16 +817,16 @@ macro_rules! searcher_methods {
     };
 }
 
-/// Associated type for `<[char; N] as Pattern<'a>>::Searcher`.
+/// Associated type for `<[char; N] as Pattern<&'a str>>::Searcher`.
 #[derive(Clone, Debug)]
 pub struct CharArraySearcher<'a, const N: usize>(
-    <MultiCharEqPattern<[char; N]> as Pattern<'a>>::Searcher,
+    <MultiCharEqPattern<[char; N]> as Pattern<&'a str>>::Searcher,
 );
 
-/// Associated type for `<&[char; N] as Pattern<'a>>::Searcher`.
+/// Associated type for `<&[char; N] as Pattern<&'a str>>::Searcher`.
 #[derive(Clone, Debug)]
 pub struct CharArrayRefSearcher<'a, 'b, const N: usize>(
-    <MultiCharEqPattern<&'b [char; N]> as Pattern<'a>>::Searcher,
+    <MultiCharEqPattern<&'b [char; N]> as Pattern<&'a str>>::Searcher,
 );
 
 /// Searches for chars that are equal to any of the [`char`]s in the array.
@@ -794,15 +837,15 @@ pub struct CharArrayRefSearcher<'a, 'b, const N: usize>(
 /// assert_eq!("Hello world".find(['l', 'l']), Some(2));
 /// assert_eq!("Hello world".find(['l', 'l']), Some(2));
 /// ```
-impl<'a, const N: usize> Pattern<'a> for [char; N] {
+impl<'a, const N: usize> Pattern<&'a str> for [char; N] {
     pattern_methods!(CharArraySearcher<'a, N>, MultiCharEqPattern, CharArraySearcher);
 }
 
-unsafe impl<'a, const N: usize> Searcher<'a> for CharArraySearcher<'a, N> {
+unsafe impl<'a, const N: usize> Searcher<&'a str> for CharArraySearcher<'a, N> {
     searcher_methods!(forward);
 }
 
-unsafe impl<'a, const N: usize> ReverseSearcher<'a> for CharArraySearcher<'a, N> {
+unsafe impl<'a, const N: usize> ReverseSearcher<&'a str> for CharArraySearcher<'a, N> {
     searcher_methods!(reverse);
 }
 
@@ -814,15 +857,15 @@ unsafe impl<'a, const N: usize> ReverseSearcher<'a> for CharArraySearcher<'a, N>
 /// assert_eq!("Hello world".find(&['l', 'l']), Some(2));
 /// assert_eq!("Hello world".find(&['l', 'l']), Some(2));
 /// ```
-impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N] {
+impl<'a, 'b, const N: usize> Pattern<&'a str> for &'b [char; N] {
     pattern_methods!(CharArrayRefSearcher<'a, 'b, N>, MultiCharEqPattern, CharArrayRefSearcher);
 }
 
-unsafe impl<'a, 'b, const N: usize> Searcher<'a> for CharArrayRefSearcher<'a, 'b, N> {
+unsafe impl<'a, 'b, const N: usize> Searcher<&'a str> for CharArrayRefSearcher<'a, 'b, N> {
     searcher_methods!(forward);
 }
 
-unsafe impl<'a, 'b, const N: usize> ReverseSearcher<'a> for CharArrayRefSearcher<'a, 'b, N> {
+unsafe impl<'a, 'b, const N: usize> ReverseSearcher<&'a str> for CharArrayRefSearcher<'a, 'b, N> {
     searcher_methods!(reverse);
 }
 
@@ -832,19 +875,19 @@ unsafe impl<'a, 'b, const N: usize> ReverseSearcher<'a> for CharArrayRefSearcher
 
 // Todo: Change / Remove due to ambiguity in meaning.
 
-/// Associated type for `<&[char] as Pattern<'a>>::Searcher`.
+/// Associated type for `<&[char] as Pattern<&'a str>>::Searcher`.
 #[derive(Clone, Debug)]
-pub struct CharSliceSearcher<'a, 'b>(<MultiCharEqPattern<&'b [char]> as Pattern<'a>>::Searcher);
+pub struct CharSliceSearcher<'a, 'b>(<MultiCharEqPattern<&'b [char]> as Pattern<&'a str>>::Searcher);
 
-unsafe impl<'a, 'b> Searcher<'a> for CharSliceSearcher<'a, 'b> {
+unsafe impl<'a, 'b> Searcher<&'a str> for CharSliceSearcher<'a, 'b> {
     searcher_methods!(forward);
 }
 
-unsafe impl<'a, 'b> ReverseSearcher<'a> for CharSliceSearcher<'a, 'b> {
+unsafe impl<'a, 'b> ReverseSearcher<&'a str> for CharSliceSearcher<'a, 'b> {
     searcher_methods!(reverse);
 }
 
-impl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b> {}
+impl<'a, 'b> DoubleEndedSearcher<&'a str> for CharSliceSearcher<'a, 'b> {}
 
 /// Searches for chars that are equal to any of the [`char`]s in the slice.
 ///
@@ -854,7 +897,7 @@ impl<'a, 'b> DoubleEndedSearcher<'a> for CharSliceSearcher<'a, 'b> {}
 /// assert_eq!("Hello world".find(&['l', 'l'] as &[_]), Some(2));
 /// assert_eq!("Hello world".find(&['l', 'l'][..]), Some(2));
 /// ```
-impl<'a, 'b> Pattern<'a> for &'b [char] {
+impl<'a, 'b> Pattern<&'a str> for &'b [char] {
     pattern_methods!(CharSliceSearcher<'a, 'b>, MultiCharEqPattern, CharSliceSearcher);
 }
 
@@ -862,9 +905,9 @@ impl<'a, 'b> Pattern<'a> for &'b [char] {
 // Impl for F: FnMut(char) -> bool
 /////////////////////////////////////////////////////////////////////////////
 
-/// Associated type for `<F as Pattern<'a>>::Searcher`.
+/// Associated type for `<F as Pattern<&'a str>>::Searcher`.
 #[derive(Clone)]
-pub struct CharPredicateSearcher<'a, F>(<MultiCharEqPattern<F> as Pattern<'a>>::Searcher)
+pub struct CharPredicateSearcher<'a, F>(<MultiCharEqPattern<F> as Pattern<&'a str>>::Searcher)
 where
     F: FnMut(char) -> bool;
 
@@ -879,21 +922,21 @@ where
             .finish()
     }
 }
-unsafe impl<'a, F> Searcher<'a> for CharPredicateSearcher<'a, F>
+unsafe impl<'a, F> Searcher<&'a str> for CharPredicateSearcher<'a, F>
 where
     F: FnMut(char) -> bool,
 {
     searcher_methods!(forward);
 }
 
-unsafe impl<'a, F> ReverseSearcher<'a> for CharPredicateSearcher<'a, F>
+unsafe impl<'a, F> ReverseSearcher<&'a str> for CharPredicateSearcher<'a, F>
 where
     F: FnMut(char) -> bool,
 {
     searcher_methods!(reverse);
 }
 
-impl<'a, F> DoubleEndedSearcher<'a> for CharPredicateSearcher<'a, F> where F: FnMut(char) -> bool {}
+impl<'a, F> DoubleEndedSearcher<&'a str> for CharPredicateSearcher<'a, F> where F: FnMut(char) -> bool {}
 
 /// Searches for [`char`]s that match the given predicate.
 ///
@@ -903,7 +946,7 @@ impl<'a, F> DoubleEndedSearcher<'a> for CharPredicateSearcher<'a, F> where F: Fn
 /// assert_eq!("Hello world".find(char::is_uppercase), Some(0));
 /// assert_eq!("Hello world".find(|c| "aeiou".contains(c)), Some(1));
 /// ```
-impl<'a, F> Pattern<'a> for F
+impl<'a, F> Pattern<&'a str> for F
 where
     F: FnMut(char) -> bool,
 {
@@ -915,7 +958,7 @@ where
 /////////////////////////////////////////////////////////////////////////////
 
 /// Delegates to the `&str` impl.
-impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str {
+impl<'a, 'b, 'c> Pattern<&'a str> for &'c &'b str {
     pattern_methods!(StrSearcher<'a, 'b>, |&s| s, |s| s);
 }
 
@@ -933,7 +976,7 @@ impl<'a, 'b, 'c> Pattern<'a> for &'c &'b str {
 /// ```
 /// assert_eq!("Hello world".find("world"), Some(6));
 /// ```
-impl<'a, 'b> Pattern<'a> for &'b str {
+impl<'a, 'b> Pattern<&'a str> for &'b str {
     type Searcher = StrSearcher<'a, 'b>;
 
     #[inline]
@@ -1008,7 +1051,7 @@ impl<'a, 'b> Pattern<'a> for &'b str {
 /////////////////////////////////////////////////////////////////////////////
 
 #[derive(Clone, Debug)]
-/// Associated type for `<&str as Pattern<'a>>::Searcher`.
+/// Associated type for `<&str as Pattern<&'a str>>::Searcher`.
 pub struct StrSearcher<'a, 'b> {
     haystack: &'a str,
     needle: &'b str,
@@ -1059,7 +1102,7 @@ impl<'a, 'b> StrSearcher<'a, 'b> {
     }
 }
 
-unsafe impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b> {
+unsafe impl<'a, 'b> Searcher<&'a str> for StrSearcher<'a, 'b> {
     #[inline]
     fn haystack(&self) -> &'a str {
         self.haystack
@@ -1149,7 +1192,7 @@ unsafe impl<'a, 'b> Searcher<'a> for StrSearcher<'a, 'b> {
     }
 }
 
-unsafe impl<'a, 'b> ReverseSearcher<'a> for StrSearcher<'a, 'b> {
+unsafe impl<'a, 'b> ReverseSearcher<&'a str> for StrSearcher<'a, 'b> {
     #[inline]
     fn next_back(&mut self) -> SearchStep {
         match self.searcher {
diff --git a/tests/run-make-fulldeps/save-analysis-fail/foo.rs b/tests/run-make-fulldeps/save-analysis-fail/foo.rs
index c5a70605e04cb..dccf83f6ec3a1 100644
--- a/tests/run-make-fulldeps/save-analysis-fail/foo.rs
+++ b/tests/run-make-fulldeps/save-analysis-fail/foo.rs
@@ -403,17 +403,17 @@ impl Iterator for nofields {
     }
 }
 
-trait Pattern<'a> {
+trait Pattern<&'a str> {
     type Searcher;
 }
 
 struct CharEqPattern;
 
-impl<'a> Pattern<'a> for CharEqPattern {
+impl<'a> Pattern<&'a str> for CharEqPattern {
     type Searcher = CharEqPattern;
 }
 
-struct CharSearcher<'a>(<CharEqPattern as Pattern<'a>>::Searcher);
+struct CharSearcher<'a>(<CharEqPattern as Pattern<&'a str>>::Searcher);
 
 pub trait Error {}
 
diff --git a/tests/run-make-fulldeps/save-analysis/foo.rs b/tests/run-make-fulldeps/save-analysis/foo.rs
index 384589de3b480..5c6fe02cbdc12 100644
--- a/tests/run-make-fulldeps/save-analysis/foo.rs
+++ b/tests/run-make-fulldeps/save-analysis/foo.rs
@@ -402,17 +402,17 @@ impl Iterator for nofields {
     }
 }
 
-trait Pattern<'a> {
+trait Pattern<&'a str> {
     type Searcher;
 }
 
 struct CharEqPattern;
 
-impl<'a> Pattern<'a> for CharEqPattern {
+impl<'a> Pattern<&'a str> for CharEqPattern {
     type Searcher = CharEqPattern;
 }
 
-struct CharSearcher<'a>(<CharEqPattern as Pattern<'a>>::Searcher);
+struct CharSearcher<'a>(<CharEqPattern as Pattern<&'a str>>::Searcher);
 
 pub trait Error {}
 
diff --git a/tests/rustdoc/async-fn.rs b/tests/rustdoc/async-fn.rs
index 70bcbcb6ff44a..3f641473d308a 100644
--- a/tests/rustdoc/async-fn.rs
+++ b/tests/rustdoc/async-fn.rs
@@ -46,7 +46,7 @@ impl Foo {
     pub async fn mut_self(mut self, mut first: usize) {}
 }
 
-pub trait Pattern<'a> {}
+pub trait Pattern<&'a str> {}
 
 pub trait Trait<const N: usize> {}
 // @has async_fn/fn.const_generics.html
@@ -91,5 +91,5 @@ impl Foo {
 // @has - '//pre[@class="rust item-decl"]' "pub async fn named<'a, 'b>(foo: &'a str) -> &'b str"
 pub async fn named<'a, 'b>(foo: &'a str) -> &'b str {}
 // @has async_fn/fn.named_trait.html
-// @has - '//pre[@class="rust item-decl"]' "pub async fn named_trait<'a, 'b>(foo: impl Pattern<'a>) -> impl Pattern<'b>"
-pub async fn named_trait<'a, 'b>(foo: impl Pattern<'a>) -> impl Pattern<'b> {}
+// @has - '//pre[@class="rust item-decl"]' "pub async fn named_trait<'a, 'b>(foo: impl Pattern<&'a str>) -> impl Pattern<'b>"
+pub async fn named_trait<'a, 'b>(foo: impl Pattern<&'a str>) -> impl Pattern<'b> {}
diff --git a/tests/ui/traits/bound/assoc-fn-bound-root-obligation.rs b/tests/ui/traits/bound/assoc-fn-bound-root-obligation.rs
index f9a9347641143..8a047a082c4a4 100644
--- a/tests/ui/traits/bound/assoc-fn-bound-root-obligation.rs
+++ b/tests/ui/traits/bound/assoc-fn-bound-root-obligation.rs
@@ -3,7 +3,7 @@ fn strip_lf(s: &str) -> &str {
     //~^ ERROR expected a `FnMut<(char,)>` closure, found `u8`
     //~| NOTE expected an `FnMut<(char,)>` closure, found `u8`
     //~| HELP the trait `FnMut<(char,)>` is not implemented for `u8`
-    //~| HELP the following other types implement trait `Pattern<'a>`:
+    //~| HELP the following other types implement trait `Pattern<&'a str>`:
     //~| NOTE required for `u8` to implement `Pattern<'_>`
 
 }
diff --git a/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr b/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
index ce9ab2d811ae1..e97aaa6834309 100644
--- a/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
+++ b/tests/ui/traits/bound/assoc-fn-bound-root-obligation.stderr
@@ -5,7 +5,7 @@ LL |     s.strip_suffix(b'\n').unwrap_or(s)
    |       ^^^^^^^^^^^^ expected an `FnMut<(char,)>` closure, found `u8`
    |
    = help: the trait `FnMut<(char,)>` is not implemented for `u8`
-   = help: the following other types implement trait `Pattern<'a>`:
+   = help: the following other types implement trait `Pattern<&'a str>`:
              &'b String
              &'b [char; N]
              &'b [char]