Fixes to dynamic constant usage

hercules_opt/src/fork_guard_elim.rs

 use std::collections::{HashMap, HashSet};
+use std::ops::Deref;
 
 use hercules_ir::*;
 
@@ -70,22 +71,24 @@ fn guarded_fork(
     };
 
     let mut factors = factors.iter().enumerate().map(|(idx, dc)| {
-        let DynamicConstant::Max(l, r) = *editor.get_dynamic_constant(*dc) else {
+        let factor = editor.get_dynamic_constant(*dc);
+        let DynamicConstant::Max(xs) = factor.deref() else {
             return Factor::Normal(*dc);
         };
 
-        // There really needs to be a better way to work w/ associativity.
-        let binding = [(l, r), (r, l)];
-        let id = binding.iter().find_map(|(a, b)| {
-            let DynamicConstant::Constant(1) = *editor.get_dynamic_constant(*a) else {
-                return None;
-            };
-            Some(b)
-        });
-
-        match id {
-            Some(v) => Factor::Max(idx, *v),
-            None => Factor::Normal(*dc),
+        // Filter out any terms which are just 1s
+        let non_ones = xs.iter().filter(|i| {
+            if let DynamicConstant::Constant(1) = editor.get_dynamic_constant(**i).deref() {
+                false
+            } else {
+                true
+            }
+        }).collect::<Vec<_>>();
+        // If we're left with just one term x, we had max { 1, x }
+        if non_ones.len() == 1 {
+            Factor::Max(idx, *non_ones[0])
+        } else {
+            Factor::Normal(*dc)
         }
     });
 

hercules_opt/src/forkify.rs

@@ -265,9 +265,8 @@ pub fn forkify_loop(
     let bound_dc_id = {
         let mut max_id = DynamicConstantID::new(0);
         editor.edit(|mut edit| {
-            // FIXME: Maybe add_dynamic_constant should intern?
             let one_id = edit.add_dynamic_constant(DynamicConstant::Constant(1));
-            max_id = edit.add_dynamic_constant(DynamicConstant::Max(one_id, bound_dc_id));
+            max_id = edit.add_dynamic_constant(DynamicConstant::max(one_id, bound_dc_id));
             Ok(edit)
         });
         max_id

hercules_test/hercules_interpreter/src/interpreter.rs

@@ -69,17 +69,17 @@ pub fn dyn_const_value(
     match dc {
         DynamicConstant::Constant(v) => *v,
         DynamicConstant::Parameter(v) => dyn_const_params[*v],
-        DynamicConstant::Add(a, b) => {
-            dyn_const_value(a, dyn_const_values, dyn_const_params)
-                + dyn_const_value(b, dyn_const_values, dyn_const_params)
+        DynamicConstant::Add(xs) => {
+            xs.iter().map(|x| dyn_const_value(x, dyn_const_values, dyn_const_params))
+                .fold(0, |s, v| s + v)
         }
         DynamicConstant::Sub(a, b) => {
             dyn_const_value(a, dyn_const_values, dyn_const_params)
                 - dyn_const_value(b, dyn_const_values, dyn_const_params)
         }
-        DynamicConstant::Mul(a, b) => {
-            dyn_const_value(a, dyn_const_values, dyn_const_params)
-                * dyn_const_value(b, dyn_const_values, dyn_const_params)
+        DynamicConstant::Mul(xs) => {
+            xs.iter().map(|x| dyn_const_value(x, dyn_const_values, dyn_const_params))
+                .fold(1, |p, v| p * v)
         }
         DynamicConstant::Div(a, b) => {
             dyn_const_value(a, dyn_const_values, dyn_const_params)
@@ -89,14 +89,28 @@ pub fn dyn_const_value(
             dyn_const_value(a, dyn_const_values, dyn_const_params)
                 % dyn_const_value(b, dyn_const_values, dyn_const_params)
         }
-        DynamicConstant::Max(a, b) => max(
-            dyn_const_value(a, dyn_const_values, dyn_const_params),
-            dyn_const_value(b, dyn_const_values, dyn_const_params),
-        ),
-        DynamicConstant::Min(a, b) => min(
-            dyn_const_value(a, dyn_const_values, dyn_const_params),
-            dyn_const_value(b, dyn_const_values, dyn_const_params),
-        ),
+        DynamicConstant::Max(xs) => {
+            xs.iter().map(|x| dyn_const_value(x, dyn_const_values, dyn_const_params))
+                .fold(None, |m, v| {
+                    if let Some(m) = m {
+                        Some(max(m, v))
+                    } else {
+                        Some(v)
+                    }
+                })
+                .unwrap()
+        }
+        DynamicConstant::Min(xs) => {
+            xs.iter().map(|x| dyn_const_value(x, dyn_const_values, dyn_const_params))
+                .fold(None, |m, v| {
+                    if let Some(m) = m {
+                        Some(min(m, v))
+                    } else {
+                        Some(v)
+                    }
+                })
+                .unwrap()
+        }
     }
 }