From dbf5886aadf63850cc1b59abd161b840549502e9 Mon Sep 17 00:00:00 2001
From: greg <greg.shuflin@protonmail.com>
Date: Sat, 18 Feb 2017 03:09:36 -0800
Subject: [PATCH] List evaluation technically working

---
 src/schala_lang/eval.rs   | 17 +++++++++++++++++
 src/schala_lang/parser.rs | 10 +++++++++-
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/src/schala_lang/eval.rs b/src/schala_lang/eval.rs
index 2889f59..1f5e1f9 100644
--- a/src/schala_lang/eval.rs
+++ b/src/schala_lang/eval.rs
@@ -104,6 +104,9 @@ impl Evaluable for Expression {
             StringLiteral(_) => false,
             Lambda(_) => false,
             Number(_) => false,
+            ListLiteral(ref items) => {
+                items.iter().any(|x| x.is_reducible())
+            }
             _ => true,
         }
     }
@@ -327,6 +330,20 @@ impl<'a> Evaluator<'a> {
                     _ => (Null, None)
                 }
             }
+            ListLiteral(mut exprs) => {
+                let mut side_effect = None;
+                for expr in exprs.iter_mut() {
+                    if expr.is_reducible() {
+                        take_mut::take(expr, |expr| {
+                            let (a, b) = self.reduce_expr(expr);
+                            side_effect = b;
+                            a
+                        });
+                        break;
+                    }
+                }
+                (ListLiteral(exprs), side_effect)
+            },
         }
     }
 
diff --git a/src/schala_lang/parser.rs b/src/schala_lang/parser.rs
index 33f9e3d..9bcc4ea 100644
--- a/src/schala_lang/parser.rs
+++ b/src/schala_lang/parser.rs
@@ -74,6 +74,7 @@ pub enum Expression {
     Block(VecDeque<Expression>),
     While(Box<Expression>, Vec<Expression>),
     Index(Box<Expression>, Box<Expression>),
+    ListLiteral(VecDeque<Expression>),
 }
 
 #[derive(Clone, Debug)]
@@ -92,6 +93,9 @@ impl fmt::Display for Expression {
             Lambda(Function { prototype: Prototype { ref name, ref parameters, .. }, .. }) => {
                 write!(f, "«function: {}, {} arg(s)»", name, parameters.len())
             }
+            ListLiteral(ref items) => {
+                write!(f, "[ <a list> ]")
+            }
             _ => write!(f, "UNIMPLEMENTED"),
         }
     }
@@ -444,7 +448,11 @@ impl Parser {
     }
 
     fn list_expr(&mut self) -> ParseResult<Expression> {
-        unimplemented!()
+        expect!(self, LSquareBracket);
+        let exprlist: Vec<Expression> = self.exprlist()?;
+        expect!(self, RSquareBracket);
+
+        Ok(Expression::ListLiteral(VecDeque::from(exprlist)))
     }
 
     fn number_expression(&mut self) -> ParseResult<Expression> {