Conception de structures de données pour un évaluateur paresseux enfant-premier qui imprime la procédure

Question

Je construis un évaluateur d'expressions paresseux like Python's en utilisant un plugin de compilateur.

Je veux imprimer un journal comme:

assert (left == vec![1, 2, 3, 4]) 
assert (vec![1, 2, 3, 4] == vec![1, 2, 3, 4]); 

et essayé:

// crate rt 
pub struct Expr<T, F: FnMut() -> T> { 
    // I noticed that this must be changed to fn with format!() call, to 
    // support updating child. 
    src: &'static str, // holds value 
} 
pub trait EvalTo: Display { 
    /// Type of expression 
    type Type; 

    /// Returns Some(val) when done 
    /// Accepts &mut self as it might be called many time. 
    fn eval_one_level(&mut self) -> Some<T>; 
} 

impl<T, F> EvalTo for Expr<T, F> { 
    type Type = T; 
} 
/// Prints source before evaluation, (it must be changed) 
/// and value after evaluation. 
impl<T, F> Display for Expr<T, F> {} 

avec le plugin compilateur pour les créer sur la compilation. Mais quand je fais

let left = vec![1, 2, 3, 4]; 
lazy_expr!(left == vec![1, 2, 3, 4]); 

Il se développe pour

::rt::binary({ 
    ::rt::Expr::wrap(::rt::Source{ expr: "left" }, || Some(left)) 
}, { 
    ::rt::Expr::wrap(::rt::Source{ expr: "vec!(1, 2, 3, 4)" }, 
    || vec![1, 2, 3, 4]) 
}).eq() 

et le compilateur ne l'aime pas. Il est dit cannot move out of captured outer variable in an `FnMut` closure.

Je ne peux donc pas utiliser FnMut, mais il doit être appelé plusieurs fois et doit pouvoir modifier l'expression enfant.

Existe-t-il une structure de données permettant de capturer des variables locales, mais pouvant être appelée plusieurs fois avec &mut self? Dois-je utiliser FnOnce(&mut Context)?

Answer 1

Je n'en ai plus besoin, parce que j'ai utilisé un autre apporach. Mais pour être complet, vous pouvez définir un trait avec (&mut self) et utiliser [std::mem::replace] [] pour obtenir la valeur possédée, et Option a une méthode auxiliaire nommée.

Pour qui veut construire un moteur évaluable paresseux avec un plugin de compilateur, did some more on compile time.

Il appelle

fn capture<T :?Sized>(&mut self, expr: &'static str, val: &T) 

de code généré comme

ctx.capture("f()", &_var_of_expr) 

si le contexte peut écrire l'expression et de la valeur avec elle.