Merge pull request #96 from shepmaster/pattern

Remove usage of unstable pattern feature

Author: shepmaster

.github/workflows/ci.yml

@@ -46,27 +46,6 @@ jobs:
 
       - run: cargo test
 
-  features:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        rust:
-          - nightly
-        features:
-          - unstable
-          # - compile_failure # Currently not clean
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ matrix.rust }}
-
-      - run: cargo build --features ${{ matrix.features }}
-
-      - run: cargo test--features ${{ matrix.features }}
-
   windows:
     runs-on: windows-latest
     strategy:

src/lib.rs

@@ -49,7 +49,6 @@
 //! Try to leverage the type system as much as possible.
 
 #![deny(rust_2018_idioms)]
-#![cfg_attr(feature = "unstable", feature(pattern))]
 #![cfg_attr(feature = "unstable", feature(test))]
 
 #[macro_use]

src/str_ext.rs

@@ -1,85 +1,16 @@
-#[cfg(feature = "unstable")]
-use std::str::pattern::{Pattern, Searcher};
-
 #[derive(Copy, Clone, Debug, PartialEq)]
 pub enum SplitType<'a> {
     Match(&'a str),
     Delimiter(&'a str),
 }
 
-#[cfg(feature = "unstable")]
-pub struct SplitKeepingDelimiter<'p, P>
-where
-    P: Pattern<'p>,
-{
-    searcher: P::Searcher,
-    start: usize,
-    saved: Option<usize>,
-}
-
-#[cfg(feature = "unstable")]
-impl<'p, P> Iterator for SplitKeepingDelimiter<'p, P>
-where
-    P: Pattern<'p>,
-{
-    type Item = SplitType<'p>;
-
-    fn next(&mut self) -> Option<SplitType<'p>> {
-        if self.start == self.searcher.haystack().len() {
-            return None;
-        }
-
-        if let Some(end_of_match) = self.saved.take() {
-            let s = &self.searcher.haystack()[self.start..end_of_match];
-            self.start = end_of_match;
-            return Some(SplitType::Delimiter(s));
-        }
-
-        match self.searcher.next_match() {
-            Some((start, end)) => {
-                if self.start == start {
-                    let s = &self.searcher.haystack()[start..end];
-                    self.start = end;
-                    Some(SplitType::Delimiter(s))
-                } else {
-                    let s = &self.searcher.haystack()[self.start..start];
-                    self.start = start;
-                    self.saved = Some(end);
-                    Some(SplitType::Match(s))
-                }
-            }
-            None => {
-                let s = &self.searcher.haystack()[self.start..];
-                self.start = self.searcher.haystack().len();
-                Some(SplitType::Match(s))
-            }
-        }
-    }
-}
-
-#[cfg(feature = "unstable")]
-pub trait SplitKeepingDelimiterExt: ::std::ops::Index<::std::ops::RangeFull, Output = str> {
-    fn split_keeping_delimiter<P>(&self, pattern: P) -> SplitKeepingDelimiter<'_, P>
-    where
-        P: for<'a> Pattern<'a>,
-    {
-        SplitKeepingDelimiter {
-            searcher: pattern.into_searcher(&self[..]),
-            start: 0,
-            saved: None,
-        }
-    }
-}
-
-#[cfg(not(feature = "unstable"))]
 pub struct SplitKeepingDelimiter<'a, F> {
     haystack: &'a str,
     chars: F,
     start: usize,
     saved: Option<usize>,
 }
 
-#[cfg(not(feature = "unstable"))]
 impl<'a, F> Iterator for SplitKeepingDelimiter<'a, F>
 where
     F: Fn(char) -> bool,
@@ -123,7 +54,6 @@ where
     }
 }
 
-#[cfg(not(feature = "unstable"))]
 pub trait SplitKeepingDelimiterExt: ::std::ops::Index<::std::ops::RangeFull, Output = str> {
     fn split_keeping_delimiter<F>(&self, chars: F) -> SplitKeepingDelimiter<'_, F>
     where