Split string at given positions

Question

Given a vector <Vec<usize>> of indices indicating where to split a string as follows:

println!("{:?}", idxs);
[2, 1, 6, 2, 5, 2, 2, 1]

And the following string (The Series column in the Bureau of Labor Statistics' data):

let mut sstr = "JTS000000000000000JOR";

I wrote a recursive function to split the string as follows:

fn split_str(cur: &str, rest: &str, idxs: Vec<usize>, mut res: Vec<String>) -> Vec<String> {
    if idxs.len() > 1 {
        //println!("cur: {} idx: {} rest: {}", cur, *idxs.first().unwrap(), rest);
        res.push(cur.to_owned());
        let (cur, rest) = rest.split_at(*idxs.first().unwrap());
        split_str(cur, rest, idxs[1..].to_vec(), res)        
    }
    else {
        res.push(cur.to_string()); 
        //println!("{}", rest);
        res[1..].to_vec()
    }
}

The method is run as follows:

let r = split_str(&sstr[0..idxs[0]], &sstr[(idxs[1]+1)..], idxs[1..].to_vec(), vec!["".to_string()]);

which correctly returns

["JT", "S", "000000", "00", "00000", "00", "JO", "R"]

How can I optimize this code? I'm used to Scala and it feels like I'm forcing Rust into a pattern it wasn't designed for, but I don't want to revert to traditional loops.

Answer 1

In Rust, we tend to make use of iterators rather than recursion. Map, filter, reduce, etc. are your friends, especially if you don't like loops. Also, when working with parameters, slices tend to be preferable over Vecs (though returning is usually a concrete collection). Another thing is that we tend to use method chaining where possible (acting as a poor man's function composition).

Keeping the general method of splitting the string, I've refactored the given method to the following:

pub fn split_str(string: &str, places: &[usize]) -> Vec<String> {
    let (mut res, rem) = places
        .iter()
        .fold((Vec::<String>::new(), string), |(res, rem), place| {
            let (cur, rem) = rem.split_at(place);
            res.push(String::from(cur));
            (res, rem)
        });
    res.push(String::from(cur));
    res
}

Hope this was helpful!

Answer 2

I ended up rewriting the function with fold as follows:

fn str_splits(s: String, is: &[usize]) -> Vec<String> {
   let (first, mut rest) = s.split_at(is[0]);  
   let cols =  is.iter().skip(1).fold(vec![first.to_string()],  |mut v, nxt|  {
    //println!("Current vector: {:?} Next: {}, Remaining String: {}", v, nxt, rest);
    let (cur, rst) = &rest.split_at(*nxt);
    rest = rst;   
    v.push(cur.to_string());
    v});
    cols
}

Given the following slice and string

let cs = str_splits(&[2, 1, 6, 2, 5, 2, 2, 1]
let s = "JTS000000000000000JOR".to_string();

The function can be run as follows:

let r = str_splits(s, cs);

Which correctly returns

["JT", "S", "000000", "00", "00000", "00", "JO", "R"]

A demonstration can be found here.

I believe this version is easier to grasp and more in line with Rust style. Fold has also proved to be fast in other cases.