Use Value::sum, adding FromSum::Err; fmt

Author: acl-cqc

hugr-passes/src/const_fold2/datalog/partial_value.rs

@@ -14,8 +14,13 @@ pub trait AbstractValue: Clone + std::fmt::Debug + PartialEq + Eq + Hash {
     fn as_sum(&self) -> Option<(usize, impl Iterator<Item = Self> + '_)>;
 }
 
-pub trait FromSum {
-    fn new_sum(tag: usize, items: impl IntoIterator<Item=Self>, st: &SumType) -> Self;
+pub trait FromSum: Sized {
+    type Err: std::error::Error;
+    fn try_new_sum(
+        tag: usize,
+        items: impl IntoIterator<Item = Self>,
+        st: &SumType,
+    ) -> Result<Self, Self::Err>;
     fn debug_check_is_type(&self, _ty: &Type) {}
 }
 
@@ -120,7 +125,7 @@ impl<V: AbstractValue> PartialSum<V> {
             .map(|(v, t)| v.clone().try_into_value(t))
             .collect::<Result<Vec<_>, _>>()
         {
-            Ok(vs) => Ok(V2::new_sum(*k, vs, &st)),
+            Ok(vs) => V2::try_new_sum(*k, vs, &st).map_err(|_| self),
             Err(_) => Err(self),
         }
     }

hugr-passes/src/const_fold2/datalog/utils.rs

@@ -3,7 +3,10 @@
 // https://github.com/proptest-rs/proptest/issues/447
 #![cfg_attr(test, allow(non_local_definitions))]
 
-use std::{cmp::Ordering, ops::{Index, IndexMut}};
+use std::{
+    cmp::Ordering,
+    ops::{Index, IndexMut},
+};
 
 use ascent::lattice::{BoundedLattice, Lattice};
 use itertools::zip_eq;
@@ -149,8 +152,9 @@ where
 
 impl<V, Idx> IndexMut<Idx> for ValueRow<V>
 where
-    Vec<PartialValue<V>>: IndexMut<Idx> {
-        fn index_mut(&mut self, index: Idx) -> &mut Self::Output {
+    Vec<PartialValue<V>>: IndexMut<Idx>,
+{
+    fn index_mut(&mut self, index: Idx) -> &mut Self::Output {
         self.0.index_mut(index)
     }
 }

hugr-passes/src/const_fold2/value_handle.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 
 use hugr_core::ops::constant::{CustomConst, Sum};
 use hugr_core::ops::Value;
-use hugr_core::types::Type;
+use hugr_core::types::{ConstTypeError, Type};
 use hugr_core::Node;
 
 use super::datalog::{AbstractValue, FromSum};
@@ -103,8 +103,13 @@ impl AbstractValue for ValueHandle {
 }
 
 impl FromSum for Value {
-    fn new_sum(tag: usize, items: impl IntoIterator<Item=Self>, st: &hugr_core::types::SumType) -> Self {
-        Value::Sum(Sum {tag, values: items.into_iter().collect(), sum_type: st.clone()})
+    type Err = ConstTypeError;
+    fn try_new_sum(
+        tag: usize,
+        items: impl IntoIterator<Item = Self>,
+        st: &hugr_core::types::SumType,
+    ) -> Result<Self, ConstTypeError> {
+        Self::sum(tag, items, st.clone())
     }
 }
 

hugr-passes/src/const_fold2/value_handle/context.rs

@@ -68,7 +68,7 @@ impl<H: HugrView> DFContext<ValueHandle> for HugrValueContext<H> {
         &self,
         n: Node,
         ins: &[(IncomingPort, Value)],
-    ) -> Vec<(OutgoingPort,ValueHandle)> {
+    ) -> Vec<(OutgoingPort, ValueHandle)> {
         match self.0.get_optype(n) {
             OpType::LoadConstant(load_op) => {
                 assert!(ins.is_empty()); // static edge, so need to find constant
@@ -78,14 +78,21 @@ impl<H: HugrView> DFContext<ValueHandle> for HugrValueContext<H> {
                     .unwrap()
                     .0;
                 let const_op = self.0.get_optype(const_node).as_const().unwrap();
-                vec![(OutgoingPort::from(0), ValueHandle::new(
-                    const_node.into(),
-                    Arc::new(const_op.value().clone()),
-                ))]
+                vec![(
+                    OutgoingPort::from(0),
+                    ValueHandle::new(const_node.into(), Arc::new(const_op.value().clone())),
+                )]
             }
             OpType::CustomOp(CustomOp::Extension(op)) => {
-                let ins = ins.into_iter().map(|(p,v)|(*p,v.clone())).collect::<Vec<_>>();
-                op.constant_fold(&ins).map_or(Vec::new(), |outs|outs.into_iter().map(|(p,v)|(p, ValueHandle::new(ValueKey::Node(n), Arc::new(v)))).collect())
+                let ins = ins
+                    .into_iter()
+                    .map(|(p, v)| (*p, v.clone()))
+                    .collect::<Vec<_>>();
+                op.constant_fold(&ins).map_or(Vec::new(), |outs| {
+                    outs.into_iter()
+                        .map(|(p, v)| (p, ValueHandle::new(ValueKey::Node(n), Arc::new(v))))
+                        .collect()
+                })
             }
             _ => vec![],
         }