Using the same iterator multiple times in Rust

by

As you identified, each take_while call is duplicating iter, since take_while takes self and the Peekable chars iterator is Copy. (Only true before Rust 1.0 — editor)

You want to be modifying the iterator each time, that is, for take_while to be operating on an &mut to your iterator. Which is exactly what the .by_ref adaptor is for:

pub fn split(input: &str) -> Vec<String> {
    let mut bits: Vec<String> = vec![];
    let mut iter = input.chars().peekable();
    loop {
        match iter.peek().map(|c| *c) {
            None => return bits,
            Some(c) => if c.is_digit(10) {
                bits.push(iter.by_ref().take_while(|c| c.is_digit(10)).collect());
            } else {
                bits.push(iter.by_ref().take_while(|c| !c.is_digit(10)).collect());
            },
        }
    }
}

fn main() {
    println!("{:?}", split("123abc456def"))
}

Prints

["123", "bc", "56", "ef"]

However, I imagine this is not correct.

I would actually recommend writing this as a normal for loop, using the char_indices iterator:

pub fn split(input: &str) -> Vec<String> {
    let mut bits: Vec<String> = vec![];
    if input.is_empty() {
        return bits;
    }

    let mut is_digit = input.chars().next().unwrap().is_digit(10);
    let mut start = 0;

    for (i, c) in input.char_indices() {
        let this_is_digit = c.is_digit(10);
        if is_digit != this_is_digit {
            bits.push(input[start..i].to_string());
            is_digit = this_is_digit;
            start = i;
        }
    }

    bits.push(input[start..].to_string());
    bits
}

This form also allows for doing this with much fewer allocations (that is, the Strings are not required), because each returned value is just a slice into the input, and we can use lifetimes to state this:

pub fn split<'a>(input: &'a str) -> Vec<&'a str> {
    let mut bits = vec![];
    if input.is_empty() {
        return bits;
    }

    let mut is_digit = input.chars().next().unwrap().is_digit(10);
    let mut start = 0;

    for (i, c) in input.char_indices() {
        let this_is_digit = c.is_digit(10);
        if is_digit != this_is_digit {
            bits.push(&input[start..i]);
            is_digit = this_is_digit;
            start = i;
        }
    }

    bits.push(&input[start..]);
    bits
}

All that changed was the type signature, removing the Vec<String> type hint and the .to_string calls.

One could even write an iterator like this, to avoid having to allocate the Vec. Something like fn split<'a>(input: &'a str) -> Splits<'a> { /* construct a Splits */ } where Splits is a struct that implements Iterator<&'a str>.

More Related Contents:

  1. Why can’t I store a value and a reference to that value in the same struct?
  2. How do I create a heterogeneous collection of objects?
  3. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  4. Is it possible to control the size of an array using the type parameter of a generic?
  5. Are polymorphic variables allowed?
  6. Does println! borrow or own the variable?
  7. How do I pass disjoint slices from a vector to different threads?
  8. Why does Iterator::take_while take ownership of the iterator?
  9. When should I implement std::convert::From vs std::convert::Into?
  10. Why is it possible to implement Read on an immutable reference to File?
  11. Compare enums only by variant, not value
  12. How can I call a mutating method while holding a reference to self?
  13. How do you actually use dynamically sized types in Rust?
  14. Why do I need rebinding/shadowing when I can have mutable variable binding?
  15. How can I downcast from Box to a trait object type?
  16. How do I ‘pass down’ feature flags to subdependencies in Cargo?
  17. Using generic trait methods like .into() when type inference is impossible
  18. Why does an enum require extra memory size?
  19. What is a crate attribute and where do I add it?
  20. Parameter type may not live long enough?
  21. Why does Rust disallow mutable aliasing?
  22. How to model complex recursive data structures (graphs)?
  23. Why can’t I reuse a &mut reference after passing it to a function that accepts a generic type?
  24. How can I define an async method in a trait?
  25. How do I specify the linker path in Rust?
  26. How can I override a constant via a compiler option?
  27. What is the purpose of the unit type in Rust?
  28. Why does the Rust compiler request I constrain a generic type parameter’s lifetime (error E0309)?
  29. Cannot pass self as callback parameter due to double borrowing
  30. How do I create a HashMap with type erased keys?

Leave a Comment