How to implement Iterator for boxed values? - rust

Question

I have a struct that gives numbers by method next from trait Iterator:
struct Numbers{
number: usize,
count: usize
}
impl Iterator for Numbers {
type Item = usize;
fn next(&mut self) -> Option<Self::Item> {
if self.count > 0 {
self.count -= 1;
return Some(self.number);
}
return None;
}
}
fn main(){
let numbers = Numbers{
number: 777,
count: 10
};
for n in numbers {
println!{"{:?}", n};
}
}
It's work properly with usize type.
But same code with Box type gives a compilation error:
struct Numbers{
number: Box<usize>,
count: usize
}
impl Iterator for Numbers {
type Item = Box<usize>;
fn next(&mut self) -> Option<Self::Item> {
if self.count > 0 {
self.count -= 1;
return Some(self.number);
}
return None;
}
}
fn main(){
let numbers = Numbers{
number: Box::new(777),
count: 10
};
for n in numbers {
println!{"{:?}", n};
}
}
./numbers.rs:12:25: 12:29 error: cannot move out of borrowed content
./numbers.rs:12 return Some(self.number);
How to implement Iterator for boxed values properly?

Answer 1

This comes down to Rust’s ownership model and the distinction between copy and move semantics; Box<T> has move semantics, not implementing Copy, and so return Some(self.number); would move self.number, taking ownership of it; but this is not permitted because it would require consuming self, which is only taken by mutable reference.
You have a few choices (where I write “the object with move semantics,” I mean in this specific case self.number):
Don’t return the object with move semantics, return something else with copy semantics reference, such as a reference instead of the boxed value (returning a reference will require the iterator object to be different from the object being iterated over so that you can write the lifetime in Item; thus it doesn’t apply to your specific use case) or the unboxed number.
Construct a new value to return based on the object with move semantics:
impl Iterator for Numbers {
type Item = Box<usize>;
fn next(&mut self) -> Option<Self::Item> {
if self.count > 0 {
self.count -= 1;
Some(Box::new(self.number))
} else {
None
}
}
}
Clone the object with move semantics (this is a simplified form of the second option, really):
impl Iterator for Numbers {
type Item = Box<usize>;
fn next(&mut self) -> Option<Self::Item> {
if self.count > 0 {
self.count -= 1;
Some(self.number.clone())
} else {
None
}
}
}
Construct a new value to substitute in place of the object with move semantics:
use std::mem;
impl Iterator for Numbers {
type Item = Box<usize>;
fn next(&mut self) -> Option<Self::Item> {
if self.count > 0 {
self.count -= 1;
let number = mem::replace(&mut self.number, Box::new(0));
// self.number now contains 0
Some(number)
} else {
None
}
}
}