Разделите строку, удерживающую разделители

Существует ли тривиальный способ разделить строку, сохраняющую разделители? Вместо этого:

let texte = "Ten. Million. Questions. Let celebrate all we've done together.";
let v: Vec<&str> = texte.split(|c: char| !(c.is_alphanumeric() || c == '\'')).filter(|s| !s.is_empty()).collect();

который получается с помощью ["Ten", "Million", "Questions", "Let's", "celebrate", "all", "we've", "done", "together"].

Мне хотелось бы что-то, что дает мне:

["Ten", ".", " ", "Million", ".", " ", "Questions", ".", " ", "Let's", " ", "celebrate", " ", "all", " ", "we've", " ", "done", " ", "together", "."].

Я пытаюсь использовать такой код (предполагается, что строка начинается с буквы и заканчивается "не-буквой" ):

let texte = "Ten. Million. Questions. Let celebrate all we've done together.  ";
let v1: Vec<&str> = texte.split(|c: char| !(c.is_alphanumeric() || c == '\'')).filter(|s| !s.is_empty()).collect();
let v2: Vec<&str> = texte.split(|c: char| c.is_alphanumeric() || c == '\'').filter(|s| !s.is_empty()).collect();
let mut w: Vec<&str> = Vec::new();

let mut j = 0;
for i in v2 {
    w.push(v1[j]);
    w.push(i);
    j = j+1;
}

Это дает мне почти результат, который я написал ранее, но это хорошо:

["Ten", ". ", "Million", ". ", "Questions", ". ", "Let's", " ", "celebrate", " ", "all", " ", "we've", " ", "done", " ", "together", "."]

Однако есть ли лучший способ кодировать это? Поскольку я пытался перечислить v2, но это не сработало, и выглядит грубо для использования j в цикле for.

Ответ 1

Использование str::match_indices:

let text = "Ten. Million. Questions. Let celebrate all we've done together.";

let mut result = Vec::new();
let mut last = 0;
for (index, matched) in text.match_indices(|c: char| !(c.is_alphanumeric() || c == '\'')) {
    if last != index {
        result.push(&text[last..index]);
    }
    result.push(matched);
    last = index + matched.len();
}
if last < text.len() {
    result.push(&text[last..]);
}

println!("{:?}", result);

Печать:

["Ten", ".", " ", "Million", ".", " ", "Questions", ".", " ", "Let\'s", " ", "celebrate", " ", "all", " ", "we\'ve", " ", "done", " ", "together", "."]

Ответ 2

Я не смог ничего найти в стандартной библиотеке, поэтому я написал свою собственную:

В этой версии используется нестабильный API шаблонов, поскольку он более гибкий, но приведенная выше ссылка имеет запасной вариант, который я жестко прописал для своего конкретного стабильного варианта использования.

#![feature(pattern)]

use std::str::pattern::{Pattern, Searcher};

#[derive(Copy, Clone, Debug, PartialEq)]
pub enum SplitType<'a> {
    Match(&'a str),
    Delimiter(&'a str),
}

pub struct SplitKeepingDelimiter<'p, P>
where
    P: Pattern<'p>,
{
    searcher: P::Searcher,
    start: usize,
    saved: Option<usize>,
}

impl<'p, P> Iterator for SplitKeepingDelimiter<'p, P>
where
    P: Pattern<'p>,
{
    type Item = SplitType<'p>;

    fn next(&mut self) -> Option<Self::Item> {
        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))
            }
        }
    }
}

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,
        }
    }
}

impl SplitKeepingDelimiterExt for str {}

#[cfg(test)]
mod test {
    use super::SplitKeepingDelimiterExt;

    #[test]
    fn split_with_delimiter() {
        use super::SplitType::*;
        let delims = &[',', ';'][..];
        let items: Vec<_> = "alpha,beta;gamma".split_keeping_delimiter(delims).collect();
        assert_eq!(
            &items,
            &[
                Match("alpha"),
                Delimiter(","),
                Match("beta"),
                Delimiter(";"),
                Match("gamma")
            ]
        );
    }

    #[test]
    fn split_with_delimiter_allows_consecutive_delimiters() {
        use super::SplitType::*;
        let delims = &[',', ';'][..];
        let items: Vec<_> = ",;".split_keeping_delimiter(delims).collect();
        assert_eq!(&items, &[Delimiter(","), Delimiter(";")]);
    }
}

Вы заметите, что мне нужно было отследить, является ли что-то одним из разделителей или нет, но это должно быть легко адаптировать, если вам это не нужно.