[rust-dev] Lifetimes and iterators

Michael Neumann mneumann at ntecs.de
Thu Jun 5 05:52:04 PDT 2014


Hi all,

I want to implement an iterator that returns a reference into the
iterator struct from the next() call.

Usually I'd write something like:

     fn next<'a>(&'a mut self) -> Option<&'a ...>

but this breaks the Iterator<T> trait. I now have the following code
that works, but I am unsure if it is correct or not.

     use std::mem::transmute; // std::cast::transmute

     struct Iter {
       current: uint
     }

     impl<'a> Iterator<&'a uint> for Iter {
       fn next(&mut self) -> Option<&'a uint> {
	Some(unsafe { transmute(&self.current) } )
       }
     }

     fn main() {
       let mut iter = Iter { current: 2 };
       for &i in iter {
	println!("{}", i);
       }
     }

Actually what I want is to declare that 'a (&self.current) is of shorter
or equal lifetime than &self, but I don't know how.

I found out that my code is of course wrong, as the following code
produces a memory protection fault.

     use std::mem::transmute;

     struct Iter { current: ~str }

     impl<'a> Iterator<&'a ~str> for Iter {
       fn next(&mut self) -> Option<&'a ~str> {
	Some(unsafe { transmute(&self.current) } )
       }
     }

     fn foo<'a>() -> &'a ~str {
       let mut iter = Iter { current: "hello".to_owned() };
       return iter.next().unwrap();
     }

     fn main() {
       println!("{}", foo());
     }

Any hints?

Regards,

   Michael


More information about the Rust-dev mailing list