Interpreter

type Contexto = Record<string, string>;

interface Expressao {
  interpretar(ctx: Contexto): boolean;
}

// Terminal: a regra mais simples da gramatica
class Campo implements Expressao {
  constructor(
    private nome: string,
    private valor: string,
  ) {}
  interpretar(ctx: Contexto): boolean {
    return ctx[this.nome] === this.valor;
  }
}

// Nao-terminais: regras compostas por outras regras
class E implements Expressao {
  constructor(private esq: Expressao, private dir: Expressao) {}
  interpretar(ctx: Contexto): boolean {
    return this.esq.interpretar(ctx) && this.dir.interpretar(ctx);
  }
}

class Ou implements Expressao {
  constructor(private esq: Expressao, private dir: Expressao) {}
  interpretar(ctx: Contexto): boolean {
    return this.esq.interpretar(ctx) || this.dir.interpretar(ctx);
  }
}

class Nao implements Expressao {
  constructor(private dentro: Expressao) {}
  interpretar(ctx: Contexto): boolean {
    return !this.dentro.interpretar(ctx);
  }
}

// "plano = pro E (regiao = sul OU NAO(bloqueado = sim))"
const regra = new E(
  new Campo("plano", "pro"),
  new Ou(new Campo("regiao", "sul"), new Nao(new Campo("bloqueado", "sim"))),
);

console.log(regra.interpretar({ plano: "pro", regiao: "norte", bloqueado: "nao" })); // true

from abc import ABC, abstractmethod

class Expressao(ABC):
    @abstractmethod
    def interpretar(self, ctx) -> bool: ...

# Terminal: a regra mais simples da gramatica
class Campo(Expressao):
    def __init__(self, nome, valor):
        self._nome, self._valor = nome, valor
    def interpretar(self, ctx):
        return ctx.get(self._nome) == self._valor

# Nao-terminais: regras compostas por outras regras
class E(Expressao):
    def __init__(self, esq, dir):
        self._esq, self._dir = esq, dir
    def interpretar(self, ctx):
        return self._esq.interpretar(ctx) and self._dir.interpretar(ctx)

class Ou(Expressao):
    def __init__(self, esq, dir):
        self._esq, self._dir = esq, dir
    def interpretar(self, ctx):
        return self._esq.interpretar(ctx) or self._dir.interpretar(ctx)

class Nao(Expressao):
    def __init__(self, dentro):
        self._dentro = dentro
    def interpretar(self, ctx):
        return not self._dentro.interpretar(ctx)

# "plano = pro E (regiao = sul OU NAO(bloqueado = sim))"
regra = E(Campo("plano", "pro"),
          Ou(Campo("regiao", "sul"), Nao(Campo("bloqueado", "sim"))))

print(regra.interpretar({"plano": "pro", "regiao": "norte", "bloqueado": "nao"}))  # True