Início / coding / Perguntas / 78339561
Accepted
David
Asked: 2024-04-17 16:41:55 +0800 CST

Não consigo emprestar *self como imutável, mas não consigo encontrar uma maneira de contornar

  • 772

Então eu tenho o erro acima na linha 17, que eu entendo, mas não encontro uma boa maneira de contornar:

struct Node {
    node_type: NodeType
}

enum NodeType {
    Inner([Box<Node>; 16]),
    Leaf(Vec<usize>)
}

impl Node {
    fn foo(&mut self) {
        match &mut self.node_type {
            NodeType::Leaf(_content) => {
                // Mutate content
            },
            NodeType::Inner(children) => {
                let index = self.compute_index();
                let child = &mut children[index];
                child.foo();
            }
        }
    }

    fn compute_index(&self) -> usize {
        // compute something
        0
    }
}

Parque infantil

Preciso selfser mutável, para alterar seu conteúdo no Leafcaso. Eu poderia copiar o código compute_index()para minha foo()função, mas isso tornaria a foo()função desnecessariamente longa e o código dentro dela compute_index()pareceria uma unidade semântica separada por si só.

Eu também poderia mover a chamada para compute_index()cima da matchinstrução, mas não preciso executá-la em todos os braços de correspondência, então isso causaria cálculos desnecessários nesse caso e também não parece certo.

Pensei nisso por um bom tempo, mas não consigo descobrir uma maneira de me livrar desse erro sem tornar meu código ruim. Alguém tem idéias sobre como se livrar do erro sem tornar o código ruim?

rust

1 respostas

  1. Best Answer

    Você pode embaralhar as coisas para calcular o índice antes de adquirir um empréstimo mutável?

    impl Node {
    fn foo(&mut self) {
        if let NodeType::Leaf(_content) = &mut self.node_type {
            // Mutate content
            _content.push(42);
        } else {
            let index = self.compute_index();
            if let NodeType::Inner(children) = &mut self.node_type {
                let child = &mut children[index];
                child.foo();
            }
        }
    }

    fn compute_index(&self) -> usize {
        // compute something
        0
    }
}
    • 1

relate perguntas