add do forms

src/compiler.rs

@@ -316,10 +316,14 @@ pub struct Compiler<'a> {
     loop_info: Vec<LoopInfo>,
 }
 
-fn is_let(expr: &Spanned<Ast>) -> bool {
+fn is_binding(expr: &Spanned<Ast>) -> bool {
     let (ast, _) = expr;
     use Ast::*;
-    matches!(ast, Let(..))
+    match ast {
+        Let(..) | LBox(..) => true,
+        Fn(name, ..) => !name.is_empty(),
+        _ => false,
+    }
 }
 
 impl<'a> Compiler<'a> {
@@ -463,6 +467,7 @@ impl<'a> Compiler<'a> {
     }
 
     fn pop(&mut self) {
+        println!("Popping from: {}", self.ast);
         self.emit_op(Op::Pop);
         self.stack_depth -= 1;
     }
@@ -515,7 +520,7 @@ impl<'a> Compiler<'a> {
                 self.scope_depth += 1;
                 let stack_depth = self.stack_depth;
                 for expr in lines.iter().take(lines.len() - 1) {
-                    if is_let(expr) {
+                    if is_binding(expr) {
                         self.visit(expr);
                     } else {
                         self.visit(expr);
@@ -846,8 +851,8 @@ impl<'a> Compiler<'a> {
 
                             self.emit_op(Op::PushBinding);
                             self.stack_depth += 1;
-                            let biter = self.bindings.iter().rev();
-                            for binding in biter {
+                            // let biter = self.bindings.iter().rev();
+                            for binding in self.bindings.iter() {
                                 if binding.name == *fn_name {
                                     self.emit_byte(binding.stack_pos);
                                     break;
@@ -1256,12 +1261,21 @@ impl<'a> Compiler<'a> {
                     }
                 }
             }
-            Arguments(..)
-            | Placeholder
-            | Do(..)
-            | Splat(..)
-            | InterpolatedPattern(..)
-            | Splattern(..) => todo!(),
+            Do(terms) => {
+                let mut terms = terms.iter();
+                let first = terms.next().unwrap();
+                // put the first value on the stack
+                self.visit(first);
+                for term in terms {
+                    self.visit(term);
+                    self.emit_op(Op::Call);
+                    self.emit_byte(1);
+                    self.stack_depth -= 1;
+                }
+            }
+            Arguments(..) | Placeholder | Splat(..) | InterpolatedPattern(..) | Splattern(..) => {
+                todo!()
+            }
             And | Or => unreachable!(),
         }
     }

src/main.rs

@@ -76,9 +76,13 @@ pub fn run(src: &'static str) {
 pub fn main() {
     env::set_var("RUST_BACKTRACE", "1");
     let src = "
-fn foo () -> :foo
+fn increase (x) -> add (x, 1)
 
-foo
+fn double (x) -> mult (x, 2)
+
+fn halve (x) -> div (x, 2)
+
+do 1 > increase > double > increase > halve
 
 
     ";