added ,@ (comma splice) operation

src/interpreter.rs

@@ -66,8 +66,31 @@ fn eval_inner(
                     // do nothing, handle it down below
                 }
                 _ => {
+                    // @cesar - this is modified to support splicing, with a flat map feature.
                     return list
                         .into_iter()
+                        .map(|el| -> Result<Vec<Value>, RuntimeError> {
+                            match el {
+                                Value::List(x) if x != List::NIL => match &x.car() {
+                                    Ok(Value::Symbol(Symbol(keyword))) if keyword == "splice" => {
+                                        let arg1 = x.cdr().car()?;
+                                        let eval_arg =
+                                            eval_inner(env.clone(), &arg1, context.quoting(false))?;
+                                        let tmp = [eval_arg];
+                                        let arg2 = require_typed_arg::<&List>(keyword, &tmp, 0)?;
+                                        let arg3 = arg2.into_iter().collect::<Vec<_>>();
+                                        Ok(arg3)
+                                    }
+                                    Ok(v) => Ok(vec![v.clone()]),
+                                    Err(e) => Err(e.clone()),
+                                },
+                                _ => Ok(vec![el]),
+                            }
+                        })
+                        .collect::<Result<Vec<_>, RuntimeError>>()
+                        .into_iter()
+                        .flat_map(|x| x.into_iter())
+                        .flat_map(|x| x.into_iter())
                         .map(|el| eval_inner(env.clone(), &el, context))
                         .collect::<Result<List, RuntimeError>>()
                         .map(Value::List);

src/parser.rs

@@ -36,6 +36,7 @@ enum ParseTree {
     List(Vec<ParseTree>),
     Quoted(Box<ParseTree>),
     Comma(Box<ParseTree>),
+    CommaSplice(Box<ParseTree>),
 }
 
 impl ParseTree {
@@ -49,6 +50,7 @@ impl ParseTree {
             ),
             ParseTree::Quoted(inner) => lisp! { (quote {inner.into_value()}) },
             ParseTree::Comma(inner) => lisp! { (comma {inner.into_value()}) },
+            ParseTree::CommaSplice(inner) => lisp! { (splice {inner.into_value()}) },
         }
     }
 }
@@ -120,6 +122,7 @@ fn parse_list(code: &str, index: usize) -> ParseResult {
 fn parse_atom(code: &str, index: usize) -> ParseResult {
     for func in [
         parse_quoted,
+        parse_comma_splice,
         parse_comma,
         parse_nil,
         parse_false,
@@ -152,6 +155,20 @@ fn parse_quoted(code: &str, index: usize) -> ParseResult {
     }
 }
 
+fn parse_comma_splice(code: &str, index: usize) -> ParseResult {
+    let index = consume(code, index, ",@")?;
+    let res = parse_expression(code, index)?;
+
+    if let Ok(ParsedAndIndex { parsed, index }) = res {
+        Some(Ok(ParsedAndIndex {
+            parsed: ParseTree::CommaSplice(Box::new(parsed)),
+            index,
+        }))
+    } else {
+        Some(res)
+    }
+}
+
 fn parse_comma(code: &str, index: usize) -> ParseResult {
     let index = consume(code, index, ",")?;
     let res = parse_expression(code, index)?;