バイナリ検索ツリーの＆mut反復子を実装する方法は？

Question

私は単純なバイナリ検索ツリーをRustに実装しました（CIS 198に従ってください）。学習のために、右端を通るイテレータをやっています。

私は、可変参照を与えるイテレータを実装できませんでした。私はたくさんの方法を試しましたが、どれもRustコンパイラでは受け入れられませんでした。私は助けを必要とする以下のコードは、1（while I made a gist with the complete code here）です：

#[derive(Debug)] 
pub struct Tree<T>(Option<Box<Node<T>>>); 

#[derive(Debug)] 
pub struct Node<T> { 
    elem: T, 
    left: Tree<T>, 
    right: Tree<T>, 
} 

// MUTABLE BORROW STRUCT 
pub struct IterMut<'a, T: 'a> { 
    next: &'a mut Tree<T>, 
} 

// MUTABLE BORROW NEXT (I'M STUCK HERE, NOTHING WORKS) 
impl<'a, T> Iterator for IterMut<'a, T> { 
    type Item = &'a mut T; 
    fn next(&mut self) -> Option<Self::Item> { 
     // 1 try: cannot infer lifetime 
     self.next.0.as_mut().map(|node| { 
      self.next = &mut node.right; 
      &mut node.elem 
     }) 

     // 2 try: node.right, node.elem does not live long enough 
     self.next.0.take().map(|node| { 
      self.next = &mut node.right; 
      &mut node.elem 
     }) 
    } 
} 

Answer 1

あなたはOption<&'a mut Node<T>>にフィールドIterMut::nextの種類を変更する必要があります。

pub struct IterMut<'a, T: 'a> { 
    next: 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> { 
     self.next.take().map(|node| { 
      self.next = node.right.0.as_mut().map(|node| &mut **node); 
      &mut node.elem 
     }) 

    } 
} 

あなたがここに再帰的なデータ構造のための可変イテレータの実装についてのより有用な情報を見つけることができます：http://cglab.ca/~abeinges/blah/too-many-lists/book/second-iter-mut.html

Answer 2

私はあなたには、いくつかの危険なコードを使用せずに2つの可変オブジェクト（Itemに1つ、self自体の1）にselfを分割することはできませんと思います。