chore(deps-rs): Update to hugr 0.9.0 (#497)

Author: aborgna-q

Cargo.lock

@@ -24,9 +24,9 @@ missing_docs = "warn"
 
 [workspace.dependencies]
 
-hugr = "0.8.0"
-hugr-cli = "0.1.4"
-hugr-core = "0.5.0"
+hugr = "0.9.0"
+hugr-cli = "0.2.0"
+hugr-core = "0.6.0"
 portgraph = "0.12"
 pyo3 = "0.21.2"
 itertools = "0.13.0"

Cargo.toml

@@ -36,7 +36,7 @@ compatibility:
 1. The `main` function takes one `Array<N, Qubit>`
 input and has one output of the same type (the same statically known
 size).
-2. All Operations that have a `FunctionType` involving `Qubit` have as
+2. All Operations that have a `Signature` involving `Qubit` have as
  many `Qubit` input wires as output.
 
 

docs/quantum.md

@@ -10,9 +10,7 @@ use hugr::{
         ExtensionBuildError, ExtensionId, ExtensionRegistry, OpDef, SignatureFunc, TypeDef,
     },
     ops::{custom::ExtensionOp, CustomOp, OpType},
-    types::{
-        type_param::TypeParam, CustomType, FunctionType, PolyFuncType, Type, TypeArg, TypeBound,
-    },
+    types::{type_param::TypeParam, CustomType, PolyFuncType, Signature, Type, TypeArg, TypeBound},
     Extension, Wire,
 };
 use lazy_static::lazy_static;
@@ -97,15 +95,15 @@ impl MakeOpDef for FutureOp {
         let future_type = future_type(t_type.clone());
         match self {
             FutureOp::Read => {
-                PolyFuncType::new([t_param], FunctionType::new(future_type, t_type)).into()
+                PolyFuncType::new([t_param], Signature::new(future_type, t_type)).into()
             }
             FutureOp::Dup => PolyFuncType::new(
                 [t_param],
-                FunctionType::new(future_type.clone(), vec![future_type.clone(), future_type]),
+                Signature::new(future_type.clone(), vec![future_type.clone(), future_type]),
             )
             .into(),
             FutureOp::Free => {
-                PolyFuncType::new([t_param], FunctionType::new(future_type.clone(), vec![])).into()
+                PolyFuncType::new([t_param], Signature::new(future_type.clone(), vec![])).into()
             }
         }
     }
@@ -287,7 +285,7 @@ pub(crate) mod test {
         let hugr = {
             let mut func_builder = FunctionBuilder::new(
                 "circuit",
-                PolyFuncType::new(vec![t_param], FunctionType::new(future_type, t.clone())),
+                PolyFuncType::new(vec![t_param], Signature::new(future_type, t.clone())),
             )
             .unwrap();
             let [future_w] = func_builder.input_wires_arr();

tket2-hseries/src/extension/futures.rs

@@ -11,7 +11,7 @@ use hugr::{
         ExtensionId, ExtensionRegistry, OpDef, SignatureFunc, PRELUDE,
     },
     ops::{CustomOp, OpType},
-    types::FunctionType,
+    types::Signature,
     Extension, Wire,
 };
 
@@ -66,7 +66,7 @@ pub enum LazyQuantumOp {
 impl MakeOpDef for LazyQuantumOp {
     fn signature(&self) -> SignatureFunc {
         match self {
-            Self::Measure => FunctionType::new(QB_T, vec![QB_T, future_type(BOOL_T)]).into(),
+            Self::Measure => Signature::new(QB_T, vec![QB_T, future_type(BOOL_T)]).into(),
         }
     }
 
@@ -147,8 +147,7 @@ mod test {
     fn circuit() {
         let hugr = {
             let mut func_builder =
-                FunctionBuilder::new("circuit", FunctionType::new(QB_T, vec![QB_T, BOOL_T]))
-                    .unwrap();
+                FunctionBuilder::new("circuit", Signature::new(QB_T, vec![QB_T, BOOL_T])).unwrap();
             let [qb] = func_builder.input_wires_arr();
             let [qb, lazy_b] = func_builder.add_lazy_measure(qb).unwrap();
             let [b] = func_builder.add_read(lazy_b, BOOL_T).unwrap();

tket2-hseries/src/extension/quantum_lazy.rs

@@ -1,6 +1,7 @@
 //! This module defines the Hugr extension used to represent result reporting operations,
 //! with static string tags.
 //!
+use hugr::types::Signature;
 use hugr::{
     builder::{BuildError, Dataflow},
     extension::{
@@ -21,7 +22,7 @@ use hugr::{
     type_row,
     types::{
         type_param::{CustomTypeArg, TypeParam},
-        FunctionType, PolyFuncType, Type, TypeArg,
+        PolyFuncType, Type, TypeArg,
     },
     Extension, Wire,
 };
@@ -175,7 +176,7 @@ impl ResultOpDef {
 
         PolyFuncType::new(
             [vec![string_param], self.type_params()].concat(),
-            FunctionType::new(self.arg_type(), type_row![]),
+            Signature::new(self.arg_type(), type_row![]),
         )
         .into()
     }
@@ -412,6 +413,7 @@ impl<D: Dataflow> ResultOpBuilder for D {}
 #[cfg(test)]
 pub(crate) mod test {
     use cool_asserts::assert_matches;
+    use hugr::types::Signature;
     use hugr::{
         builder::{Dataflow, DataflowHugr, FunctionBuilder},
         extension::prelude::array_type,
@@ -455,7 +457,7 @@ pub(crate) mod test {
         .concat();
         let hugr = {
             let mut func_builder =
-                FunctionBuilder::new("circuit", FunctionType::new(in_row, type_row![])).unwrap();
+                FunctionBuilder::new("circuit", Signature::new(in_row, type_row![])).unwrap();
             let ops = [
                 ResultOp::new_bool("b"),
                 ResultOp::new_f64("f"),

tket2-hseries/src/extension/result.rs

@@ -13,7 +13,7 @@ use hugr::{
         ExtensionRegistry,
     },
     hugr::{hugrmut::HugrMut, views::SiblingSubgraph, Rewrite},
-    types::FunctionType,
+    types::Signature,
     Hugr, HugrView, IncomingPort, Node, OutgoingPort, SimpleReplacement,
 };
 use tket2::Tk2Op;
@@ -85,7 +85,7 @@ impl State {
 
 lazy_static! {
     static ref MEASURE_READ_HUGR: Hugr = {
-        let mut builder = DFGBuilder::new(FunctionType::new(QB_T, vec![QB_T, BOOL_T])).unwrap();
+        let mut builder = DFGBuilder::new(Signature::new(QB_T, vec![QB_T, BOOL_T])).unwrap();
         let [qb] = builder.input_wires_arr();
         let [qb, lazy_r] = builder.add_lazy_measure(qb).unwrap();
         let [r] = builder.add_read(lazy_r, BOOL_T).unwrap();
@@ -99,7 +99,7 @@ fn measure_replacement(num_dups: usize) -> Hugr {
     let mut out_types = vec![QB_T];
     out_types.extend((0..num_dups).map(|_| BOOL_T));
     let num_out_types = out_types.len();
-    let mut builder = DFGBuilder::new(FunctionType::new(QB_T, out_types)).unwrap();
+    let mut builder = DFGBuilder::new(Signature::new(QB_T, out_types)).unwrap();
     let [qb] = builder.input_wires_arr();
     let [qb, mut future_r] = builder.add_lazy_measure(qb).unwrap();
     let mut future_rs = vec![];
@@ -215,7 +215,7 @@ mod test {
     #[test]
     fn simple() {
         let mut hugr = {
-            let mut builder = DFGBuilder::new(FunctionType::new(QB_T, vec![QB_T, BOOL_T])).unwrap();
+            let mut builder = DFGBuilder::new(Signature::new(QB_T, vec![QB_T, BOOL_T])).unwrap();
             let [qb] = builder.input_wires_arr();
             let outs = builder
                 .add_dataflow_op(Tk2Op::Measure, [qb])
@@ -248,7 +248,7 @@ mod test {
     #[test]
     fn multiple_uses() {
         let mut builder =
-            DFGBuilder::new(FunctionType::new(QB_T, vec![QB_T, BOOL_T, BOOL_T])).unwrap();
+            DFGBuilder::new(Signature::new(QB_T, vec![QB_T, BOOL_T, BOOL_T])).unwrap();
         let [qb] = builder.input_wires_arr();
         let [qb, bool] = builder
             .add_dataflow_op(Tk2Op::Measure, [qb])
@@ -267,7 +267,7 @@ mod test {
 
     #[test]
     fn no_uses() {
-        let mut builder = DFGBuilder::new(FunctionType::new_endo(QB_T)).unwrap();
+        let mut builder = DFGBuilder::new(Signature::new_endo(QB_T)).unwrap();
         let [qb] = builder.input_wires_arr();
         let [qb, _] = builder
             .add_dataflow_op(Tk2Op::Measure, [qb])

tket2-hseries/src/lazify_measure.rs

@@ -10,7 +10,7 @@ use hugr::extension::prelude::{BOOL_T, QB_T};
 use hugr::hugr::IdentList;
 use hugr::ops::custom::{ExtensionOp, OpaqueOp};
 use hugr::ops::{CustomOp, NamedOp, OpName, OpType};
-use hugr::types::{CustomType, FunctionType, Type, TypeBound};
+use hugr::types::{CustomType, Type, TypeBound};
 use pyo3::prelude::*;
 use std::fmt;
 

tket2-py/src/circuit.rs

@@ -6,7 +6,7 @@ use hugr::builder::{CircuitBuilder, DFGBuilder, Dataflow, DataflowHugr};
 use hugr::extension::prelude::QB_T;
 use hugr::ops::handle::NodeHandle;
 use hugr::ops::{CustomOp, OpType};
-use hugr::types::{FunctionType, Type};
+use hugr::types::Type;
 use itertools::Itertools;
 use pyo3::exceptions::{PyAttributeError, PyValueError};
 use pyo3::types::{PyAnyMethods, PyModule, PyString, PyTypeMethods};

tket2-py/src/circuit/convert.rs

@@ -6,7 +6,7 @@ use hugr::builder::{CircuitBuilder, DFGBuilder, Dataflow, DataflowHugr};
 use hugr::extension::prelude::QB_T;
 use hugr::ops::handle::NodeHandle;
 use hugr::ops::{CustomOp, OpType};
-use hugr::types::{FunctionType, Type};
+use hugr::types::Type;
 use itertools::Itertools;
 use pyo3::exceptions::{PyAttributeError, PyValueError};
 use pyo3::types::{PyAnyMethods, PyModule, PyString, PyTypeMethods};