Problems with the Visitor Pattern

[sergioantoy]

Problems: (1) the code presented to explain the Visitor Pattern is missing a test or an example of execution. (2) the type Expr in the presented code is ideal for applying the pattern, but no visitor is shown and used. (3) no compelling reason is given for the need of a visitor.

The pattern allows adding new virtual-like functions to a family of classes, without modifying the classes. This is non-trivial in languages like C++ and Java in which classes are closed. In rust adding functionality to a type (or hierarchy of types) does not require modifying the type (or the hierarchy).

Below is a definition of a simple arithmetic expression type (hierarchy) and two operations on it that are defined without modifying the type. This example suggests that the Visitor Pattern is not useful in Rust.

pub enum Expr {
    Num{val: isize},
    Add{l: Box<Expr>, r: Box<Expr>},
    Mul{l: Box<Expr>, r: Box<Expr>},
    Sub{l: Box<Expr>, r: Box<Expr>},
}

use Expr::*;

pub trait Eval {
    fn eval(&self) -> isize;
}

impl Eval for Expr {
   fn eval(&self) -> isize {
       return match self {
           Num{val} => *val,
           Add{l, r} => l.eval() + r.eval(),
           Mul{l, r} => l.eval() * r.eval(),
           Sub{l, r} => l.eval() - r.eval(),
       }
   } 
}

pub trait Pretty {
    fn pretty(&self) -> String;
}

impl Pretty for Expr {
    fn pretty(&self) -> String {
        return match self {
           Num{val} => format!("{}", *val),
           Add{l, r} => format!("({}+{})", l.pretty(), r.pretty()),
           Mul{l, r} => format!("({}*{})", l.pretty(), r.pretty()),
           Sub{l, r} => format!("({}-{})", l.pretty(), r.pretty()),
       }
   } 
}

#[cfg(test)]
mod tests {

    use super::*;

    #[test]
    fn test_eval() {
        let sample = Expr::Mul{
            l: Box::new(Expr::Num{val: 21}),
            r: Box::new(Expr::Num{val: 2}),
        };
        assert!(sample.eval()==42);
    }

    #[test]
    fn test_pretty() {
        let sample = Expr::Mul{
            l: Box::new(Expr::Num{val: 21}),
            r: Box::new(Expr::Num{val: 2}),
        };
        println!("{}", sample.pretty());
        assert!(sample.pretty()=="(21*2)");
    }

}