Broken structure now gets through syntax evaluator.

src/syntax/eval.rs

@@ -2,6 +2,7 @@ use crate::eval::{EvalError, PrimitiveType, Value};
 use crate::syntax::{ConstantType, Expression, Name, Program, Statement, TopLevel};
 use crate::util::scoped_map::ScopedMap;
 use internment::ArcIntern;
+use std::collections::HashMap;
 use std::str::FromStr;
 
 impl Program {
@@ -23,11 +24,15 @@ impl Program {
 
         for stmt in self.items.iter() {
             match stmt {
-                TopLevel::Function(name, arg_names, body) => {
+                TopLevel::Function(name, arg_names, _, body) => {
                     last_result = Value::Closure(
                         name.clone().map(Name::intern),
                         env.clone(),
-                        arg_names.iter().cloned().map(Name::intern).collect(),
+                        arg_names
+                            .iter()
+                            .cloned()
+                            .map(|(x, _)| Name::intern(x))
+                            .collect(),
                         body.clone(),
                     );
                     if let Some(name) = name {
@@ -36,6 +41,10 @@ impl Program {
                 }
 
                 TopLevel::Statement(stmt) => last_result = stmt.eval(&mut stdout, &mut env)?,
+
+                TopLevel::Structure(_, _, _) => {
+                    last_result = Value::Void;
+                }
             }
         }
 
@@ -98,11 +107,43 @@ impl Expression {
                 },
             },
 
+            Expression::Constructor(_, on, fields) => {
+                let mut map = HashMap::with_capacity(fields.len());
+
+                for (k, v) in fields.iter() {
+                    map.insert(k.clone().intern(), v.eval(stdout, env)?);
+                }
+
+                Ok(Value::Structure(Some(on.clone().intern()), map))
+            }
+
             Expression::Reference(loc, n) => env
                 .get(&ArcIntern::new(n.clone()))
                 .ok_or_else(|| EvalError::LookupFailed(loc.clone(), n.clone()))
                 .cloned(),
 
+            Expression::FieldRef(loc, expr, field) => {
+                let struck = expr.eval(stdout, env)?;
+
+                if let Value::Structure(on, mut fields) = struck {
+                    if let Some(value) = fields.remove(&field.clone().intern()) {
+                        Ok(value)
+                    } else {
+                        Err(EvalError::BadFieldForStructure(
+                            loc.clone(),
+                            on,
+                            field.clone().intern(),
+                        ))
+                    }
+                } else {
+                    Err(EvalError::NoFieldForValue(
+                        loc.clone(),
+                        struck,
+                        field.clone().intern(),
+                    ))
+                }
+            }
+
             Expression::Cast(_, target, expr) => {
                 let target_type = PrimitiveType::from_str(target)?;
                 let value = expr.eval(stdout, env)?;