Capturing group in split doesn't contain the matches

[yangsibai]

When I use capturing group in my pattern, I want the result of split can keep the matched strings. It seems the current implementation of split removed them.

For example: the patten is "(x)", the text is "1x2", the result should be ["1", "x", "2"]。

[BurntSushi]

Could you say more about the actual problem you're trying to solve? Having the captured text inside the iterator is a means to end.

In any case, I don't think something like this should be added to the crate. I find it to be very strange behavior that would be better handled by something not called "split." You might consider just writing it yourself. For example, if you use captures_iter, then you'll get an iterator over all matches. With a little extra state, it would be easy to turn that into an iterator over an enum like this:

enum SplitState<'t> {
    Unmatched(&'t str),
    Captured(Captures<'t>),
}

If you'd like help writing the code, I can do that for you, but it might take me a bit to get to.

[yangsibai]

Could you say more about the actual problem you're trying to solve? Having the captured text inside the iterator is a means to end.

Sure.

This could be very useful when I want to know what string split the text.

For example:

My texts could be "1+2", "1-2", and the pattern is "([^\d]+)".

I want the split method get results of ["1", "+", "2"] and ["1", "-", "2"], then I can know what is the operator.

Since the pattern contains group capturing, it should keep the matches into the results. I don't agree to it's a strange behavior.

You might consider just writing it yourself.

Thank you for telling me the captures_iter. I will try it later.

[BurntSushi]

It might not be strange, but I don't think it's standard behavior for something called "split," and I do at least think it's niche.

In any case, I wrote the iterator I mentioned in my previous comment. It's untested, but it does handle your case. :-)

extern crate regex;

use regex::{Regex, Captures, CaptureMatches};

struct SplitCaptures<'r, 't> {
    finder: CaptureMatches<'r, 't>,
    text: &'t str,
    last: usize,
    caps: Option<Captures<'t>>,
}

impl<'r, 't> SplitCaptures<'r, 't> {
    fn new(re: &'r Regex, text: &'t str) -> SplitCaptures<'r, 't> {
        SplitCaptures {
            finder: re.captures_iter(text),
            text: text,
            last: 0,
            caps: None,
        }
    }
}

#[derive(Debug)]
enum SplitState<'t> {
    Unmatched(&'t str),
    Captured(Captures<'t>),
}

impl<'r, 't> Iterator for SplitCaptures<'r, 't> {
    type Item = SplitState<'t>;

    fn next(&mut self) -> Option<SplitState<'t>> {
        if let Some(caps) = self.caps.take() {
            return Some(SplitState::Captured(caps));
        }
        match self.finder.next() {
            None => {
                if self.last >= self.text.len() {
                    None
                } else {
                    let s = &self.text[self.last..];
                    self.last = self.text.len();
                    Some(SplitState::Unmatched(s))
                }
            }
            Some(caps) => {
                let m = caps.get(0).unwrap();
                let unmatched = &self.text[self.last..m.start()];
                self.last = m.end();
                self.caps = Some(caps);
                Some(SplitState::Unmatched(unmatched))
            }
        }
    }
}

fn main() {
    let re = Regex::new(r"([^\d]+)").unwrap();
    let splitter = SplitCaptures::new(&re, "1+2");
    for state in splitter {
        match state {
            SplitState::Unmatched(t) => println!("unmatched: {:?}", t),
            SplitState::Captured(caps) => println!("captured: {:?}", &caps[0]),
        }
    }
}

[yangsibai]

I'm a newbie to rust. Your code is very helpful.

I have tested it, it's working well.

I think this should be a feature, some languages (like js, python) have this, I don't know is this standard behavior or a idiom, but I wish this could be added.

Thank you.

[BurntSushi]

I think it's potentially useful, but I'm not quite convinced it has broad enough applicability. I could be convinced otherwise, but I think I'd need to see some much stronger motivation.

I'm glad it helped though. :-)

[messense]

Just run into this when I was trying to port some regex from Python, it would indeed be quite useful to have it as a standard behavior for people coming from Python.

For now the SplitCaptures code works fine, a link to this issue in documentation/FAQ would be nice.