if

Author: lpil

Diff for: README.md

@@ -10,7 +10,7 @@ It features:
 - [ ] Closures with `lambda`.
 - [x] Global variables with `define`.
 - [x] Local variables with `let`.
-- [ ] Flow control with `if`.
+- [x] Flow control with `if`.
 
 ## Usage
 

Diff for: src/glisp.gleam

@@ -135,6 +135,7 @@ fn new_state() -> State {
       #("not", Procedure(not_builtin)),
       #("and", Procedure(and_builtin)),
       #("or", Procedure(or_builtin)),
+      #("if", Procedure(if_builtin)),
       #("define", Procedure(define_builtin)),
     ])
   let local_scope = map.new()
@@ -351,6 +352,16 @@ fn or_builtin(expressions: List(Expression), state: State) -> Evaluated {
   }
 }
 
+fn if_builtin(expressions: List(Expression), state: State) -> Evaluated {
+  try #(condition, then, else) = expect_3(expressions)
+  try #(condition, state) = evaluate_expression(condition, state)
+  try bool = expect_bool(condition)
+  case bool {
+    True -> evaluate_expression(then, state)
+    False -> evaluate_expression(else, state)
+  }
+}
+
 fn type_error(expected: String, value: Expression) -> Result(anything, Error) {
   Error(TypeError(expected: expected, got: type_name(value), value: value))
 }
@@ -399,7 +410,16 @@ fn expect_2(
 ) -> Result(#(Expression, Expression), Error) {
   case expressions {
     [x, y] -> Ok(#(x, y))
-    _ -> arity_error(1, expressions)
+    _ -> arity_error(2, expressions)
+  }
+}
+
+fn expect_3(
+  expressions: List(Expression),
+) -> Result(#(Expression, Expression, Expression), Error) {
+  case expressions {
+    [x, y, z] -> Ok(#(x, y, z))
+    _ -> arity_error(3, expressions)
   }
 }
 
@@ -419,7 +439,7 @@ fn print(value: Expression) -> String {
     Bool(True) -> "true"
     Bool(False) -> "false"
     List(xs) -> "'(" <> string.join(list.map(xs, print), " ") <> ")"
-    Procedure(_) -> "#procedure"
+    Procedure(_) -> "#<procedure>"
     Atom(x) -> "'" <> x
   }
 }

Diff for: test/glisp_test.gleam

@@ -181,9 +181,20 @@ pub fn let_nested_test() {
   // Here x is defined in both lets. The inner one does not leak
   assert Ok("1") =
     glisp.eval(
-      "
-    (let ((x 1) 
-          (y (let ((x 2)) x)))
-         x)",
+      "(let ((x 1) 
+             (y (let ((x 2)) x)))
+        x)",
     )
 }
+
+pub fn procedure_printing_test() {
+  assert Ok("#<procedure>") = glisp.eval("let")
+}
+
+pub fn if_true_test() {
+  assert Ok("2") = glisp.eval("(if (= 1 1) (+ 1 1) (+ 2 2))")
+}
+
+pub fn if_false_test() {
+  assert Ok("4") = glisp.eval("(if (= 1 2) (+ 1 1) (+ 2 2))")
+}