lambda

Author: lpil

Diff for: README.md

@@ -5,9 +5,9 @@ A tree-walking Lisp interpreter written in [Gleam](https://gleam.run).
 It features:
 - [x] Ints with `+`, `-`, `*`, and `/`.
 - [x] Bools with `not`, `and`, and `or`.
-- [=] Comparison with `=`.
+- [x] Comparison with `=`.
 - [x] Lists with `cons`, `car`, `cdr`.
-- [ ] Closures with `lambda`.
+- [x] Closures with `lambda`.
 - [x] Global variables with `define`.
 - [x] Local variables with `let`.
 - [x] Flow control with `if`.

Diff for: src/glisp.gleam

@@ -11,6 +11,7 @@ pub type Expression {
   Int(Int)
   Atom(String)
   Procedure(procedure: Procedure)
+  Closure(arguments: List(String), body: List(Expression), scope: Scope)
 }
 
 pub type Error {
@@ -137,6 +138,7 @@ fn new_state() -> State {
       #("or", Procedure(or_builtin)),
       #("if", Procedure(if_builtin)),
       #("define", Procedure(define_builtin)),
+      #("lambda", Procedure(lambda_builtin)),
     ])
   let local_scope = map.new()
   State(global_scope: global_scope, local_scope: local_scope)
@@ -158,7 +160,7 @@ fn evaluate(
 
 fn evaluate_expression(expression: Expression, state: State) -> Evaluated {
   case expression {
-    Bool(_) | Int(_) | Procedure(..) -> Ok(#(expression, state))
+    Bool(_) | Int(_) | Procedure(_) | Closure(..) -> Ok(#(expression, state))
     List(expressions) -> evaluate_list(expressions, state)
     Atom(atom) -> {
       try value = evaluate_atom(atom, state)
@@ -198,7 +200,41 @@ fn call(
 ) -> Evaluated {
   case callable {
     Procedure(procedure) -> procedure(arguments, state)
-    _ -> type_error("procedure", callable)
+    Closure(parameters, body, environment) ->
+      call_closure(parameters, body, environment, arguments, state)
+    _ -> type_error("Procedure", callable)
+  }
+}
+
+fn call_closure(
+  parameters: List(String),
+  body: List(Expression),
+  environment: Map(String, Expression),
+  arguments: List(Expression),
+  state: State,
+) -> Evaluated {
+  let original_locals = state.local_scope
+  let state = set_locals(state, environment)
+  try state = evaluate_lambda_arguments(parameters, arguments, state, 0)
+  try #(result, state) = evaluate(body, empty, state)
+  Ok(#(result, set_locals(state, original_locals)))
+}
+
+fn evaluate_lambda_arguments(
+  parameters: List(String),
+  arguments: List(Expression),
+  state: State,
+  count: Int,
+) -> Result(State, Error) {
+  case parameters, arguments {
+    [], [] -> Ok(state)
+    [parameter, ..parameters], [argument, ..arguments] -> {
+      try #(argument, state) = evaluate_expression(argument, state)
+      let state = insert_local(state, parameter, argument)
+      evaluate_lambda_arguments(parameters, arguments, state, count + 1)
+    }
+    [], rest -> Error(IncorrectArity(count, count + list.length(rest)))
+    rest, [] -> Error(IncorrectArity(count + list.length(rest), count))
   }
 }
 
@@ -225,6 +261,17 @@ fn define_builtin(arguments: List(Expression), state: State) -> Evaluated {
   }
 }
 
+fn lambda_builtin(arguments: List(Expression), state: State) -> Evaluated {
+  case arguments {
+    [parameters, ..body] -> {
+      try parameters = expect_list(parameters)
+      try parameters = list.try_map(parameters, expect_atom)
+      Ok(#(Closure(parameters, body, state.local_scope), state))
+    }
+    _ -> Error(IncorrectArity(2, list.length(arguments)))
+  }
+}
+
 fn evaluate_atom(atom: String, state: State) -> Result(Expression, Error) {
   map.get(state.local_scope, atom)
   |> result.lazy_or(fn() { map.get(state.global_scope, atom) })
@@ -429,6 +476,7 @@ fn type_name(value: Expression) -> String {
     Bool(_) -> "Bool"
     List(_) -> "List"
     Procedure(_) -> "Procedure"
+    Closure(..) -> "Closure"
     Atom(_) -> "Atom"
   }
 }
@@ -440,6 +488,7 @@ fn print(value: Expression) -> String {
     Bool(False) -> "false"
     List(xs) -> "'(" <> string.join(list.map(xs, print), " ") <> ")"
     Procedure(_) -> "#<procedure>"
+    Closure(..) -> "#<closure>"
     Atom(x) -> "'" <> x
   }
 }

Diff for: test/glisp_test.gleam

@@ -198,3 +198,25 @@ pub fn if_true_test() {
 pub fn if_false_test() {
   assert Ok("4") = glisp.eval("(if (= 1 2) (+ 1 1) (+ 2 2))")
 }
+
+pub fn closure_test() {
+  assert Ok("1") =
+    glisp.eval(
+      "
+(define id (lambda (x) x))
+(id 1)
+",
+    )
+}
+
+pub fn closure_closes_over_scope_at_time_of_definition_test() {
+  assert Ok("1") =
+    glisp.eval(
+      "
+(define fn (let ((x 1)
+                 (return-x (lambda () x)))
+            return-x))
+(let ((x 2)) (fn))
+",
+    )
+}