How to re-use a Range multiple times without cloning it?

Question

I have some working code to sum a Range and then use it again later in a for loop. Is it possible to make the code below work without having to clone the Range?

let range = 0..10;
let sum = range.clone().sum::<i8>();
println!("{}", sum);

for data in range.step_by(2).enumerate() {
   println!("{:?}", data);
}

Can you please explain in your question why you want to avoid cloning the Range? — pretzelhammer, Jun 28 '20 at 13:12
Note that `clone` is expensive only when the underlying data is large and/or heap-allocated, as is the case when cloning a large vector, which must both allocate and clone each element. But cloning a `Range`, which is basically a couple of stack (or register) allocated integers is "zero cost", meaning it costs the same as just writing the same range twice. In other words, don't be afraid to clone where needed. — user4815162342, Jun 28 '20 at 16:51

score 5 · Accepted Answer · answered Jun 28 '20 at 13:28

Range<T> is an iterator. Rust iterators are usually:

One shot. You can iterate once, and only once. Iterating modifies the iterator, and there is no way to "go back" or to reset them. If you want to iterate twice, you have to clone them, or create another iterator somehow.
Cheap. Iterators rarely store any data. In particular, Range<T> only stores its two bounds, not the entire range of numbers. 0..10 is therefore just a pair of integers, which is really cheap to clone.
Not Copy, even when their underlying data is. This is why you need the explicit clone, and this is because a Copy iterator would be unintuitive to use.

See also:

I see, on call sum its iterate once and cannot be re-use. thats why need clone there. Thanks for the info — weiz, Jun 28 '20 at 13:42

pretzelhammer · Answer 2 · 2020-06-28T14:02:06.640

Refer to @mcarton's answer for a general explanation, but if you're just learning Rust and experimenting with toy examples then simpler version of your code would be to just declare the Range twice:

fn main() {
    let sum: i32 = (0..10).sum();
    println!("{}", sum);
    
    for data in (0..10).step_by(2).enumerate() {
        println!("{:?}", data);
    }
}

If you were writing a function that accepted the Range as an argument then you would have to clone (or be creative in consolidating both loops):

fn fun(mut range: Range<i32>) {
    let sum: i32 = range.clone().sum();
    println!("{}", sum);
    
    for data in range.step_by(2).enumerate() {
        println!("{:?}", data);
    }
}

Regardless, cloning a Range is not a big deal because it's only two integers:

pub struct Range<Idx> {
    pub start: Idx,
    pub end: Idx,
}

So whether you're cloning a 0..10 or a 0..1000000 they're all the same size and the clone operation will be fast and cheap.

"the idiomatic version of your code would be to just declare the `Range` twice" I disagree completely. Repeating magical constants is never a good solution. — mcarton, Jun 28 '20 at 13:48
I think OP is just learning Rust by experimenting with toy examples. There's no actual requirement that the ranges have to be the same. I've updated my answer to make these assumptions clear. — pretzelhammer, Jun 28 '20 at 14:11

How to re-use a Range multiple times without cloning it?

2 Answers2