David's questions

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?

Então eu tenho essa situação , onde Rust não pode inferir os argumentos de tipo genérico para uma função, que usa o opcional Fn como parâmetro. Ao passar Nonepara ele, parece que os argumentos do tipo genérico estão obsoletos, mas Rust precisa saber seus valores para compilar e não sei o que dizer a ele. Eu tentei foo::<(), ()>(calculation_result, None), mas isso não funciona.

Alguém sabe como posso chamar essa foofunção ao passar Noneem vez de fechar ela? Existe um tipo fictício que eu possa especificar ou algo assim?