Disclaimer:
I understand that Rust used to use internal iteration in for-loops, but that
was before I became interested in this language, so my perspective on this
matter may not match yours.
I suppose internal iteration support in for-loops should be preferably
implemented through the use of resumable functions. But since it may take a
long time until we get resumable functions, I wonder if we should add the
support for internal iteration in for-loops through the old fashion way:
// in std::iter
pub enum LoopControl<T> {
Continue,
Break,
Return(T)
}
pub trait InternalIterator<Elem, Ret> {
fn iter(&self, func: |&Elem| -> LoopControl<Ret>) -> LoopControl<Ret>;
}
// in std::prelude
pub use std::iter::{LoopControl, Continue, Break, Return, InternalIterator};
// in user code
struct Tree {
data: int,
left: Option<Box<Tree>>,
right: Option<Box<Tree>>
}
impl<Ret> InternalIterator<int, Ret> for Tree {
fn iter(&self, func: |&int| -> LoopControl<Ret>) -> LoopControl<Ret> {
match func(&self.data) {
Continue => {
match self.left {
Some(box ref left_branch) => {
match left_branch.iter(|n| func(n)) {
Continue => {}
Break => { return Break; }
Return(x) => { return Return(x); }
}
}
None => {}
}
match self.right {
Some(box ref right_branch) => {
match right_branch.iter(|n| func(n)) {
Continue => {}
Break => { return Break; }
Return(x) => { return Return(x); }
}
}
None => {}
}
}
Break => { return Break; }
Return(x) => { return Return(x); }
}
return Continue;
}
}
fn foo() -> char {
let mut tree = Tree { data: 0, left: None, right: None };
tree.left = Some(box Tree { data: 1, left: None, right: None });
tree.right = Some(box Tree { data: 2, left: None, right: None });
tree.right.get_mut_ref().left = Some(box Tree { data: 3, left: None, right:
None });
for e in tree {
print!("{} ", e);
if *e == 11 {
continue;
}
if *e == 22 {
break;
}
if *e == 3 {
return 'D';
}
}
// Since `tree` doesn't implement `Iterator`, the compiler
// checks if it implements `InternalIterator`, and uses that.
// The for-loop above would be lowered by the compiler
// to the following match expression:
match tree.iter(|e: &int| -> LoopControl<char> {
print!("{} ", e);
if *e == 11 {
return Continue;
}
if *e == 22 {
return Break;
}
if *e == 3 {
return Return('D');
}
return Continue;
}) {
Continue => {}
Break => {}
Return(x) => { return x; }
}
return '?';
}
fn main() {
print!("- {}", foo());
}
// The program output: 0 1 2 3 - D
_______________________________________________
Rust-dev mailing list
[email protected]
https://mail.mozilla.org/listinfo/rust-dev
