Initial checkin

Author: vishpat

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "lisp-rs"
+version = "0.0.1"
+edition = "2021"
+license = "MIT"
+homepage = "https://vishpat.github.io/lisp-rs"
+repository = "https://github.com/vishpat/lisp-rs"
+documentation = "https://vishpat.github.io/lisp-rs"
+description = """
+Lisp interpreter in Rust
+"""
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+linefeed = "0.6.0"

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Vishal Patil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,7 @@
+# lisp-rs
+
+A simple Lisp interpreter in Rust. The interpreter was developed to explain how programming language interpreters work and how can they be implemented using the Rust programming language.
+
+For detailed code walk-through refer to the [docs](https://vishpat.github.io/lisp-rs).
+
+[![asciicast](https://asciinema.org/a/VVQQfGpp15a4BaoNgnEKIqqrr.svg)](https://asciinema.org/a/VVQQfGpp15a4BaoNgnEKIqqrr)

src/env.rs

@@ -0,0 +1,36 @@
+use crate::object::Object;
+use std::collections::HashMap;
+
+#[derive(Debug, PartialEq, Default)]
+pub struct Env<'a> {
+    parent: Option<&'a Env<'a>>,
+    vars: HashMap<String, Object>,
+}
+
+impl<'a> Env<'a> {
+
+    pub fn new() -> Env<'a> {
+        Env {
+            vars: HashMap::new(),
+            parent: None,
+        }
+    }
+
+    pub fn extend(parent: &'a Self) -> Env<'a> {
+        Env {
+            vars: HashMap::new(),
+            parent: Some(parent),
+        }
+    }
+
+    pub fn get(&self, name: &str) -> Option<Object> {
+        match self.vars.get(name) {
+            Some(value) => Some(value.clone()),
+            None => self.parent.and_then(|parent| parent.get(name)),
+        }
+    }
+
+    pub fn set(&mut self, name: &str, val: Object) {
+        self.vars.insert(name.to_string(), val);
+    }
+}

src/eval.rs

@@ -0,0 +1,254 @@
+use crate::env::*;
+use crate::object::*;
+use crate::parser::*;
+
+fn eval_binary_op(list: &Vec<Object>, env: &mut Env) -> Result<Object, String> {
+    if list.len() != 3 {
+        return Err(format!("Invalid number of arguments for infix operator"));
+    }
+    let operator = list[0].clone();
+    let left = eval_obj(&list[1].clone(), env)?;
+    let right = eval_obj(&list[2].clone(), env)?;
+    let left_val = match left {
+        Object::Integer(n) => n,
+        _ => return Err(format!("Left operand must be an integer {:?}", left)),
+    };
+    let right_val = match right {
+        Object::Integer(n) => n,
+        _ => return Err(format!("Right operand must be an integer {:?}", right)),
+    };
+    match operator {
+        Object::Symbol(s) => match s.as_str() {
+            "+" => Ok(Object::Integer(left_val + right_val)),
+            "-" => Ok(Object::Integer(left_val - right_val)),
+            "*" => Ok(Object::Integer(left_val * right_val)),
+            "/" => Ok(Object::Integer(left_val / right_val)),
+            "<" => Ok(Object::Bool(left_val < right_val)),
+            ">" => Ok(Object::Bool(left_val > right_val)),
+            "=" => Ok(Object::Bool(left_val == right_val)),
+            "!=" => Ok(Object::Bool(left_val != right_val)),
+            _ => Err(format!("Invalid infix operator: {}", s)),
+        },
+        _ => Err(format!("Operator must be a symbol")),
+    }
+}
+
+fn eval_define(list: &Vec<Object>, env: &mut Env) -> Result<Object, String> {
+    if list.len() != 3 {
+        return Err(format!("Invalid number of arguments for define"));
+    }
+
+    let sym = match &list[1] {
+        Object::Symbol(s) => s.clone(),
+        _ => return Err(format!("Invalid define")),
+    };
+    let val = eval_obj(&list[2], env)?;
+    env.set(&sym, val);
+    Ok(Object::Void)
+}
+
+fn eval_if(list: &Vec<Object>, env: &mut Env) -> Result<Object, String> {
+    if list.len() != 4 {
+        return Err(format!("Invalid number of arguments for if statement"));
+    }
+
+    let cond_obj = eval_obj(&list[1], env)?;
+    let cond = match cond_obj {
+        Object::Bool(b) => b,
+        _ => return Err(format!("Condition must be a boolean")),
+    };
+
+    if cond == true {
+        return eval_obj(&list[2], env);
+    } else {
+        return eval_obj(&list[3], env);
+    }
+}
+
+fn eval_function_definition(list: &Vec<Object>) -> Result<Object, String> {
+    let params = match &list[1] {
+        Object::List(list) => {
+            let mut params = Vec::new();
+            for param in list {
+                match param {
+                    Object::Symbol(s) => params.push(s.clone()),
+                    _ => return Err(format!("Invalid lambda parameter")),
+                }
+            }
+            params
+        }
+        _ => return Err(format!("Invalid lambda")),
+    };
+
+    let body = match &list[2] {
+        Object::List(list) => list.clone(),
+        _ => return Err(format!("Invalid lambda")),
+    };
+    Ok(Object::Lambda(params, body))
+}
+
+fn eval_function_call(
+    s: &str,
+    list: &Vec<Object>,
+    env: &mut Env,
+) -> Result<Object, String> {
+    let lamdba = env.get(s);
+    if lamdba.is_none() {
+        return Err(format!("Unbound symbol: {}", s));
+    }
+
+    let func = lamdba.unwrap();
+    match func {
+        Object::Lambda(params, body) => {
+            let mut new_env = Env::extend(env);
+            for (i, param) in params.iter().enumerate() {
+                let val = eval_obj(&list[i + 1], &mut new_env)?;
+                new_env.set(param, val);
+            }
+            return eval_obj(&Object::List(body), &mut new_env);
+        }
+        _ => return Err(format!("Not a lambda: {}", s)),
+    }
+}
+
+fn eval_symbol(s: &str, env: &mut Env) -> Result<Object, String> {
+    let val = env.get(s);
+    if val.is_none() {
+        return Err(format!("Unbound symbol: {}", s));
+    }
+    Ok(val.unwrap().clone())
+}
+
+fn eval_list(list: &Vec<Object>, env: &mut Env) -> Result<Object, String> {
+    let head = &list[0];
+    match head {
+        Object::Symbol(s) => match s.as_str() {
+            "+" | "-" | "*" | "/" | "<" | ">" | "=" | "!=" => {
+                return eval_binary_op(&list, env);
+            }
+            "define" => eval_define(&list, env),
+            "if" => eval_if(&list, env),
+            "lambda" => eval_function_definition(&list),
+            _ => eval_function_call(&s, &list, env),
+        },
+        _ => {
+            let mut new_list = Vec::new();
+            for obj in list {
+                let result = eval_obj(obj, env)?;
+                match result {
+                    Object::Void => {}
+                    _ => new_list.push(result),
+                }
+            }
+            Ok(Object::List(new_list))
+        }
+    }
+}
+
+fn eval_obj(obj: &Object, env: &mut Env) -> Result<Object, String> {
+    match obj {
+        Object::List(list) => eval_list(list, env),
+        Object::Void => Ok(Object::Void),
+        Object::Lambda(_params, _body) => Ok(Object::Void),
+        Object::Bool(_) => Ok(obj.clone()),
+        Object::Integer(n) => Ok(Object::Integer(*n)),
+        Object::Symbol(s) => eval_symbol(s, env),
+    }
+}
+
+pub fn eval(program: &str, env: &mut Env) -> Result<Object, String> {
+    let parsed_list = parse(program);
+    if parsed_list.is_err() {
+        return Err(format!("{}", parsed_list.err().unwrap()));
+    }
+    eval_obj(&parsed_list.unwrap(), env)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_simple_add() {
+        let mut env = Box::new(Env::new());
+        let result = eval("(+ 1 2)", &mut env).unwrap();
+        assert_eq!(result, Object::Integer(3));
+    }
+
+    #[test]
+    fn test_area_of_a_circle() {
+        let mut env = Box::new(Env::new());
+        let program = "(
+                        (define r 10)
+                        (define pi 314)
+                        (* pi (* r r))
+                      )";
+        let result = eval(program, &mut env).unwrap();
+        assert_eq!(
+            result,
+            Object::List(vec![Object::Integer((314 * 10 * 10) as i64)])
+        );
+    }
+
+    #[test]
+    fn test_sqr_function() {
+        let mut env = Box::new(Env::new());
+        let program = "(
+                        (define sqr (lambda (r) (* r r))) 
+                        (sqr 10)
+                       )";
+        let result = eval(program, &mut env).unwrap();
+        assert_eq!(
+            result,
+            Object::List(vec![Object::Integer((10 * 10) as i64)])
+        );
+    }
+
+    #[test]
+    fn test_fibonaci() {
+        let mut env = Box::new(Env::new());
+        let program = "
+            (
+                (define fib (lambda (n) (if (< n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))))
+                (fib 10)
+            )
+        ";
+
+        let result = eval(program, &mut env).unwrap();
+        assert_eq!(result, Object::List(vec![Object::Integer((89) as i64)]));
+    }
+
+    #[test]
+    fn test_factorial() {
+        let mut env = Box::new(Env::new());
+        let program = "
+            (
+                (define fact (lambda (n) (if (< n 1) 1 (* n (fact (- n 1))))))
+                (fact 5)
+            )
+        ";
+
+        let result = eval(program, &mut env).unwrap();
+        assert_eq!(result, Object::List(vec![Object::Integer((120) as i64)]));
+    }
+
+    #[test]
+    fn test_circle_area_function() {
+        let mut env = Box::new(Env::new());
+        let program = "
+            (
+                (define pi 314)
+                (define r 10)
+                (define sqr (lambda (r) (* r r)))
+                (define area (lambda (r) (* pi (sqr r))))
+                (area r)
+            )
+        ";
+
+        let result = eval(program, &mut env).unwrap();
+        assert_eq!(
+            result,
+            Object::List(vec![Object::Integer((314 * 10 * 10) as i64)])
+        );
+    }
+}