checkpoint

src/syntax/eval.rs

@@ -35,25 +35,7 @@ impl Program {
                     }
                 }
 
-                TopLevel::Statement(Statement::Binding(_, name, value)) => {
-                    let actual_value = value.eval(&env)?;
-                    env.insert(name.clone().intern(), actual_value);
-                    last_result = Value::Void;
-                }
-
-                TopLevel::Statement(Statement::Print(loc, name)) => {
-                    let value = env
-                        .get(&name.clone().intern())
-                        .ok_or_else(|| EvalError::LookupFailed(loc.clone(), name.name.clone()))?;
-                    let value = if let Value::Number(x) = value {
-                        Value::U64(*x)
-                    } else {
-                        value.clone()
-                    };
-                    let line = format!("{} = {}\n", name, value);
-                    stdout.push_str(&line);
-                    last_result = Value::Void;
-                }
+                TopLevel::Statement(stmt) => last_result = stmt.eval(&mut stdout, &mut env)?,
             }
         }
 
@@ -61,10 +43,41 @@ impl Program {
     }
 }
 
+impl Statement {
+    fn eval(
+        &self,
+        stdout: &mut String,
+        env: &mut ScopedMap<ArcIntern<String>, Value<Expression>>,
+    ) -> Result<Value<Expression>, EvalError<Expression>> {
+        match self {
+            Statement::Binding(_, name, value) => {
+                let actual_value = value.eval(stdout, env)?;
+                env.insert(name.clone().intern(), actual_value);
+                Ok(Value::Void)
+            }
+
+            Statement::Print(loc, name) => {
+                let value = env
+                    .get(&name.clone().intern())
+                    .ok_or_else(|| EvalError::LookupFailed(loc.clone(), name.name.clone()))?;
+                let value = if let Value::Number(x) = value {
+                    Value::U64(*x)
+                } else {
+                    value.clone()
+                };
+                let line = format!("{} = {}\n", name, value);
+                stdout.push_str(&line);
+                Ok(Value::Void)
+            }
+        }
+    }
+}
+
 impl Expression {
     fn eval(
         &self,
-        env: &ScopedMap<ArcIntern<String>, Value<Expression>>,
+        stdout: &mut String,
+        env: &mut ScopedMap<ArcIntern<String>, Value<Expression>>,
     ) -> Result<Value<Expression>, EvalError<Expression>> {
         match self {
             Expression::Value(_, v) => match v {
@@ -90,7 +103,7 @@ impl Expression {
 
             Expression::Cast(_, target, expr) => {
                 let target_type = PrimitiveType::from_str(target)?;
-                let value = expr.eval(env)?;
+                let value = expr.eval(stdout, env)?;
                 Ok(target_type.safe_cast(&value)?)
             }
 
@@ -99,11 +112,21 @@ impl Expression {
 
                 for arg in args.iter() {
                     // yay, recursion! makes this pretty straightforward
-                    arg_values.push(arg.eval(env)?);
+                    arg_values.push(arg.eval(stdout, env)?);
                 }
 
                 Ok(Value::calculate(op, arg_values)?)
             }
+
+            Expression::Block(_, stmts) => {
+                let mut result = Value::Void;
+
+                for stmt in stmts.iter() {
+                    result = stmt.eval(stdout, env)?;
+                }
+
+                Ok(result)
+            }
         }
     }
 }