实现迭代器的代理方法，生命周期冲突

Question

I'm trying to implement an iterator which simply proxies the next method to another method on the struct itself.

struct Element<'a>(&'a str);

struct IterStruct<'a> {
    name: &'a str,
}

impl<'a> IterStruct<'a> {
    fn name(&mut self) -> Option<Element> {
        Some(Element(self.name))
    }
}

impl<'a> Iterator for IterStruct<'a> {
    type Item = Element<'a>;
    fn next(&mut self) -> Option<Self::Item> {
        self.name()
    }
}

I'm getting the conflicting requirements for lifetime error though:

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
  --> src/lib.rs:16:14
   |
16 |         self.name()
   |              ^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 15:5...
  --> src/lib.rs:15:5
   |
15 | /     fn next(&mut self) -> Option<Self::Item> {
16 | |         self.name()
17 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:16:9
   |
16 |         self.name()
   |         ^^^^
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 13:6...
  --> src/lib.rs:13:6
   |
13 | impl<'a> Iterator for IterStruct<'a> {
   |      ^^
   = note: ...so that the types are compatible:
           expected std::iter::Iterator
              found std::iter::Iterator

Playground

How can I resolve this?

Answer 1

One solution is to specify that name outlives the IterStruct it is contained in:

struct Element<'a>(&'a str);

struct IterStruct<'a> {
    name: &'a str,
}

impl<'a> IterStruct<'a> {
    fn name<'s>(&'s mut self) -> Option<Element<'a>>
    where
        'a: 's, // <- specify that name outlives self
    {
        Some(Element(self.name))
    }
}

impl<'a> Iterator for IterStruct<'a> {
    type Item = Element<'a>;
    fn next(&mut self) -> Option<Self::Item> {
        self.name()
    }
}

Answer 2

Well you need to give borrow checker a way to infer the lifetimes. What's essentially missing is one of the following line

impl<'a> IterStruct<'a> {
    fn name(&mut self) -> Option<Element> {
//  ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
        Some(Element(self.name))
    }
}

into fn name(&mut self) -> Option<Element<'a>> . The Rust borrow checker will take care of the rest [Playground link] .

Compiler seems smart enough to infer 'a should outlive 'self .