Visitor

interface Visitante<T> {
  visitarNumero(n: Numero): T;
  visitarSoma(s: Soma): T;
}

interface No {
  aceitar<T>(v: Visitante<T>): T;
}

class Numero implements No {
  constructor(readonly valor: number) {}
  // duplo despacho: o no sabe QUAL metodo do visitante chamar
  aceitar<T>(v: Visitante<T>): T {
    return v.visitarNumero(this);
  }
}

class Soma implements No {
  constructor(readonly esq: No, readonly dir: No) {}
  aceitar<T>(v: Visitante<T>): T {
    return v.visitarSoma(this);
  }
}

// Operacao 1: calcular — nenhuma mudanca nas classes de no
class Avaliador implements Visitante<number> {
  visitarNumero(n: Numero): number {
    return n.valor;
  }
  visitarSoma(s: Soma): number {
    return s.esq.aceitar(this) + s.dir.aceitar(this);
  }
}

// Operacao 2: imprimir — de novo, sem tocar nos nos
class Impressor implements Visitante<string> {
  visitarNumero(n: Numero): string {
    return String(n.valor);
  }
  visitarSoma(s: Soma): string {
    return `(${s.esq.aceitar(this)} + ${s.dir.aceitar(this)})`;
  }
}

const expr = new Soma(new Numero(1), new Soma(new Numero(2), new Numero(3)));
console.log(expr.aceitar(new Impressor())); // (1 + (2 + 3))
console.log(expr.aceitar(new Avaliador())); // 6

from abc import ABC, abstractmethod

class No(ABC):
    @abstractmethod
    def aceitar(self, v): ...

class Numero(No):
    def __init__(self, valor):
        self.valor = valor
    # duplo despacho: o no sabe QUAL metodo chamar
    def aceitar(self, v):
        return v.visitar_numero(self)

class Soma(No):
    def __init__(self, esq, dir):
        self.esq, self.dir = esq, dir
    def aceitar(self, v):
        return v.visitar_soma(self)

# Operacao 1: calcular — sem tocar nas classes de no
class Avaliador:
    def visitar_numero(self, n):
        return n.valor
    def visitar_soma(self, s):
        return s.esq.aceitar(self) + s.dir.aceitar(self)

# Operacao 2: imprimir — de novo, sem tocar nos nos
class Impressor:
    def visitar_numero(self, n):
        return str(n.valor)
    def visitar_soma(self, s):
        return f"({s.esq.aceitar(self)} + {s.dir.aceitar(self)})"

expr = Soma(Numero(1), Soma(Numero(2), Numero(3)))
print(expr.aceitar(Impressor()))  # (1 + (2 + 3))
print(expr.aceitar(Avaliador()))  # 6