improve do & recur errs

src/main.rs

@@ -167,8 +167,7 @@ pub fn run(src: &'static str) {
 
 pub fn main() {
     let src = "
-box foo = 42
+do 42 > recur ()
-foo
     ";
     run(src);
     // struct_scalpel::print_dissection_info::<value::Value>()

src/validator.rs

@@ -256,7 +256,43 @@ impl<'a> Validator<'a> {
             // check arity is 1 if first term is keyword
             // check arity against fn info if first term is word and second term is args
             Ast::Synthetic(first, second, rest) => {
-                todo!()
+                match (&first.0, &second.0) {
+                    (Ast::Word(_), Ast::Keyword(_)) => {
+                        let (expr, span) = first.as_ref();
+                        self.ast = expr;
+                        self.span = *span;
+                        self.validate();
+                    }
+                    (Ast::Keyword(_), Ast::Arguments(args)) => {
+                        if args.len() != 1 {
+                            self.err("called keywords may only take one argument".to_string())
+                        }
+                        let (expr, span) = second.as_ref();
+                        self.ast = expr;
+                        self.span = *span;
+                        self.validate();
+                    }
+                    (Ast::Word(_), Ast::Arguments(_)) => {
+                        let (expr, span) = first.as_ref();
+                        self.ast = expr;
+                        self.span = *span;
+                        self.validate();
+
+                        let (expr, span) = second.as_ref();
+                        self.ast = expr;
+                        self.span = *span;
+                        self.validate();
+
+                        //TODO: check arity of call
+                    }
+                    _ => unreachable!(),
+                }
+                for term in rest {
+                    let (expr, span) = term;
+                    self.ast = expr;
+                    self.span = *span;
+                    self.validate();
+                }
             }
             Ast::When(clauses) => {
                 // let tailpos = self.status.tail_position;
@@ -355,13 +391,25 @@ impl<'a> Validator<'a> {
                 self.validate();
                 self.status.tail_position = tailpos;
             }
+            // TODO: fix the tail call here?
             Ast::Do(terms) => {
-                for term in terms {
+                if terms.len() < 2 {
+                    return self.err("do expressions must have at least two terms".to_string());
+                }
+                for term in terms.iter().take(terms.len() - 1) {
                     let (expr, span) = term;
                     self.ast = expr;
                     self.span = *span;
                     self.validate();
                 }
+
+                let (expr, span) = terms.last().unwrap();
+                self.ast = expr;
+                self.span = *span;
+                if matches!(expr, Ast::Recur(_)) {
+                    self.err("`recur` may not be used in `do` forms".to_string());
+                }
+                self.validate();
             }
             Ast::Repeat(times, body) => {
                 self.status.tail_position = false;
@@ -393,7 +441,8 @@ impl<'a> Validator<'a> {
             }
             Ast::Recur(args) => {
                 if !self.status.in_loop {
-                    self.err("you may only use `recur` in a loop form".to_string());
+                    self.err("you may only use `recur` in a `loop` form".to_string());
+                    return;
                 }
                 if !self.status.tail_position {
                     self.err("you may only use `recur` in tail position".to_string());