Rust: error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements

Question

This is the minimal code:

struct Node<T> {
    item: T,
    next: Link<T>,
}

type Link<T> = Option<Box<Node<T>>>;

pub struct IterMut<'a, T>(&'a mut Link<T>);

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
        self.0.as_mut().map(|boxed_node| {
            self.0 = &mut boxed_node.next;
            &mut boxed_node.item
        })
    }
}

As far as I understand, there should be no problem. I have done a lot of searching, but no way.

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
  --> src/lib.rs:13:16
   |
13 |         self.0.as_mut().map(|boxed_node| {
   |                ^^^^^^
   |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the method body at 12:5...
  --> src/lib.rs:12:5
   |
12 | /     fn next(&mut self) -> Option<Self::Item> {
13 | |         self.0.as_mut().map(|boxed_node| {
14 | |             self.0 = &mut boxed_node.next;
15 | |             &mut boxed_node.item
16 | |         })
17 | |     }
   | |_____^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:13:9
   |
13 |         self.0.as_mut().map(|boxed_node| {
   |         ^^^^^^
note: but, the lifetime must be valid for the lifetime 'a as defined on the impl at 10:6...
  --> src/lib.rs:10:6
   |
10 | impl<'a, T> Iterator for IterMut<'a, T> {
   |      ^^
note: ...so that reference does not outlive borrowed content
  --> src/lib.rs:14:22
   |
14 |             self.0 = &mut boxed_node.next;
   |                      ^^^^^^^^^^^^^^^^^^^^

Answer 1

We can rewrite your code as:

struct Node<T> {
    item: T,
    next: Link<T>,
}

type Link<T> = Option<Box<Node<T>>>;

pub struct IterMut<'a, T>(&'a mut Link<T>);

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(boxed_node) = self.0 {
            self.0 = &mut boxed_node.next;
            Some(&mut boxed_node.item)
        }
        else {
            None
        }
    }
}

You can see that boxed_node life end at the end of the function so you can't return a reference link to it.

The solution is to take a reference of the box and not a reference to the option:

struct Node<T> {
    item: T,
    next: Link<T>,
}

type Link<T> = Option<Box<Node<T>>>;

pub struct IterMut<'a, T>(Option<&'a mut Box<Node<T>>>);

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(boxed_node) = self.0.take() {
            self.0 = boxed_node.next.as_mut();
            Some(&mut boxed_node.item)
        }
        else {
            None
        }
    }
}

You can also remove the Box :

struct Node<T> {
    item: T,
    next: Link<T>,
}

type Link<T> = Option<Box<Node<T>>>;

pub struct IterMut<'a, T>(Option<&'a mut Node<T>>);

impl<'a, T> Iterator for IterMut<'a, T> {
    type Item = &'a mut T;
    fn next(&mut self) -> Option<Self::Item> {
        if let Some(boxed_node) = self.0.take() {
            self.0 = boxed_node.next.as_mut().map(AsMut::as_mut);
            Some(&mut boxed_node.item)
        }
        else {
            None
        }
    }
}