How to translate "x-y" to vec![x, x+1, … y-1, y]?

Question

This solution seems rather inelegant:

fn parse_range(&self, string_value: &str) -> Vec<u8> {
    let values: Vec<u8> = string_value
        .splitn(2, "-")
        .map(|part| part.parse().ok().unwrap())
        .collect();

    { values[0]..(values[1] + 1) }.collect()
}

Since splitn(2, "-") returns exactly two results for any valid string_value, it would be better to assign the tuple directly to two variables first and last rather than a seemingly arbitrary-length Vec. I can't seem to do this with a tuple.
There are two instances of collect(), and I wonder if it can be reduced to one (or even zero).

As long as you want to return a `Vec`, you need at least 1 collect — hellow, Mar 08 '18 at 07:43

score 3 · Answer 1 · edited Mar 08 '18 at 13:14

3

Trivial implementation

fn parse_range(string_value: &str) -> Vec<u8> {
    let pos = string_value.find(|c| c == '-').expect("No valid string");
    let (first, second) = string_value.split_at(pos);

    let first: u8 = first.parse().expect("Not a number");
    let second: u8 = second[1..].parse().expect("Not a number");

    { first..second + 1 }.collect()
}

Playground

I would recommend returning a Result<Vec<u8>, Error> instead of panicking with expect/unwrap.

Nightly implementation

My next thought was about the second collect. Here is a code example which uses nightly code, but you won't need any collect at all.

#![feature(conservative_impl_trait, inclusive_range_syntax)]

fn parse_range(string_value: &str) -> impl Iterator<Item = u8> {
    let pos = string_value.find(|c| c == '-').expect("No valid string");
    let (first, second) = string_value.split_at(pos);

    let first: u8 = first.parse().expect("Not a number");
    let second: u8 = second[1..].parse().expect("Not a number");

    first..=second
}

fn main() {
    println!("{:?}", parse_range("3-7").collect::<Vec<u8>>());
}

edited Mar 08 '18 at 13:14

Shepmaster

388,571
95
1,107
1,366

answered Mar 08 '18 at 07:48

hellow

12,430
7
56
79

2

Wouldn't `inclusive_range_syntax` fix the overflow in `"0-255"` that the first version has? – Sebastian Redl Mar 08 '18 at 09:01
1

You could also avoid the `collect` by returning a `std::ops::Range` and not need nightly. Unfortunately you still need nightly to return `RangeInclusive`, but maybe one of these days... – trent Mar 08 '18 at 19:36
In the nightly implementation I'd rather return the `RangeInclusive` from the function and leave turning it into a vector (or treating it as iterator) to the caller. – CodesInChaos Mar 09 '18 at 12:02
@CodesInChaos that's what I did. Well... I didn't returned `RangeInclusive`, but it's the callers decision to collect the result or do something else with it. – hellow Mar 09 '18 at 12:05

Shepmaster · Answer 2 · 2018-03-08T20:49:55.930

Instead of calling collect the first time, just advance the iterator:

let mut values = string_value
    .splitn(2, "-")
    .map(|part| part.parse().unwrap());

let start = values.next().unwrap();
let end = values.next().unwrap();

Do not call .ok().unwrap() — that converts the Result with useful error information to an Option, which has no information. Just call unwrap directly on the Result.

As already mentioned, if you want to return a Vec, you'll want to call collect to create it. If you want to return an iterator, you can. It's not bad even in stable Rust:

fn parse_range(string_value: &str) -> std::ops::Range<u8> {
    let mut values = string_value
        .splitn(2, "-")
        .map(|part| part.parse().unwrap());

    let start = values.next().unwrap();
    let end = values.next().unwrap();

    start..end + 1
}

fn main() {
    assert!(parse_range("1-5").eq(1..6));
}

Sadly, inclusive ranges are not yet stable, so you'll need to continue to use +1 or switch to nightly.

Since splitn(2, "-") returns exactly two results for any valid string_value, it would be better to assign the tuple directly to two variables first and last rather than a seemingly arbitrary-length Vec. I can't seem to do this with a tuple.

This is not possible with Rust's type system. You are asking for dependent types, a way for runtime values to interact with the type system. You'd want splitn to return a (&str, &str) for a value of 2 and a (&str, &str, &str) for a value of 3. That gets even more complicated when the argument is a variable, especially when it's set at run time.

The closest workaround would be to have a runtime check that there are no more values:

assert!(values.next().is_none());

Such a check doesn't feel valuable to me.

How to translate "x-y" to vec![x, x+1, … y-1, y]?

2 Answers2

Trivial implementation

Nightly implementation