Rust: невозможно выйти из `self`, потому что это заимствованная ошибка

Я пытаюсь написать рекурсивный метод, который добавляет элемент в дерево и возвращает узел дерева, соответствующий этому элементу.

enum BstNode {
    Node(int, ~BstNode, ~BstNode),
    Leaf
}

impl BstNode {
    fn insert<'a>(&'a mut self, item: int) -> &'a mut BstNode {
        match *self {
            Leaf => {
                *self = Node(item, ~Leaf, ~Leaf);
                self
            },
            Node(ref node_item, ref mut left, ref mut right) =>
                match item.cmp(node_item) {
                    Less => left.insert(item),
                    Equal => self,
                    Greater => right.insert(item)
                }
        }
    }
}

Меня укусила следующая ошибка:

bst.rs:19:30: 19:34 error: cannot move out of `self` because it is borrowed
bst.rs:19                     Equal => self,
                                       ^~~~
bst.rs:16:18: 16:31 note: borrow of `self#0` occurs here
bst.rs:16             Node(ref node_item, ref mut left, ref mut right) =>
                           ^~~~~~~~~~~~~

Что означает "выезд из something"? Как исправить эту ошибку?

Я использую Rust 0.10.


rust lifetime pattern-matching
person Krzysiek Goj    schedule 27.04.2014    source источник

Ответы (1)


arrow_upward
2
arrow_downward

В вашем примере node_item, left и right принадлежат переменной self. Проверщик заимствований не знает, что в ветке Equal

match item.cmp(node_item) {
    Less => left.insert(item),
    Equal => self,
    Greater => right.insert(item)
}

ни node_item, ни left, ни right не используются, но он видит, что self перемещается (вы возвращаете его), в то время как эти 3 переменные все еще заимствованы (вы все еще находитесь в лексической области соответствия, где они заимствованы). Я думаю, что это известная ошибка, что такое поведение слишком строгое, см. issue #6993.

Что касается лучшего способа исправить код, честно говоря, я не уверен. Я бы использовал совершенно другую структуру (по крайней мере, пока предыдущая ошибка не будет исправлена):

pub struct BstNode {
  item: int,
  left: Option<~BstNode>,
  right: Option<~BstNode>
}

impl BstNode {
    pub fn insert<'a>(&'a mut self, item: int) -> &'a mut BstNode {
        match item.cmp(&self.item) {
            Less => match self.left {
              Some(ref mut lnode) => lnode.insert(item),
              None => {
                self.left = Some(~BstNode {item: item, left: None, right: None});
                &mut **self.left.as_mut().unwrap()
              }
            },
            Equal => self,
            Greater => match self.right {
              Some(ref mut rnode) => rnode.insert(item),
              None => {
                self.right = Some(~BstNode {item: item, left: None, right: None});
                &mut **self.right.as_mut().unwrap()
              }
            }
        }
    }
}

Таким образом, когда вы возвращаете свой узел, у вас никогда не остается заимствованных членов.

person rca    schedule 28.04.2014
comment
Спасибо! Способ исправить мой код с сохранением структуры данных оказался таким: сопоставить Node(node_item, _, _) (обратите внимание на отсутствие ref) и извлечь левое/правое с помощью еще одного совпадения шаблона в ветвях Меньше/Больше. - person Krzysiek Goj; 29.04.2014