从零构建编程语言：PL Zoo 迷你语言实现全指南

从零构建编程语言：PL Zoo 迷你语言实现全指南

为什么选择 PL Zoo？

你是否曾好奇主流编程语言背后的实现原理？是否想亲手构建一门属于自己的语言却不知从何下手？PL Zoo（Programming Languages Zoo）项目为你提供了完美的起点。作为一个包含多种迷你编程语言实现的开源项目，它展示了语言设计中的核心技术，从词法分析到类型检查，从解释执行到编译优化，覆盖了现代编程语言实现的方方面面。

本文将带你深入探索 PL Zoo 的架构设计与核心功能，通过实际案例掌握语言实现的关键技术，读完后你将能够：

• 理解迷你语言的完整实现流程
• 掌握词法分析器（Lexer）与语法分析器（Parser）的构建方法
• 实现基础的类型检查与错误处理机制
• 构建解释器或编译器执行自定义语言
• 基于 PL Zoo 扩展开发新的语言特性

PL Zoo 项目架构概览

PL Zoo 采用模块化设计，每个子目录对应一种迷你语言实现，整体结构清晰且易于扩展。项目主要包含以下核心组件：

plzoo/
├── README.md               # 项目总览与安装指南
├── dune-project            # OCaml 构建系统配置
└── src/                    # 语言实现目录
    ├── calc/               # 算术计算器语言
    ├── calc_var/           # 带变量的计算器语言
    ├── lambda/             # λ演算实现
    ├── miniml/             # 迷你ML语言（函数式）
    ├── minihaskell/        # 迷你Haskell语言
    ├── comm/               # 命令式语言
    └── ...                 # 其他语言实现

每个语言模块遵循统一的实现模式，包含以下关键文件：

• lexer.mll: 使用 OCaml Lex 定义的词法分析器
• parser.mly: 使用 OCaml Yacc 定义的语法分析器
• syntax.ml: 抽象语法树（AST）定义
• eval.ml/interpret.ml: 解释器实现
• type_check.ml: 类型检查器（部分语言）
• example.*: 示例程序文件

快速上手：从安装到运行

环境准备

PL Zoo 基于 OCaml 语言开发，需先安装以下依赖：

# Ubuntu/Debian
sudo apt-get install ocaml ocaml-native-compilers opam
opam init
opam install dune menhir

# 克隆项目仓库
git clone https://gitcode.com/gh_mirrors/pl/plzoo
cd plzoo

构建与运行

使用 Dune 构建系统编译整个项目：

# 编译所有语言实现
dune build

# 运行计算器语言示例
dune exec src/calc/calc.exe

成功运行后将进入交互式环境：

calc -- programming languages zoo
Type Ctrl-D to exit
calc> 2+2*3
8
calc> (10-4)/(2+1)
2
calc> 10/(5-5)
Error: division by zero

深入核心：迷你语言实现全解析

案例一：calc 语言——算术表达式解析器

calc 是 PL Zoo 中最简单的语言之一，实现了基本算术运算。我们以它为例，解析迷你语言的完整实现流程。

1. 词法分析器（Lexer）实现

lexer.mll 文件定义了如何将输入字符流转换为标记（Tokens）：

{
  open Parser
  exception Eof
}

rule token = parse
  | [' ' '\t' '\n'] { token lexbuf }  (* 忽略空白字符 *)
  | ['0'-'9']+      { INT (int_of_string (Lexing.lexeme lexbuf)) }
  | '+'             { PLUS }
  | '-'             { MINUS }
  | '*'             { MUL }
  | '/'             { DIV }
  | '('             { LPAREN }
  | ')'             { RPAREN }
  | eof             { raise Eof }

这段代码定义了计算器语言的所有标记类型：整数(INT)、运算符(PLUS/MINUS等)和括号。词法分析器会忽略空白字符，将数字转换为整数类型，并为运算符返回相应标记。

2. 语法分析器（Parser）实现

parser.mly 文件使用上下文无关文法定义表达式语法：

%{
  open Syntax
%}

%token <int> INT
%token PLUS MINUS MUL DIV LPAREN RPAREN EOF
%left PLUS MINUS        /* 优先级：加法和减法最低 */
%left MUL DIV           /* 乘法和除法优先级更高 */
%nonassoc UMINUS        /* 负号是右结合的前缀运算符 */

%start main
%type <Syntax.expr> main

%%

main:
  expr EOF { $1 }

expr:
  | INT                { Int $1 }
  | LPAREN expr RPAREN { $2 }
  | expr PLUS expr     { Add ($1, $3) }
  | expr MINUS expr    { Sub ($1, $3) }
  | expr MUL expr      { Mul ($1, $3) }
  | expr DIV expr      { Div ($1, $3) }
  | MINUS expr %prec UMINUS { Neg $2 }

通过定义运算符优先级（MUL/DIV > PLUS/MINUS）和结合性，语法分析器能够正确解析复杂表达式，生成对应的抽象语法树（AST）。

3. 抽象语法树（AST）与解释器

Syntax.ml 定义了表达式的抽象表示：

type expr =
  | Int of int
  | Add of expr * expr
  | Sub of expr * expr
  | Mul of expr * expr
  | Div of expr * expr
  | Neg of expr

eval.ml 实现了解释器，递归计算表达式值：

open Syntax

let rec eval = function
  | Int n -> n
  | Add (e1, e2) -> eval e1 + eval e2
  | Sub (e1, e2) -> eval e1 - eval e2
  | Mul (e1, e2) -> eval e1 * eval e2
  | Div (e1, e2) ->
      let v2 = eval e2 in
      if v2 = 0 then raise (Failure "division by zero")
      else eval e1 / v2
  | Neg e -> -eval e

案例二：MiniML 语言——类型系统与函数式编程

MiniML 展示了函数式语言的核心特性：类型推断、递归函数和高阶函数。其类型检查器实现了 Hindley-Milner 类型系统，能够自动推断表达式类型。

类型系统实现

type_check.ml 中定义了类型表示与类型检查逻辑：

type typ =
  | TInt
  | TBool
  | TArrow of typ * typ  (* 函数类型 t1 -> t2 *)

let rec string_of_typ = function
  | TInt -> "int"
  | TBool -> "bool"
  | TArrow (t1, t2) -> "(" ^ string_of_typ t1 ^ " -> " ^ string_of_typ t2 ^ ")"

类型检查函数通过环境（context）跟踪变量类型：

let rec type_check ctx = function
  | Syntax.Int _ -> TInt
  | Syntax.Bool _ -> TBool
  | Syntax.Var x -> 
      (try List.assoc x ctx with Not_found -> 
        raise (Failure ("Unbound variable: " ^ x)))
  | Syntax.Abs (x, t, e) ->
      let ctx' = (x, t) :: ctx in
      let t' = type_check ctx' e in
      TArrow (t, t')
  | Syntax.App (e1, e2) ->
      let t1 = type_check ctx e1 in
      let t2 = type_check ctx e2 in
      (match t1 with
       | TArrow (t11, t12) when t11 = t2 -> t12
       | TArrow (t11, _) -> 
           raise (Failure ("Type mismatch: expected " ^ string_of_typ t11 ^ 
                          " but got " ^ string_of_typ t2))
       | _ -> raise (Failure "Expected function type"))
  (* 其他表达式的类型检查... *)

递归函数定义与使用

MiniML 支持递归函数定义，以下是阶乘函数的实现示例：

(* example.miniml *)
let fact = fun f (n : int) : int is 
  if n = 0 then 1 else n * f (n-1) ;;

fact 10 ;;  (* 计算结果: 3628800 *)

这个递归定义通过将函数自身作为参数传递（fun f ...）实现递归，类型检查器能够正确推断其类型为 int -> int。

核心技术解析：语言实现关键组件

1. 词法分析与语法分析

词法分析将源代码字符流转换为有意义的标记（tokens），如关键字、标识符、常量等。PL Zoo 使用 OCaml Lex 工具生成词法分析器，通过正则表达式定义标记模式。

语法分析基于上下文无关文法将标记流转换为抽象语法树（AST）。PL Zoo 使用 OCaml Yacc（Menhir）工具，通过产生式规则定义语法结构，并处理运算符优先级与结合性。

2. 解释执行与编译

PL Zoo 中的语言实现采用两种执行策略：

解释执行：直接遍历 AST 并计算结果，适用于快速原型开发。如 calc 和 lambda 语言：

编译执行：将 AST 转换为低级中间表示（IR）或机器码，如 comm 和 miniml 语言实现了简单的栈式虚拟机：

(* miniml/machine.ml 中的虚拟机定义 *)
type instruction =
  | Push of int
  | Add
  | Sub
  | Mul
  | ... (* 其他指令 *)

type stack = int list
type state = { stack : stack; pc : int }

let step state =
  let instr = state.code.(state.pc) in
  match instr with
  | Push n -> { state with stack = n :: state.stack; pc = state.pc + 1 }
  | Add -> 
      let a :: b :: rest = state.stack in
      { state with stack = (a + b) :: rest; pc = state.pc + 1 }
  (* 其他指令处理... *)

3. 类型系统与错误处理

高级语言实现包含类型检查器，确保程序的类型安全性。PL Zoo 展示了多种类型系统实现：

• 简单类型系统：如 calc_var 中的变量类型检查
• ** Hindley-Milner 类型系统**：如 miniml 和 minihaskell 中的类型推断
• 依赖类型：部分高级语言实现中的探索性特性

错误处理机制通过清晰的错误消息提升用户体验：

(* message.ml 中的错误报告函数 *)
let error pos msg =
  Printf.eprintf "Error at %s: %s\n" (position_to_string pos) msg;
  exit 1

实践指南：扩展与定制

添加新的语言特性

以 calc 语言为例，添加模运算（%）支持的步骤：

1. 扩展词法分析器：在 lexer.mll 中添加模运算符标记

| "%"             { MOD }

2. 扩展语法分析器：在 parser.mly 中添加模运算产生式

%left PLUS MINUS MOD
...
| expr MOD expr     { Mod ($1, $3) }

3. 扩展 AST 定义：在 syntax.ml 中添加 Mod 构造器

type expr =
  | ... (* 现有构造器 *)
  | Mod of expr * expr

4. 扩展解释器：在 eval.ml 中添加模运算求值逻辑

| Mod (e1, e2) ->
    let v1 = eval e1 and v2 = eval e2 in
    if v2 = 0 then raise (Failure "mod by zero")
    else v1 mod v2

构建自定义语言

基于 PL Zoo 构建新语言的推荐步骤：

1. 定义语言特性：确定核心语法、类型系统和执行模型
2. 实现基础组件：先完成词法分析器和语法分析器
3. 构建 AST 表示：设计适合语言特性的抽象语法树
4. 实现解释器：从简单求值开始，逐步添加功能
5. 添加类型检查：实现类型系统确保程序正确性
6. 优化与扩展：添加错误处理、标准库和高级特性

项目应用场景与学习路径

教学与学习工具

PL Zoo 是理解编程语言理论的绝佳实践资源，适合以下学习场景：

• 计算机科学课程中的编译器/解释器教学
• 编程语言理论自学项目
• 研究生阶段的语言设计研究

学习路径建议

针对不同基础的学习者，推荐以下学习路径：

入门级（无编译器经验）：

1. calc → calc_var → comm：理解基本表达式解析与执行
2. lambda：学习 λ演算基础与函数式编程思想
3. miniml：掌握类型系统与函数式语言实现

进阶级（有一定编译器基础）：

1. minihaskell → levy：学习高级类型系统
2. miniml_error：研究错误处理机制
3. poly：探索多态与类型推断高级特性

总结与展望

PL Zoo 提供了从简单到复杂的编程语言实现案例，涵盖了现代语言设计的核心技术。通过学习这些迷你语言，你不仅能理解编程语言的工作原理，还能掌握实现自定义语言的关键技能。

未来扩展方向：

• 添加 JIT 编译支持提升执行效率
• 实现垃圾回收机制支持复杂数据结构
• 开发图形化 IDE 提升开发体验
• 扩展标准库丰富语言功能

无论你是编程语言爱好者、编译器开发者，还是计算机科学学生，PL Zoo 都为你打开了探索编程语言设计与实现的大门。现在就克隆项目，动手实践，开启你的语言开发之旅吧！