todo: arbitrary ir

src/eval/value.rs

@@ -1,6 +1,6 @@
-use super::EvalError;
+use crate::util::scoped_map::ScopedMap;
+use internment::ArcIntern;
 use std::fmt;
-use std::rc::Rc;
 
 /// Values in the interpreter.
 ///
@@ -8,7 +8,8 @@ use std::rc::Rc;
 /// are almost entirely identical. However, it's nice to have them separated
 /// by type so that we don't mix them up.
 #[derive(Clone)]
-pub enum Value {
+pub enum Value<IR> {
+    Void,
     I8(i8),
     I16(i16),
     I32(i32),
@@ -17,14 +18,44 @@ pub enum Value {
     U16(u16),
     U32(u32),
     U64(u64),
-    Function(
-        Option<String>,
-        Rc<dyn Fn(Vec<Value>) -> Result<Value, EvalError>>,
+    Closure(
+        Option<ArcIntern<String>>,
+        ScopedMap<ArcIntern<String>, Value<IR>>,
+        Vec<ArcIntern<String>>,
+        IR,
     ),
 }
 
-fn format_value(value: &Value, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+impl<IR: Clone> Value<IR> {
+    /// Given a Value associated with some expression type, just strip out
+    /// the expressions and replace them with unit.
+    ///
+    /// Doing this transformation will likely make this value useless for
+    /// computation, but is very useful in allowing equivalence checks.
+    pub fn strip(&self) -> Value<()> {
+        match self {
+            Value::Void => Value::Void,
+            Value::U8(x) => Value::U8(*x),
+            Value::U16(x) => Value::U16(*x),
+            Value::U32(x) => Value::U32(*x),
+            Value::U64(x) => Value::U64(*x),
+            Value::I8(x) => Value::I8(*x),
+            Value::I16(x) => Value::I16(*x),
+            Value::I32(x) => Value::I32(*x),
+            Value::I64(x) => Value::I64(*x),
+            Value::Closure(name, env, args, _) => {
+                let new_env = env
+                    .clone()
+                    .map_values(|x| x.strip());
+                Value::Closure(name.clone(), new_env, args.clone(), ())
+            }
+        }
+    }
+}
+
+fn format_value<IR>(value: &Value<IR>, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     match value {
+        Value::Void => write!(f, "<void>"),
         Value::I8(x) => write!(f, "{}i8", x),
         Value::I16(x) => write!(f, "{}i16", x),
         Value::I32(x) => write!(f, "{}i32", x),
@@ -33,26 +64,27 @@ fn format_value(value: &Value, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         Value::U16(x) => write!(f, "{}u16", x),
         Value::U32(x) => write!(f, "{}u32", x),
         Value::U64(x) => write!(f, "{}u64", x),
-        Value::Function(Some(name), _) => write!(f, "<function {}>", name),
-        Value::Function(None, _) => write!(f, "<function>"),
+        Value::Closure(Some(name), _, _, _) => write!(f, "<function {}>", name),
+        Value::Closure(None, _, _, _) => write!(f, "<function>"),
     }
 }
 
-impl fmt::Debug for Value {
+impl<IR> fmt::Debug for Value<IR> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         format_value(self, f)
     }
 }
 
-impl fmt::Display for Value {
+impl<IR> fmt::Display for Value<IR> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         format_value(self, f)
     }
 }
 
-impl PartialEq for Value {
-    fn eq(&self, other: &Self) -> bool {
+impl<IR1, IR2> PartialEq<Value<IR2>> for Value<IR1> {
+    fn eq(&self, other: &Value<IR2>) -> bool {
         match self {
+            Value::Void => matches!(other, Value::Void),
             Value::I8(x) => match other {
                 Value::I8(y) => x == y,
                 _ => false,
@@ -85,58 +117,54 @@ impl PartialEq for Value {
                 Value::U64(y) => x == y,
                 _ => false,
             },
-            Value::Function(Some(x), _) => match other {
-                Value::Function(Some(y), _) => x == y,
-                _ => false,
-            },
-            Value::Function(None, _) => false,
+            Value::Closure(_, _, _, _) => false,
         }
     }
 }
 
-impl From<i8> for Value {
+impl<IR> From<i8> for Value<IR> {
     fn from(value: i8) -> Self {
         Value::I8(value)
     }
 }
 
-impl From<i16> for Value {
+impl<IR> From<i16> for Value<IR> {
     fn from(value: i16) -> Self {
         Value::I16(value)
     }
 }
 
-impl From<i32> for Value {
+impl<IR> From<i32> for Value<IR> {
     fn from(value: i32) -> Self {
         Value::I32(value)
     }
 }
 
-impl From<i64> for Value {
+impl<IR> From<i64> for Value<IR> {
     fn from(value: i64) -> Self {
         Value::I64(value)
     }
 }
 
-impl From<u8> for Value {
+impl<IR> From<u8> for Value<IR> {
     fn from(value: u8) -> Self {
         Value::U8(value)
     }
 }
 
-impl From<u16> for Value {
+impl<IR> From<u16> for Value<IR> {
     fn from(value: u16) -> Self {
         Value::U16(value)
     }
 }
 
-impl From<u32> for Value {
+impl<IR> From<u32> for Value<IR> {
     fn from(value: u32) -> Self {
         Value::U32(value)
     }
 }
 
-impl From<u64> for Value {
+impl<IR> From<u64> for Value<IR> {
     fn from(value: u64) -> Self {
         Value::U64(value)
     }