1
// 第一次分派：运行时根据 receiver 的实际类型选择 accept 的实现
2
expr.accept(visitor);
3
// NumberNode.accept 中：visitor.visit(this);
4
// 第二次分派：运行时根据 this 的实际类型选择 visit 的重载

1
// Rust 的 enum + match：标签联合体风格
2
enum Expr {
3
    Number(f64),
4
    Add(Box<Expr>, Box<Expr>),
5
    Mul(Box<Expr>, Box<Expr>),
6
}
7

8
// 加操作：必须修改所有 match
9
fn eval(e: &Expr) -> f64 {
10
    match e {
11
        Expr::Number(n) => *n,
12
        Expr::Add(l, r) => eval(l) + eval(r),
13
        Expr::Mul(l, r) => eval(l) * eval(r),
14
    }
15
}
16

17
// 加类型：在 enum 里加一个变体，编译器会提示所有 match 需要更新

1
// Expr 是 AST 节点的接口
2
type Expr interface{ exprNode() }
3

4
type NumberExpr struct{ Value float64 }
5
type AddExpr struct{ Left, Right Expr }
6
type MulExpr struct{ Left, Right Expr }
7

8
func (NumberExpr) exprNode() {}
9
func (AddExpr)    exprNode() {}
10
func (MulExpr)    exprNode() {}
11

12
// ExprVisitor 定义对每种节点的操作
13
type ExprVisitor interface {
14
  VisitNumber(n NumberExpr) float64
15
  VisitAdd(e AddExpr) float64
16
  VisitMul(e MulExpr) float64
17
}
18

19
// Visit 根据节点类型分发到访问者的对应方法
20
func Visit(e Expr, v ExprVisitor) float64 {
21
  switch n := e.(type) {
22
  case NumberExpr:
23
    return v.VisitNumber(n)
24
  case AddExpr:
25
    return v.VisitAdd(n)
26
  case MulExpr:
27
    return v.VisitMul(n)
28
  default:
29
    panic("unknown node type")
30
  }
31
}
32

33
// EvalVisitor 求值访问者
34
type EvalVisitor struct{}
35

36
func (EvalVisitor) VisitNumber(n NumberExpr) float64 { return n.Value }
37
func (EvalVisitor) VisitAdd(e AddExpr) float64 {
38
  return Visit(e.Left, EvalVisitor{}) + Visit(e.Right, EvalVisitor{})
39
}
40
func (EvalVisitor) VisitMul(e MulExpr) float64 {
41
  return Visit(e.Left, EvalVisitor{}) * Visit(e.Right, EvalVisitor{})
42
}
43

44
// PrintVisitor 打印访问者——新增操作，零修改 AST
45
type PrintVisitor struct{}
46

47
func (PrintVisitor) VisitNumber(n NumberExpr) float64 {
48
  fmt.Printf("%g", n.Value)
49
  return n.Value // 返回值仅用于满足接口，实际副作用在打印
50
}
51
func (PrintVisitor) VisitAdd(e AddExpr) float64 {
52
  fmt.Print("(")
53
  Visit(e.Left, PrintVisitor{})
54
  fmt.Print(" + ")
55
  Visit(e.Right, PrintVisitor{})
56
  fmt.Print(")")
57
  return 0
58
}
59
func (PrintVisitor) VisitMul(e MulExpr) float64 {
60
  fmt.Print("(")
61
  Visit(e.Left, PrintVisitor{})
62
  fmt.Print(" * ")
63
  Visit(e.Right, PrintVisitor{})
64
  fmt.Print(")")
65
  return 0
66
}

1
// 用可辨识联合定义 AST 节点
2
type Expr =
3
  | { type: 'number'; value: number }
4
  | { type: 'add'; left: Expr; right: Expr }
5
  | { type: 'multiply'; left: Expr; right: Expr };
6

7
// 访问者接口：每种节点类型一个方法
8
interface ExprVisitor<T> {
9
  visitNumber: (value: number) => T;
10
  visitAdd: (left: Expr, right: Expr) => T;
11
  visitMultiply: (left: Expr, right: Expr) => T;
12
}
13

14
// 分发函数：根据节点类型调用对应方法
15
function visit<T>(expr: Expr, v: ExprVisitor<T>): T {
16
  switch (expr.type) {
17
    case 'number':   return v.visitNumber(expr.value);
18
    case 'add':      return v.visitAdd(expr.left, expr.right);
19
    case 'multiply': return v.visitMultiply(expr.left, expr.right);
20
  }
21
}
22

23
// 求值访问者——零修改 AST 结构
24
const evalVisitor: ExprVisitor<number> = {
25
  visitNumber: (n) => n,
26
  visitAdd: (l, r) => visit(l, evalVisitor) + visit(r, evalVisitor),
27
  visitMultiply: (l, r) => visit(l, evalVisitor) * visit(r, evalVisitor),
28
};
29

30
// 打印访问者——新增操作，不改已有代码
31
const printVisitor: ExprVisitor<string> = {
32
  visitNumber: (n) => String(n),
33
  visitAdd: (l, r) => `(${visit(l, printVisitor)} + ${visit(r, printVisitor)})`,
34
  visitMultiply: (l, r) => `(${visit(l, printVisitor)} * ${visit(r, printVisitor)})`,
35
};