feat!: Allow CustomConsts to (optionally) be hashable

hugr-core/src/extension/prelude.rs

@@ -224,7 +224,7 @@ pub const STRING_CUSTOM_TYPE: CustomType =
 /// String type.
 pub const STRING_TYPE: Type = Type::new_extension(STRING_CUSTOM_TYPE);
 
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 /// Structure for holding constant string values.
 pub struct ConstString(String);
 
@@ -276,7 +276,7 @@ pub fn sum_with_error(ty: Type) -> SumType {
     SumType::new([ty, ERROR_TYPE])
 }
 
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 /// Structure for holding constant usize values.
 pub struct ConstUsize(u64);
 
@@ -311,7 +311,7 @@ impl CustomConst for ConstUsize {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 /// Structure for holding constant usize values.
 pub struct ConstError {
     /// Integer tag/signal for the error.
@@ -348,7 +348,7 @@ impl CustomConst for ConstError {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
 /// A structure for holding references to external symbols.
 pub struct ConstExternalSymbol {
     /// The symbol name that this value refers to. Must be nonempty.

hugr-core/src/ops/constant.rs

@@ -2,6 +2,9 @@
 
 mod custom;
 
+use std::collections::hash_map::DefaultHasher; // Moves into std::hash in Rust 1.76.
+use std::hash::{Hash, Hasher};
+
 use super::{NamedOp, OpName, OpTrait, StaticTag};
 use super::{OpTag, OpType};
 use crate::extension::ExtensionSet;
@@ -16,7 +19,7 @@ use thiserror::Error;
 
 pub use custom::{
     downcast_equal_consts, get_pair_of_input_values, get_single_input_value, CustomConst,
-    CustomSerialized,
+    CustomSerialized, MaybeHash,
 };
 
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
@@ -134,6 +137,24 @@ impl Sum {
         // For valid instances, the type row will not have any row variables.
         self.sum_type.as_tuple().map(|_| self.values.as_ref())
     }
+
+    fn maybe_hash<H: Hasher>(&self, st: &mut H) -> bool {
+        maybe_hash_values(&self.values, st) && {
+            st.write_usize(self.tag);
+            self.sum_type.hash(st);
+            true
+        }
+    }
+}
+
+pub(crate) fn maybe_hash_values<H: Hasher>(vals: &[Value], st: &mut H) -> bool {
+    // We can't mutate the Hasher with the first element
+    // if any element, even the last, fails.
+    let mut hasher = DefaultHasher::new();
+    vals.iter().all(|e| e.maybe_hash(&mut hasher)) && {
+        st.write_u64(hasher.finish());
+        true
+    }
 }
 
 impl TryFrom<SerialSum> for Sum {
@@ -508,6 +529,17 @@ impl Value {
             None
         }
     }
+
+    /// Hashes this value, if possible. [Value::Extension]s are hashable according
+    /// to their implementation of [MaybeHash]; [Value::Function]s never are;
+    /// [Value::Sum]s are if their contents are.
+    pub fn maybe_hash<H: Hasher>(&self, st: &mut H) -> bool {
+        match self {
+            Value::Extension { e } => e.value().maybe_hash(&mut Box::new(st)),
+            Value::Function { .. } => false,
+            Value::Sum(s) => s.maybe_hash(st),
+        }
+    }
 }
 
 impl<T> From<T> for Value
@@ -547,7 +579,7 @@ mod test {
 
     use super::*;
 
-    #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+    #[derive(Debug, Clone, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
     /// A custom constant value used in testing
     pub(crate) struct CustomTestValue(pub CustomType);
 

hugr-core/src/ops/constant/custom.rs

@@ -5,19 +5,17 @@
 //! [`Const`]: crate::ops::Const
 
 use std::any::Any;
+use std::hash::{Hash, Hasher};
 
 use downcast_rs::{impl_downcast, Downcast};
 use thiserror::Error;
 
 use crate::extension::ExtensionSet;
 use crate::macros::impl_box_clone;
-
 use crate::types::{CustomCheckFailure, Type};
 use crate::IncomingPort;
 
-use super::Value;
-
-use super::ValueName;
+use super::{Value, ValueName};
 
 /// Extensible constant values.
 ///
@@ -37,7 +35,7 @@ use super::ValueName;
 ///   extension::ExtensionSet, std_extensions::arithmetic::int_types};
 /// use serde_json::json;
 ///
-/// #[derive(std::fmt::Debug, Clone, Serialize,Deserialize)]
+/// #[derive(std::fmt::Debug, Clone, Hash, Serialize,Deserialize)]
 /// struct CC(i64);
 ///
 /// #[typetag::serde]
@@ -55,7 +53,7 @@ use super::ValueName;
 /// ```
 #[typetag::serde(tag = "c", content = "v")]
 pub trait CustomConst:
-    Send + Sync + std::fmt::Debug + CustomConstBoxClone + Any + Downcast
+    Send + Sync + std::fmt::Debug + MaybeHash + CustomConstBoxClone + Any + Downcast
 {
     /// An identifier for the constant.
     fn name(&self) -> ValueName;
@@ -90,6 +88,33 @@ pub trait CustomConst:
     fn get_type(&self) -> Type;
 }
 
+/// Prerequisite for `CustomConst`. Allows to declare a custom hash function, but the easiest
+/// options are either to `impl MaybeHash for ... {}` to declare "not hashable", or else
+/// to implement (or derive) [Hash].
+pub trait MaybeHash {
+    /// Hashes the value, if possible; else return `false` without mutating the `Hasher`.
+    /// This relates with [CustomConst::equal_consts] just like [Hash] with [Eq]:
+    /// * if `x.equal_consts(y)` ==> `x.maybe_hash(s)` behaves equivalently to `y.maybe_hash(s)`
+    /// * if `x.hash(s)` behaves differently from `y.hash(s)` ==> `x.equal_consts(y) == false`
+    ///
+    /// As with [Hash], these requirements can trivially be satisfied by either
+    /// * `equal_consts` always returning `false`, or
+    /// * `maybe_hash` always behaving the same (e.g. returning `false`, as it does by default)
+    ///
+    /// Note: this uses `dyn` rather than being parametrized by `<H: Hasher>` so that we can
+    /// still use `dyn CustomConst`.
+    fn maybe_hash(&self, _state: &mut dyn Hasher) -> bool {
+        false
+    }
+}
+
+impl<T: Hash> MaybeHash for T {
+    fn maybe_hash(&self, st: &mut dyn Hasher) -> bool {
+        Hash::hash(self, &mut Box::new(st));
+        true
+    }
+}
+
 impl PartialEq for dyn CustomConst {
     fn eq(&self, other: &Self) -> bool {
         (*self).equal_consts(other)
@@ -253,6 +278,14 @@ impl CustomSerialized {
     }
 }
 
+impl MaybeHash for CustomSerialized {
+    fn maybe_hash(&self, state: &mut dyn Hasher) -> bool {
+        // Consistent with equality, same serialization <=> same hash.
+        self.value.to_string().hash(&mut Box::new(state));
+        true
+    }
+}
+
 #[typetag::serde]
 impl CustomConst for CustomSerialized {
     fn name(&self) -> ValueName {

hugr-core/src/std_extensions/arithmetic/float_types.rs

@@ -1,6 +1,6 @@
 //! Basic floating-point types
 
-use crate::ops::constant::ValueName;
+use crate::ops::constant::{MaybeHash, ValueName};
 use crate::types::TypeName;
 use crate::{
     extension::{ExtensionId, ExtensionSet},
@@ -56,6 +56,8 @@ impl ConstF64 {
     }
 }
 
+impl MaybeHash for ConstF64 {}
+
 #[typetag::serde]
 impl CustomConst for ConstF64 {
     fn name(&self) -> ValueName {

hugr-core/src/std_extensions/arithmetic/int_types.rs

@@ -87,7 +87,7 @@ const fn type_arg(log_width: u8) -> TypeArg {
 }
 
 /// An integer (either signed or unsigned)
-#[derive(Clone, Debug, Eq, PartialEq, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]
 pub struct ConstInt {
     log_width: u8,
     // We always use a u64 for the value. The interpretation is:

hugr-core/src/std_extensions/collections.rs

@@ -1,10 +1,12 @@
 //! List type and operations.
 
+use std::hash::{Hash, Hasher};
+
 use itertools::Itertools;
 use lazy_static::lazy_static;
 use serde::{Deserialize, Serialize};
 
-use crate::ops::constant::ValueName;
+use crate::ops::constant::{maybe_hash_values, MaybeHash, ValueName};
 use crate::ops::{OpName, Value};
 use crate::types::TypeName;
 use crate::{
@@ -56,6 +58,16 @@ impl ListValue {
     }
 }
 
+impl MaybeHash for ListValue {
+    fn maybe_hash(&self, st: &mut dyn Hasher) -> bool {
+        let mut b = Box::new(st);
+        maybe_hash_values(&self.0, &mut b) && {
+            self.1.hash(&mut b);
+            true
+        }
+    }
+}
+
 #[typetag::serde]
 impl CustomConst for ListValue {
     fn name(&self) -> ValueName {