解释器模式用于：

把一种语言（DSL）解析成语法树，再按规则执行。

非常适合 LLM，比如：

• Prompt DSL
• Chain-of-Thought DSL
• Function Call DSL
• Workflow DSL
• Agent DSL

下面给你一个真正“解释器模式”的强例子。

---

⭐ 真·Interpreter 实现：自定义 Prompt DSL

目标：支持这样一个迷你语言：

DEFINE PERSON = "Jack"
ASK "What is PERSON doing?"
ASK "Write a poem about PERSON"

最终会发送两个 Prompt：

• What is Jack doing?
• Write a poem about Jack

---

Step 1：定义语法节点（终结符与非终结符）

class Expression:
    def interpret(self, context):
        raise NotImplementedError

---

终结符表达式：常量赋值

class DefineExpression(Expression):
    def __init__(self, variable, value):
        self.variable = variable
        self.value = value

    def interpret(self, context):
        context[self.variable] = self.value

---

终结符表达式：发起询问

class AskExpression(Expression):
    def __init__(self, message):
        self.message = message

    def interpret(self, context):
        # 替换变量
        for var, value in context.items():
            self.message = self.message.replace(var, value)
        print(">>> LLM 请求:", self.message)
        return self.message

---

非终结符表达式：语句列表

class SequenceExpression(Expression):
    def __init__(self, expressions):
        self.expressions = expressions

    def interpret(self, context):
        results = []
        for expr in self.expressions:
            res = expr.interpret(context)
            if res:
                results.append(res)
        return results

---

Step 2：解析 DSL 生成语法树（重点！）

这是真正的解释器模式核心。

def parse_script(script: str):
    expressions = []

    for line in script.splitlines():
        line = line.strip()

        if line.startswith("DEFINE"):
            _, var, _, value = line.split(maxsplit=3)
            value = value.strip('"')
            expressions.append(DefineExpression(var, value))

        elif line.startswith("ASK"):
            msg = line[4:].strip().strip('"')
            expressions.append(AskExpression(msg))

    return SequenceExpression(expressions)

---

Step 3：执行 DSL

script = """
DEFINE PERSON = "Jack"
ASK "What is PERSON doing?"
ASK "Write a poem about PERSON"
"""

tree = parse_script(script)
context = {}
tree.interpret(context)

输出：

>>> LLM 请求: What is Jack doing?
>>> LLM 请求: Write a poem about Jack

---

⭐ 真正体现 Interpreter 模式的点

• 有 语言
• 有 语法规则
• 有 语法树（AST）
• 有 解释执行逻辑
• 各种表达式（Define/Ask/Sequence）对应 终结符 / 非终结符
• 无需动客户端

这就是 100% 正宗的 解释器模式。