用 Rust 实现 Lisp 解释器

  • 深度参考:https://stopachka.essay.dev/post/5/risp-in-rust-lisp
  • 本文作者:suhanyujie
  • 文章来自:https://github.com/suhanyujie/rust-cookbook-note
  • ps:水平有限,翻译不当之处,还请指正,谢谢!

前言

一段时间没有写 Rust 了,感觉有些生疏了,打算找个 Rust 小项目复习一下。在芽之家博客看到了这个博文,讲的是用 Rust 实现 lisp。有感兴趣的同学,可以一起看看。

作者介绍到,这是他的第一个练手项目,有些地方可能会实现的不是很好,但我觉得也是很有参考价值的,尤其是对于我这样的 Rust 新手。此外,作者还提到了另一篇 python 实现 lisp,这应该也是参考资料之一。

Lisp

在开始前,我们需要了解一些关于 lisp 的背景知识。Lisp 是一种高阶编程语言,在其基础上演变出了很多中方言,如:Scheme、Common Lisp 等。查阅了下百度百科,其描述可读性不强,建议阅读维基百科的描述,或者这个 Lisp 教程

在实现一个 Lisp(子集)的解析器之前,先要了解 Lisp 的语法规则。如果你想大概了解一下它的语法和简单使用,可以自己在本地安装一个环境,并尝试。这里以 Ubuntu 20.04 为例。可通过以下命令安装一个 common lisp 的实现 —— sbcl,用于熟悉 lisp:

sudo apt-get install sbcl

然后,在命令行中输入 sbcl,即可进入它的交互式命令行:

$ sbcl This is SBCL 2.0.1.debian, an implementation of ANSI Common Lisp. More information about SBCL is available at <http://www.sbcl.org/>. SBCL is free software, provided as is, with absolutely no warranty. It is mostly in the public domain; some portions are provided under BSD-style licenses. See the CREDITS and COPYING files in the distribution for more information.

输入一个加法运算试一试:

$ * (+ 1 2) 3

可以看到,能得到计算后地结果 —— 3。

关于更多关于 Lisp 的语法在这里就不详细说明了,可以参考这个教程进行进一步学习。

Lisp 的算术运算

为了能尽快地实现目标,我们只是简单地实现一个类似于计算器的运算功能,别看只是一个小小的计算器,但也包含了很多的基础知识。

在开始之前,我们先确定好最终的目标,我们最终实现的效果如下:

(+ 10 5) //=> 15 (- 10 5) //=> 5

输入简单的 lisp 程序,就能输出对应的计算结果。在开始之前,先介绍一下我们的程序执行,所经历的大体过程:

程序 -> parse(解析) -> 抽象语法树 -> eval(执行) -> 结果

这个过程中的 parse 和 eval 就是我们要实现的功能。比如下面这个程序示例:

$ (+ 1 2) 3 $ (* 2 3) 6

换句话说,就是我们需要将我们输入的源代码解析转换成语法树,然后执行语法树就能得到我们想要的结果。而源码中,我们只需有三类输入:

  • 符号
  • 数值
  • 列表

将其用 Rust 枚举类型表示,如下:

#![allow(unused)] fn main() { #[derive(Clone)] enum RispExp { Symbol(String), Number(f64), List(Vec<RispExp>), } }

你可能有些疑惑,没关系,我们继续向后看。

在解析源码时,我们会遇到错误,因此需要定义错误类型:

enum RispErr { Reason(String), }

如果你想定义更健壮、好用的错误类型,可以参考这个。但这里,为了简化实现,我们只是将错误类型定义成一个枚举变体 Reason(String),一旦遇到异常,我们将异常信息装入其中,返回给调用方即可。

我们还需要一个作用域类型,用它来存储定义的变量、内置函数等。

#![allow(unused)] fn main() { #[derive(Clone)] struct RispEnv { data: HashMap<String, RispExp>, } }

解析

根据前面的过程描述,我们要将源码解析成语法树,也就是 RispExp 的表示形式。这样做之前,我们需要将源码解析成一个一个 token。

比如我们的输入是 (+ 10 5),将其 token 化的结果是 ["(", "+", "10", "5", ")"]。使用 Rust 实现如下:

#![allow(unused)] fn main() { fn tokenize(expr: String) -> Vec<String> { expr.replace("(", " ( ") .replace(")", " ) ") .split_whitespace() .map(|x| x.to_string()) .collect() } }

根据 lisp 表达式的规则,表达式一般都是由小括号包裹起来的,为了更好的通过空格分割 token,我们将小括号替换为两边各带有一个空格的括号。然后通过 split_whitespace 函数将字符串进行分割,并把每段字符串转换成带所有权的字符串,最后通过 collect 收集,以字符串数组的形式存放到变量中。

然后通过 parse 函数将其转化成 RispExp 类型结构:

#![allow(unused)] fn main() { fn parse<'a>(tokens: &'a [String]) -> Result<(RispExp, &'a [String]), RispErr> { let (token, rest) = tokens .split_first() .ok_or(RispErr::Reason("could not get token".to_string()))?; match &token[..] { "(" => read_seq(rest), ")" => Err(RispErr::Reason("unexpected `)`".to_string())), _ => Ok((parse_atom(token), rest)), } } fn read_seq<'a>(tokens: &'a [String]) -> Result<(RispExp, &'a [String]), RispErr> { let mut res: Vec<RispExp> = vec![]; let mut xs = tokens; loop { let (next_token, rest) = xs .split_first() .ok_or(RispErr::Reason("could not find closing `)`".to_string()))?; if next_token == ")" { return Ok((RispExp::List(res), rest)); } let (exp, new_xs) = parse(&xs)?; res.push(exp); xs = new_xs; } } }

得到 token 列表后,我们对 token 逐个解析,通过 split_first 取出 token 列表中的第一个 token,以及第一个以外的其余元素。 对第一个 token 进行模式匹配:

  • 如果表达式以 ( 开头,则调用 read_seq 读取表达式剩余部分的 token
  • 如果表达式以 ) 开头,则意味着当前表达式是错误的表达式。
  • 以上之外,则是要按正常情况解析 lisp 表达式中的原子 —— atom。parse_atom 的实现如下:
#![allow(unused)] fn main() { fn parse_atom(token: &str) -> RispExp { let potential_float: Result<f64, ParseFloatError> = token.parse(); match potential_float { Ok(v) => RispExp::Number(v), Err(_) => RispExp::Symbol(token.to_string().clone()), } } }

根据语法规则,一个原子是一个数字连续字符或字符串,它包括数字和特殊字符。 我们先尝试将其解析为数值类型,如果解析失败,则意味着它是字符串 —— RispExp::Symbol(token.to_string().clone())。

我们会在全局符号表中存储变量的定义和函数定义,因此我们需要扩展一下 RispExp:

#![allow(unused)] fn main() { #[derive(Clone)] enum RispExp { Symbol(String), Number(f64), List(Vec<RispExp>), Func(fn(&[RispExp]) -> Result<RispExp, RispErr>), // new } }

我们先创建一个存储特定符号的容器,每一个符号都有特殊的功能:

#![allow(unused)] fn main() { fn default_env() -> RispEnv { let mut data: HashMap<String, RispExp> = HashMap::new(); data.insert( "+".to_string(), RispExp::Func(|args: &[RispExp]| -> Result<RispExp, RispErr> { let sum = parse_list_of_floats(args)? .iter() .fold(0.0, |sum, a| sum + a); Ok(RispExp::Number(sum)) }), ); data.insert( "-".to_string(), RispExp::Func(|args: &[RispExp]| -> Result<RispExp, RispErr> { let floats = parse_list_of_floats(args)?; let first = *floats .first() .ok_or(RispErr::Reason("expected at least one number".to_string()))?; let sum_of_rest = floats[1..].iter().fold(0.0, |sum, a| sum + a); Ok(RispExp::Number(first - sum_of_rest)) }), ); RispEnv { data } } }

这里我们先实现 +- 运算符的功能。并且为了简化实现,我们先简单粗暴地认为参数都是合法的数值类型,可以通过 parse_list_of_floats 解析这些参数:

#![allow(unused)] fn main() { fn parse_list_of_floats(args: &[RispExp]) -> Result<Vec<f64>, RispErr> { args.iter().map(|x| parse_single_float(x)).collect() } fn parse_single_float(exp: &RispExp) -> Result<f64, RispErr> { match exp { RispExp::Number(num) => Ok(*num), _ => Err(RispErr::Reason("expect a number".to_string())), } } }

执行

接下来是实现 eval(程序执行)部分了。

  • 1.程序体(表达式)的第一部分如果是标识符,则在全局环境中查询该标识符,如果存在,则返回(如果是 +- 等操作符,则返回 RispExp::Func 类型的操作逻辑实现)。
  • 2.如果是数值,则返回该数值
  • 3.如果是列表,则尝试步骤一。即先返回 RispExp::Func(函数类型),然后列表中的其他原子作为参数执行该函数。
#![allow(unused)] fn main() { fn eval(exp: &RispExp, env: &mut RispEnv) -> Result<RispExp, RispErr> { match exp { RispExp::Symbol(k) => env .data .get(k) .ok_or(RispErr::Reason(format!("unexpected symbol k={}", k))) .map(|x| x.clone()), RispExp::Number(_a) => Ok(exp.clone()), RispExp::List(list) => { let first_form = list .first() .ok_or(RispErr::Reason("expected a non-empty list".to_string()))?; let arg_forms = &list[1..]; let first_eval = eval(first_form, env)?; match first_eval { RispExp::Func(f) => { let args_eval = arg_forms .iter() .map(|x| eval(x, env)) .collect::<Result<Vec<RispExp>, RispErr>>(); f(&args_eval?) } _ => Err(RispErr::Reason("first form must be a function".to_string())), } } RispExp::Func(_) => Err(RispErr::Reason("unexpected form".to_string())), } } }

前面提到过,我们要实现一个简单的计算器,而 lisp 的计算表达式一般是以符号原子开始的,如:(+ 1 2)。 当把这个表达式转换为 RispExp 结构后的形式类似于:

// 伪代码 PlusFunc( num1, num2, ... )

我们先通过 + 匹配到事先在 default_env 中注册好的函数 f,然后向该函数中传入第一个原子之后的所有参数:f(num1, num2),就能得到执行结果。

REPL

REPL 的全称是 Read Evel Print Loop,表示一种交互形式:读取 -> 执行 -> 打印结果 -> 循环。

针对前面实现的 lisp 子集,我们可以为其实现一个 repl,用于更好的使用该“lisp 解释器”。

我们要做的很简单,读取用户输入,然后解析执行,把执行结果打印出来,然后不断地循环整个过程。那接下来,把解释器的实现用循环包裹起来试试:

#![allow(unused)] fn main() { fn parse_eval(expr: String, env: &mut RispEnv) -> Result<RispExp, RispErr> { let (parsed_exp, _) = parse(&tokenize(expr))?; let evaled_exp = eval(&parsed_exp, env)?; Ok(evaled_exp) } }

获取用户输入的表达式,再调用 parse_eval:

#![allow(unused)] fn main() { fn slurp_expr() -> String { let mut expr = String::new(); io::stdin() .read_line(&mut expr) .expect("Failed to read line"); expr } pub fn run_repl() { let env = &mut default_env(); loop { println!("risp >"); let expr = slurp_expr(); match parse_eval(expr, env) { Ok(res) => println!("// 🔥 => {}", res), Err(e) => match e { RispErr::Reason(msg) => println!("// 🙀 => {}", msg), }, } } } }

好了,接下来我们把 run_repl 放入 main 函数中:

fn main() { run_repl(); }

大功告成!我们只需在命令行中输入 cargo run 即可启动你的 repl 程序。完整的代码可以点此查看

启动后,输入简单的 lisp 表达式,看看效果:

risp > (+ 1 2 ) // 🔥 => 3 risp > (+ 1 10 (+ 20 1)) // 🔥 => 32

可以看出,单一的表达式和嵌套的表达式的加、减法都可以正确地计算出结果。这样,我们算是实现了这个简单的加减法计算。

版本 0.1.1

目前,我们的“lisp”仅支持简单的加、减等算数运算,我们需要扩展它。先给它增加 bool 类型的支持。

#![allow(unused)] fn main() { #[derive(Clone)] enum RispExp { Symbol(String), Number(f64), List(Vec<RispExp>), Func(fn(&[RispExp]) -> Result<RispExp, RispErr>), Bool(bool), // ->new } }

对应的我们需要调整 parse_atom 中的代码:

#![allow(unused)] fn main() { fn parse_atom(token: &str) -> RispExp { match token { "true" => { RispExp::Bool(true) }, "false" => { RispExp::Bool(false) }, _ => { let potential_float: Result<f64, ParseFloatError> = token.parse(); match potential_float { Ok(v) => RispExp::Number(v), Err(_) => RispExp::Symbol(token.to_string().clone()), } } } } }

有了布尔类型之后,我们可以实现 ><= 等比较运算符,因为通过这些运算符计算后的结果值是布尔值。

要能支持这些比较运算符,我们需要将 = 对应的处理逻辑加到 default_env 中:

#![allow(unused)] fn main() { // = 逻辑实现 data.insert( "=".to_string(), RispExp::Func(|args: &[RispExp]| -> Result<RispExp, RispErr> { let floats = parse_list_of_floats(args)?; // 要想比较,需要有两个值 if floats.len() != 2 { return Err(RispErr::Reason("expected two number".to_string())); } // 将第 0 个元素和第 1 个元素进行比较 if floats.get(0).is_none() || floats.get(1).is_none() { return Err(RispErr::Reason("expected number".to_string())); } let is_ok = floats.get(0).unwrap().eq(floats.get(1).unwrap()); Ok(RispExp::Bool(is_ok)) }), ); }

此时,我们的 lisp 解释器已经支持了 = 的操作,使用 cargo run 运行 repl:

risp > (= 12 12) // 🔥 => true risp > (= 1 2 3) // 🙀 => expected two number risp >

真不错,我们实现了 = 操作的扩展支持。我们还需要继续支持 >>=<<=。以 >= 为例,将其实现加入到 default_env 函数中:

#![allow(unused)] fn main() { data.insert( ">=".to_string(), RispExp::Func(|args: &[RispExp]| -> Result<RispExp, RispErr> { let floats = parse_list_of_floats(args)?; // 要想比较,需要有两个值 if floats.len() != 2 { return Err(RispErr::Reason("expected two number".to_string())); } // 校验这两个值必须存在 if floats.get(0).is_none() || floats.get(1).is_none() { return Err(RispErr::Reason("expected number".to_string())); } Ok(RispExp::Bool( floats.get(0).unwrap().gt(floats.get(1).unwrap()), )) }), ); }

根据原博客,为了简化代码,这部分的实现可以用宏实现:

#![allow(unused)] fn main() { macro_rules! ensure_tonicity { ($check_fn:expr) => {{ |args: &[RispExp]| -> Result<RispExp, RispErr> { let floats = parse_list_of_floats(args)?; let first = floats .first() .ok_or(RispErr::Reason("expected at least one number".to_string()))?; let rest = &floats[1..]; fn f(prev: &f64, xs: &[f64]) -> bool { match xs.first() { Some(x) => $check_fn(prev, x) && f(x, &xs[1..]), None => true, } }; Ok(RispExp::Bool(f(first, rest))) } }}; } data.insert( ">".to_string(), RispExp::Func(ensure_tonicity!(|a, b| a > b)), ); data.insert( "<".to_string(), RispExp::Func(ensure_tonicity!(|a, b| a < b)), ); data.insert( "<=".to_string(), RispExp::Func(ensure_tonicity!(|a, b| a <= b)), ); }

这样就实现了所有比较运算符的处理逻辑了。

要实现一个更接近 lisp 的语言,我们还需要引入 defif 这两关键字了。这两关键字的作用见下表:

图片来自知乎专栏

因此,我们先更新 eval 函数,使其优先匹配内置标识符(关键字),如果不是关键字,则直接按照原先逻辑执行:

fn eval(exp: &RispExp, env: &mut RispEnv) -> Result<RispExp, RispErr> { match exp { ... ... RispExp::List(list) => { let first_form = list .first() .ok_or(RispErr::Reason("expected a non-empty list".to_string()))?; let arg_forms = &list[1..]; // 优先匹配并处理“关键字” match eval_built_in_form(first_form, arg_forms, env) { Some(built_in_res) => built_in_res, None => { let first_eval = eval(first_form, env)?; match first_eval { RispExp::Func(f) => { let args_eval = arg_forms .iter() .map(|x| eval(x, env)) .collect::<Result<Vec<RispExp>, RispErr>>(); f(&args_eval?) } _ => Err(RispErr::Reason("first form must be a function".to_string())), } } } } RispExp::Func(_) => Err(RispErr::Reason("unexpected form".to_string())), } } // 处理内置标识符 fn eval_built_in_form( exp: &RispExp, other_args: &[RispExp], env: &mut RispEnv, ) -> Option<Result<RispExp, RispErr>> { match exp { RispExp::Symbol(symbol) => match symbol.as_ref() { "if" => Some(eval_if_args(other_args, env)), "def" => Some(eval_def_args(other_args, env)), _ => None, }, _ => None, } } fn eval_if_args(args: &[RispExp], env: &mut RispEnv) -> Result<RispExp, RispErr> { let test_form = args .first() .ok_or(RispErr::Reason("expected test form".to_string()))?; let test_eval = eval(test_form, env)?; match test_eval { RispExp::Bool(b) => { let form_idx = if b { 1 } else { 2 }; let res_form = args .get(form_idx) .ok_or(RispErr::Reason(format!("expected form idx={}", form_idx)))?; let res_eval = eval(res_form, env); res_eval } _ => Err(RispErr::Reason(format!( "unexpected test form='{}'", test_form.to_string() ))), } }

根据上图表格中的描述,if 语法如下:(if test conseq alt),对 test 表达式求值,如果为真,则对 conseq 表达式求值并返回;否则,对 alt 表达式求值并返回。例如:(if (> 10 20) (+ 2 3) (- 1 2))

同理,def 语法:(def var exp)。用于定义一个新的变量 var,它的值是 exp 表达式的值,例如:(def k1 10)。逻辑实现如下:

#![allow(unused)] fn main() { fn eval_def_args(args: &[RispExp], env: &mut RispEnv) -> Result<RispExp, RispErr> { let var_exp = args.first().ok_or(RispErr::Reason(format!("unexepceted string for var")))?; let val_res = args.get(1).ok_or(RispErr::Reason(format!("expected second param.")))?; let evaled_val = eval(val_res, env)?; match var_exp { RispExp::Symbol(ref var_name) => { env.data.insert(var_name.clone(), evaled_val); Ok(var_exp.clone()) }, _ => Err(RispErr::Reason(format!("unexpected var name"))) } } }

我们运行 repl(cargo run),通过一些输入,看看实现的效果:

risp > (def a 1) // 🔥 => a risp > (+ 1 a) // 🔥 => 2 risp > (if (> 2 1) true false) // 🔥 => true risp > (if (< 2 1) true false) // 🔥 => false

太棒了,一切都运行的很完美!

接下来,我们尝试支持另一种语法 —— lambda。下面是一个翻译文章对 lambda 的描述:

lambda 特殊形式会创建一个过程(procedure)。(lambda这个名字来源于Alonzo Church的lambda calculus) —— 来自译文

lambda 其实就是一种匿名函数,既然是函数也就意味着有参数列表和函数体,所以,lambda 的语法形式如下:(lambda (var...) exp),其中的 (var...) 是参数列表,exp 是函数体,因此我们定义 lambda 结构体:

#![allow(unused)] fn main() { #[derive(Clone)] struct RispLambda { params: Rc<RispExp>, body: Rc<RispExp>, } }

解析 lambda 表达式:

#![allow(unused)] fn main() { fn eval_lambda_args(args: &[RispExp]) -> Result<RispExp, RispErr> { let params = args .first() .ok_or(RispErr::Reason(format!("unexpected args form")))?; let body = args .get(1) .ok_or(RispErr::Reason(format!("unexpected second form")))?; if args.len() != 2 { return Err(RispErr::Reason(format!("lambda can only have two forms"))); } Ok(RispExp::Lambda(RispLambda { params: Rc::new(params.clone()), body: Rc::new(body.clone()), })) } }

对用户的输入进行解析,基于已经解析了的 RispExp 结构,当遇到的 List 是 lambda 类型时,将跟随在 lambda 后的第一个表达式视为“参数列表”,第二个表达式视为“lambda 函数体”。然后返回一个 RispExp::Lambda 实例。

当 lambda 被调用时,会生成一个不同于 default_env 的新 env,可将其视为当前函数的作用域,当执行函数体的时候,会使用新的 env 中的符号、参数等信息,如果查找不到,则在全局环境(default_env)中查找,所以需要调整一下 RispEnv:

#![allow(unused)] fn main() { struct RispEnv<'a> { data: HashMap<String, RispExp>, outer: Option<&'a RispEnv<'a>>, } /// 构建 lambda 执行环境 fn env_for_lambda<'a>( params: Rc<RispExp>, args: &[RispExp], outer_env: &'a mut RispEnv, ) -> Result<RispEnv<'a>, RispErr> { let ks = parse_list_of_symbol_strings(params)?; if ks.len() != args.len() { return Err(RispErr::Reason(format!( "expected {} params, got {}", ks.len(), args.len() ))); } let vs = eval_forms(args, outer_env)?; let mut data: HashMap<String, RispExp> = HashMap::new(); for (k, v) in ks.iter().zip(vs.iter()) { data.insert(k.clone(), v.clone()); } Ok(RispEnv { data, outer: Some(outer_env), }) } /// 执行一组表达式,将结果放入数组中 fn eval_forms(args: &[RispExp], env: &mut RispEnv) -> Result<Vec<RispExp>, RispErr> { args.iter().map(|x| eval(x, env)).collect() } /// 解析参数列表 fn parse_list_of_symbol_strings(params: Rc<RispExp>) -> Result<Vec<String>, RispErr> { let list = match params.as_ref() { RispExp::List(s) => Ok(s.clone()), _ => Err(RispErr::Reason(format!("expected params to be a list"))), }?; list.iter() .map(|x| match x { RispExp::Symbol(s) => Ok(s.clone()), _ => Err(RispErr::Reason(format!( "expected symbol in the argument list" ))), }) .collect() } }

env_for_lambda 函数中的 data 是 lambda 内部环境,outer 则是外层(全局环境)env。 通过构建好的 lambda body,将其基于新构建的 lambda 环境执行,得到的结果即 lambda 调用结果。

fn eval(exp: &RispExp, env: &mut RispEnv) -> Result<RispExp, RispErr> { ... RispExp::List(list) => { ... match eval_built_in_form(first_form, arg_forms, env) { Some(built_in_res) => built_in_res, None => { let first_eval = eval(first_form, env)?; match first_eval { RispExp::Func(f) => { let args_eval = arg_forms .iter() .map(|x| eval(x, env)) .collect::<Result<Vec<RispExp>, RispErr>>(); f(&args_eval?) } RispExp::Lambda(lambda) => { // -> New let new_env = &mut env_for_lambda(lambda.params, arg_forms, env)?; eval(&lambda.body, new_env) }, _ => Err(RispErr::Reason("first form must be a function".to_string())), } } } } }

基本完成了 lambda 的支持,我们编译代码试试吧!(cargo run

risp > (def add-one (lambda (a) (+ a 1))) // 🔥 => add-one risp > (add-one 1) // 🔥 => 2 risp > (add-one 5) // 🔥 => 6

REPL 中,我们通过 def 定义了一个名为 add-one 的 lambda 表达式。 然后调用 add-one,传入的参数为 1,结果为 2,入参为 5 时,计算结果为 6。符合预期!

至此,lambda 表达式支持完成!完整的代码可以点此查看

Lisp 是非常早期的高阶编程语言之一,它的出现开创了很多先驱概念,如:树、动态类型、高阶函数等。它结构简单,却是计算机语言发展中非常重要的基础。本文通过使用 Rust 实现 Lisp 子集,即是学习 Lisp 本身,也是学习 Rust 的语法和使用。基于此,你可以探索更加完整的 Lisp 实现。希望对读者你有帮助,感谢阅读!

参考资料

  • https://stopachka.essay.dev/post/5/risp-in-rust-lisp
  • 如何(用Python)写一个(Lisp)解释器(译文) https://zhuanlan.zhihu.com/p/28989326
  • https://lisp-lang.org/learn/getting-started/
  • mod 作用域,关于 Rust 模块详解,可以查看这篇文章
  • Lisp 教程 https://www.yiibai.com/lisp/lisp_overview.html
  • Lisp 维基百科 https://zh.wikipedia.org/wiki/LISP