[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?



More information about the Rust-dev mailing list