Sketch out resources + extension mechanism, update CustomType

specification/hugr.md

@@ -713,7 +713,7 @@ resources:
   types:
   - name: QubitVector
     # Opaque types can take type arguments, with specified names
-    args: [["size", u64]]
+    args: [["size", Int]]
   operations:
   - name: measure
     description: "measure a qubit"
@@ -741,9 +741,9 @@ resources:
   - name: MatMul
     description: "Multiply matrices of statically-known size"
     args:  # per-node values passed to type-scheme-interpreter and used in signature
-      - i: U64
-      - j: U64
-      - k: U64
+      - i: Int
+      - j: Int
+      - k: Int
     signature:
       inputs: [["a", Array<i>(Array<j>(F64))], ["b", Array<j>(Array<k>(F64))]]
       outputs: [[null, Array<i>(Array<k>(F64))]]
@@ -752,7 +752,7 @@ resources:
   - name: max_float
     description: "Variable number of inputs"
     args:
-      - n: U64
+      - n: Int
     signature:
       # Where an element of a signature has three subelements, the third is the number of repeats
       inputs: [[null, F64, n]] # (defaulting to 1 if omitted)
@@ -761,19 +761,30 @@ resources:
     description: "Concatenate two arrays. Resource provides a compute_signature implementation."
     args:
       - t: Type  # Classic or Quantum
-      - i: U64
-      - j: U64
+      - i: Int
+      - j: Int
     # inputs could be: Array<i>(t), Array<j>(t)
     # outputs would be, in principle: Array<i+j>(t)
     # - but default type scheme interpreter does not support such addition
     # Hence, no signature block => will look up a compute_signature in registry.
+  - name: GraphOp
+    description: "Involves running an argument Graph. E.g. run it some variable number of times."
+    args:
+      - r: ResourceSet
+    signature:
+      inputs: [[null, Graph[r](Int -> Int)], ["arg", Int]
+      outputs: [[null, Int]]
+      resources: r # Indicates that running this operation also invokes resources r
 ```
 
 The declaration of the `args` uses a language that is a distinct, simplified
 form of the [Type System](#type-system) - writing terminals that appear in the YAML in quotes,
 the value of each member of `args` is given by the following production:
 ```
-TypeParam ::= "Type" | "ClassicType" | "F64" | "U64" | "I64" | "Opaque"(name, ...) | "List"(TypeParam)
+TypeParam ::= "Type" | "ClassicType"
+            | "F64" | "Int"
+            | "Opaque"(name, ...) | "List"(TypeParam)
+            | "ResourceSet"
 ```
 
 **Implementation note** Reading this format into Rust is made easy by `serde` and
@@ -782,9 +793,11 @@ Serialization section). It is also trivial to serialize these
 definitions in to the overall HUGR serialization format.
 
 Note the only required fields are `name` and `description`. `signature` is optional, but if present
-must have children `inputs` and `outputs`, each lists. The optional `misc` field is used for arbitrary
-YAML, which is read in as-is and passed to compiler passes and (if no `signature` is present) the
-`compute_signature` function; e.g. a pass can use the `basis` information to perform commutation.
+must have children `inputs` and `outputs`, each lists, and may have `resources`.
+
+The optional `misc` field is used for arbitrary YAML, which is read in as-is and passed to compiler
+ passes and (if no `signature` is present) the`compute_signature` function; e.g. a pass can use the `basis` information to perform commutation.
+
 The optional `args` field can be used to specify the types of static+const arguments to each operation
 ---for example the matrix needed to define an SU2 operation. If `args` are not specified
 then it is assumed empty.

src/builder.rs

@@ -33,7 +33,7 @@ pub use conditional::{CaseBuilder, ConditionalBuilder};
 mod circuit_builder;
 pub use circuit_builder::{AppendWire, CircuitBuilder};
 
-#[derive(Debug, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, PartialEq, Error)]
 /// Error while building the HUGR.
 pub enum BuildError {
     /// The constructed HUGR is invalid.

src/extensions/rotation.rs

@@ -6,14 +6,14 @@ use std::ops::{Add, Div, Mul, Neg, Sub};
 use cgmath::num_traits::ToPrimitive;
 use num_rational::Rational64;
 use smol_str::SmolStr;
+use std::collections::HashMap;
 
 #[cfg(feature = "pyo3")]
 use pyo3::prelude::*;
 
 use crate::ops::constant::CustomConst;
-use crate::ops::CustomOp;
-use crate::resource::ResourceSet;
-use crate::types::{ClassicType, CustomType, Signature, SimpleType, TypeRow};
+use crate::resource::{CustomSignatureFunc, OpDef, ResourceSet, SignatureError};
+use crate::types::{type_arg::TypeArgValue, ClassicType, CustomType, SimpleType, TypeRow};
 use crate::Resource;
 
 pub const fn resource_id() -> SmolStr {
@@ -27,7 +27,13 @@ pub fn resource() -> Resource {
     resource.add_type(Type::Angle.into());
     resource.add_type(Type::Quaternion.into());
 
-    resource.add_opaque_op(AngleAdd.into());
+    resource.add_op(OpDef::new_with_custom_sig(
+        "AngleAdd".into(),
+        "".into(),
+        vec![],
+        HashMap::default(),
+        AngleAdd,
+    ));
     resource
 }
 
@@ -90,20 +96,17 @@ impl CustomConst for Constant {
 #[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
 pub struct AngleAdd;
 
-#[typetag::serde]
-impl CustomOp for AngleAdd {
-    fn name(&self) -> SmolStr {
-        "AngleAdd".into()
-    }
-
-    fn signature(&self) -> Signature {
-        // TODO: Is there a way to make this static? The Opaque simple type requires initializing a Box...
-        Signature::new_linear(vec![SimpleType::Classic(Type::Angle.classic_type())])
-    }
-
-    fn resources(&self) -> &ResourceSet {
-        // TODO: Don't return a reference? We need to initialize the resource set.
-        todo!()
+/// When we have a YAML type-scheme interpreter, we'll be able to use that;
+/// there is no need for a binary compute_signature for a case this simple.
+impl CustomSignatureFunc for AngleAdd {
+    fn compute_signature(
+        &self,
+        _name: &SmolStr,
+        _arg_values: &Vec<TypeArgValue>,
+        _misc: &HashMap<String, serde_yaml::Value>,
+    ) -> Result<(TypeRow, TypeRow, ResourceSet), SignatureError> {
+        let t: TypeRow = vec![SimpleType::Classic(Type::Angle.classic_type())].into();
+        Ok((t.clone(), t, ResourceSet::default()))
     }
 }
 

src/hugr/serialize.rs

@@ -50,7 +50,7 @@ struct SerHugrV0 {
 }
 
 /// Errors that can occur while serializing a HUGR.
-#[derive(Debug, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, PartialEq, Error)]
 pub enum HUGRSerializationError {
     /// Unexpected hierarchy error.
     #[error("Failed to attach child to parent: {0:?}.")]

src/hugr/validate.rs

@@ -629,7 +629,7 @@ impl<'a> ValidationContext<'a> {
 }
 
 /// Errors that can occur while validating a Hugr.
-#[derive(Debug, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, PartialEq, Error)]
 #[allow(missing_docs)]
 pub enum ValidationError {
     /// The root node of the Hugr is not a root in the hierarchy.
@@ -753,7 +753,7 @@ pub enum ValidationError {
 }
 
 /// Errors related to the inter-graph edge validations.
-#[derive(Debug, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, PartialEq, Error)]
 #[allow(missing_docs)]
 pub enum InterGraphEdgeError {
     /// Inter-Graph edges can only carry classical data.

src/ops.rs

@@ -2,7 +2,7 @@
 
 pub mod constant;
 pub mod controlflow;
-pub mod custom;
+mod custom;
 pub mod dataflow;
 pub mod handle;
 pub mod leaf;
@@ -12,8 +12,6 @@ pub mod validate;
 use crate::types::{EdgeKind, Signature, SignatureDescription};
 use crate::{Direction, Port};
 
-pub use custom::{CustomOp, OpDef, OpaqueOp};
-
 use portgraph::NodeIndex;
 use smol_str::SmolStr;
 
@@ -27,7 +25,7 @@ pub use leaf::LeafOp;
 pub use module::{AliasDeclare, AliasDef, Declare, Def, Module};
 
 #[enum_dispatch(OpTrait, OpName, ValidateOp)]
-#[derive(Clone, Debug, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
 /// The concrete operation types for a node in the HUGR.
 // TODO: Link the NodeHandles to the OpType.
 #[non_exhaustive]