interpret loop & recur

src/main.rs

@@ -13,7 +13,9 @@
 //   - [x] do this to extract/simplify/DRY things like tuple patterns, fn clauses, etc.
 // * [x] Work around chumsky::Stream::from_iter().spanned disappearing in most recent version
 // * [x] investigate using labels (which is behind a compiler flag, somehow)
+// * [ ] write parsing errors
 // * [ ] wire up Ariadne parsing errors
+// * [ ] add stack traces and code locations to panics
 // * [ ] validation
 // * [x] break this out into multiple files
 // * [x] write a tree-walk VM
@@ -24,8 +26,8 @@
 //     * [x] guards in match clauses
 //     * [x] `as` patterns
 //     * [x] splat patterns in tuples, lists, dicts
-//     * [ ] splats in list and dict literals
+//     * [x] splats in list and dict literals
-//     * [ ] `loop` and `recur`
+//     * [x] `loop` and `recur`
 //     * [ ] string patterns
 //     * [ ] string interpolation
 // * [~] write `base` in Rust
@@ -55,14 +57,13 @@ use crate::base::*;
 
 pub fn main() {
     let src = "
-fn t () -> true
+let foo = false
-fn f () -> false
+loop (foo) with {
-
+    (:foo) -> :done
-fn id {
+    (x as :boolean) -> recur (:bar)
-    (x) if f () -> x
+    (x as :number) -> recur (:foo) 
-    (x) -> :whoops
+    (x as :keyword) -> recur (:foo)
 }
-id (:foo)
     ";
     let (tokens, lex_errs) = lexer().parse(src).into_output_errors();
     if lex_errs.len() > 0 {

src/parser.rs

@@ -32,17 +32,17 @@ impl<'src> fmt::Display for MatchClause<'src> {
     }
 }
 
-#[derive(Clone, Debug, PartialEq)]
+// #[derive(Clone, Debug, PartialEq)]
-pub struct Pair<'src> {
+// pub struct Pair<'src> {
-    pub key: &'src str,
+//     pub key: &'src str,
-    pub value: Spanned<Ast<'src>>,
+//     pub value: Spanned<Ast<'src>>,
-}
+// }
 
-impl<'src> fmt::Display for Pair<'src> {
+// impl<'src> fmt::Display for Pair<'src> {
-    fn fmt(self: &Pair<'src>, f: &mut fmt::Formatter) -> fmt::Result {
+//     fn fmt(self: &Pair<'src>, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "pair: {}: {}", self.key, self.value.0)
+//         write!(f, "pair: {}: {}", self.key, self.value.0)
-    }
+//     }
-}
+// }
 
 #[derive(Clone, Debug, PartialEq)]
 pub enum Ast<'src> {
@@ -59,7 +59,7 @@ pub enum Ast<'src> {
     Tuple(Vec<Spanned<Self>>),
     Arguments(Vec<Spanned<Self>>),
     List(Vec<Spanned<Self>>),
-    Dict(Vec<Pair<'src>>),
+    Dict(Vec<Spanned<Self>>),
     Let(Box<Spanned<Pattern<'src>>>, Box<Spanned<Self>>),
     Box(&'src str, Box<Spanned<Self>>),
     Synthetic(Box<Spanned<Self>>, Box<Spanned<Self>>, Vec<Spanned<Self>>),
@@ -70,8 +70,10 @@ pub enum Ast<'src> {
     Panic(Box<Spanned<Self>>),
     Do(Vec<Spanned<Self>>),
     Repeat(Box<Spanned<Self>>, Box<Spanned<Self>>),
-    // Loop(Box<Spanned<Self>>, Vec<Spanned<Self>>),
+    Splat(&'src str),
-    // Recur(Vec<Spanned<Self>>),
+    Pair(&'src str, Box<Spanned<Self>>),
+    Loop(Box<Spanned<Self>>, Vec<MatchClause<'src>>),
+    Recur(Vec<Spanned<Self>>),
 }
 
 impl<'src> fmt::Display for Ast<'src> {
@@ -105,7 +107,7 @@ impl<'src> fmt::Display for Ast<'src> {
                 "#{{{}}}",
                 entries
                     .iter()
-                    .map(|pair| pair.to_string())
+                    .map(|pair| (*pair).0.to_string())
                     .collect::<Vec<_>>()
                     .join(", ")
             ),
@@ -184,8 +186,33 @@ impl<'src> fmt::Display for Ast<'src> {
                 )
             }
             Ast::Repeat(_times, _body) => todo!(),
-            // Ast::Loop(init, body) => todo!(),
+            Ast::Splat(word) => {
-            // Ast::Recur(args) => todo!(),
+                write!(f, "splat: {}", word)
+            }
+            Ast::Pair(k, v) => {
+                write!(f, "pair: {} {}", k, (*v).0.to_string())
+            }
+            Ast::Loop(init, body) => {
+                write!(
+                    f,
+                    "loop: {} with {}",
+                    (*init).0.to_string(),
+                    body.iter()
+                        .map(|clause| clause.to_string())
+                        .collect::<Vec<_>>()
+                        .join("\n")
+                )
+            }
+            Ast::Recur(args) => {
+                write!(
+                    f,
+                    "recur: {}",
+                    args.iter()
+                        .map(|(arg, _)| arg.to_string())
+                        .collect::<Vec<_>>()
+                        .join(", ")
+                )
+            }
         }
     }
 }
@@ -428,8 +455,22 @@ where
             )
         });
 
+    let splat = just(Token::Punctuation("..."))
+        .ignore_then(word.clone())
+        .map_with(|(w, _), e| {
+            (
+                Ast::Splat(if let Ast::Word(w) = w {
+                    w
+                } else {
+                    unreachable!()
+                }),
+                e.span(),
+            )
+        });
+
     let list = simple
         .clone()
+        .or(splat.clone())
         .separated_by(separators.clone())
         .allow_leading()
         .allow_trailing()
@@ -439,15 +480,14 @@ where
 
     let pair = select! {Token::Keyword(k) => k}
         .then(simple.clone())
-        .map_with(|(key, value), e| Pair { key, value });
+        .map_with(|(key, value), e| (Ast::Pair(key, Box::new(value)), e.span()));
 
-    let shorthand = select! {Token::Word(w) => w}.map_with(|w, e| Pair {
+    let shorthand = select! {Token::Word(w) => w}
-        key: w,
+        .map_with(|w, e| (Ast::Pair(w, Box::new((Ast::Word(w), e.span()))), e.span()));
-        value: ((Ast::Word(w), e.span())),
-    });
 
     let dict = pair
         .or(shorthand)
+        .or(splat.clone())
         .separated_by(separators.clone())
         .allow_leading()
         .allow_trailing()
@@ -458,12 +498,22 @@ where
         )
         .map_with(|dict, e| (Ast::Dict(dict), e.span()));
 
+    let recur = just(Token::Reserved("recur"))
+        .ignore_then(tuple.clone())
+        .map_with(|args, e| {
+            let (Ast::Tuple(args), _) = args else {
+                unreachable!()
+            };
+            (Ast::Recur(args), e.span())
+        });
+
     simple.define(
         synthetic
+            .or(recur)
             .or(word)
             .or(keyword)
             .or(value)
-            .or(tuple)
+            .or(tuple.clone())
             .or(list)
             .or(dict)
             .labelled("simple expression"),
@@ -599,7 +649,7 @@ where
         })
         .labelled("function clause");
 
-    let fn_clause = tuple_pattern
+    let fn_unguarded = tuple_pattern
         .clone()
         .then_ignore(just(Token::Punctuation("->")))
         .then(nonbinding.clone())
@@ -610,10 +660,28 @@ where
         })
         .labelled("function clause");
 
+    let fn_clause = fn_guarded.clone().or(fn_unguarded.clone());
+
     let lambda = just(Token::Reserved("fn"))
-        .ignore_then(fn_clause.clone())
+        .ignore_then(fn_unguarded.clone())
         .map_with(|clause, e| (Ast::Fn("anonymous", vec![clause]), e.span()));
 
+    let fn_multiclause = fn_clause
+        .clone()
+        .separated_by(terminators.clone())
+        .allow_leading()
+        .allow_trailing()
+        .collect()
+        .delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}")));
+
+    let fn_single_clause = fn_clause.clone().map_with(|c, e| vec![c]);
+
+    let r#loop = just(Token::Reserved("loop"))
+        .ignore_then(tuple.clone())
+        .then_ignore(just(Token::Reserved("with")))
+        .then(fn_multiclause.clone().or(fn_single_clause.clone()))
+        .map_with(|(init, body), e| (Ast::Loop(Box::new(init), body), e.span()));
+
     nonbinding.define(
         simple
             .clone()
@@ -623,6 +691,7 @@ where
             .or(panic)
             .or(do_)
             .or(repeat)
+            .or(r#loop)
             .labelled("nonbinding expression"),
     );
 
@@ -658,18 +727,9 @@ where
             (Ast::FnDeclaration(name), e.span())
         });
 
-    // let tuple_pattern = pattern
-    //     .clone()
-    //     .separated_by(separators.clone())
-    //     .allow_leading()
-    //     .allow_trailing()
-    //     .collect()
-    //     .delimited_by(just(Token::Punctuation("(")), just(Token::Punctuation(")")))
-    //     .map_with(|tuple, e| (Pattern::Tuple(tuple), e.span()));
-
     let fn_named = just(Token::Reserved("fn"))
         .ignore_then(word.clone())
-        .then(fn_clause.clone().or(fn_guarded.clone()))
+        .then(fn_unguarded.clone())
         .map_with(|(word, clause), e| {
             let name = if let Ast::Word(word) = word.0 {
                 word
@@ -681,16 +741,7 @@ where
 
     let fn_compound = just(Token::Reserved("fn"))
         .ignore_then(word.clone())
-        .then(
+        .then(fn_multiclause.clone())
-            fn_clause
-                .clone()
-                .or(fn_guarded.clone())
-                .separated_by(terminators.clone())
-                .allow_leading()
-                .allow_trailing()
-                .collect()
-                .delimited_by(just(Token::Punctuation("{")), just(Token::Punctuation("}"))),
-        )
         .map_with(|(word, clauses), e| {
             let name = if let Ast::Word(word) = word.0 {
                 word

src/value.rs

@@ -25,10 +25,12 @@ pub enum Value<'src> {
     // ref-counted, immutable, persistent
     List(Vector<Self>),
     // ref-counted, immutable, persistent
+    // dicts may only use keywords as keys
     Dict(HashMap<&'src str, Self>),
     Box(&'src str, Rc<RefCell<Self>>),
     Fn(Rc<Fn<'src>>),
     Base(Base<'src>),
+    Recur(Vec<Self>),
     // Set(HashSet<Self>),
     // Sets are hard
     // Sets require Eq
@@ -57,6 +59,7 @@ impl<'src> Clone for Value<'src> {
             Value::Box(name, b) => Value::Box(name, b.clone()),
             Value::Placeholder => Value::Placeholder,
             Value::Base(b) => Value::Base(b.clone()),
+            Value::Recur(..) => unreachable!(),
         }
     }
 }
@@ -111,6 +114,7 @@ impl<'src> fmt::Display for Value<'src> {
                 };
                 write!(f, "base fn {}", name)
             }
+            Value::Recur(..) => unreachable!(),
         }
     }
 }
@@ -138,6 +142,7 @@ impl<'src> Value<'src> {
             Value::Placeholder => unreachable!(),
             Value::Args(_) => unreachable!(),
             Value::Base(_) => Value::Keyword("fn"),
+            Value::Recur(..) => unreachable!(),
         }
     }
 }

src/vm.rs

@@ -322,8 +322,20 @@ pub fn eval<'src, 'a>(
         Ast::List(members) => {
             let mut vect = Vector::new();
             for member in members {
+                if let Ast::Splat(_) = member.0 {
+                    let to_splat = eval(&member.0, ctx)?;
+                    match to_splat {
+                        Value::List(list) => vect.append(list),
+                        _ => {
+                            return Err(LudusError {
+                                msg: "only lists may be splatted into lists".to_string(),
+                            })
+                        }
+                    }
+                } else {
                     vect.push_back(eval(&member.0, ctx)?)
                 }
+            }
             Ok(Value::List(vect))
         }
         Ast::Tuple(members) => {
@@ -333,7 +345,7 @@ pub fn eval<'src, 'a>(
             }
             Ok(Value::Tuple(Rc::new(vect)))
         }
-        Ast::Word(w) => {
+        Ast::Word(w) | Ast::Splat(w) => {
             let val = if let Some((_, value)) = ctx.iter().rev().find(|(name, _)| w == name) {
                 value.clone()
             } else {
@@ -372,12 +384,27 @@ pub fn eval<'src, 'a>(
                 Ok(Value::Tuple(Rc::new(args)))
             }
         }
-        Ast::Dict(pairs) => {
+        Ast::Dict(terms) => {
             let mut dict = HashMap::new();
-            for Pair { key, value } in pairs {
+            for term in terms {
+                let (term, _) = term;
+                match term {
+                    Ast::Pair(key, value) => {
                         let value = eval(&value.0, ctx)?;
                         dict.insert(*key, value);
                     }
+                    Ast::Splat(_) => {
+                        let resolved = eval(term, ctx)?;
+                        let Value::Dict(to_splat) = resolved else {
+                            return Err(LudusError {
+                                msg: "cannot splat non-dict into dict".to_string(),
+                            });
+                        };
+                        dict = to_splat.union(dict);
+                    }
+                    _ => unreachable!(),
+                }
+            }
             Ok(Value::Dict(dict))
         }
         Ast::Box(name, expr) => {
@@ -451,7 +478,27 @@ pub fn eval<'src, 'a>(
                 result = apply(next, arg, ctx)?;
             }
             Ok(result)
-        } // Ast::Loop(_, _) => todo!(),
+        }
-          // Ast::Recur(_) => todo!(),
+        Ast::Pair(..) => {
+            unreachable!()
+        }
+        Ast::Loop(init, clauses) => {
+            let mut args = eval(&init.0, ctx)?;
+            loop {
+                let result = match_clauses(&args, clauses, ctx)?;
+                if let Value::Recur(recur_args) = result {
+                    args = Value::Tuple(Rc::new(recur_args));
+                } else {
+                    return Ok(result);
+                }
+            }
+        }
+        Ast::Recur(args) => {
+            let mut vect = Vec::new();
+            for arg in args {
+                vect.push(eval(&arg.0, ctx)?);
+            }
+            Ok(Value::Recur(vect))
+        }
     }
 }