simplify with option

Author: ss2165

tket2-hseries/src/extension/qsystem/barrier.rs

@@ -92,7 +92,7 @@ mod test {
                 // make sure it is because there are no qubits in the barrier
                 let mut analyzer = QTypeAnalyzer::new();
                 let tuple_type = hugr::types::Type::new_tuple(type_row);
-                assert!(!analyzer.unpack_type(&tuple_type).is_qb_container());
+                assert!(!analyzer.is_qubit_container(&tuple_type));
                 return;
             }
             h.single_linked_input(run_barr_func_n.unwrap(), 0)

tket2-hseries/src/extension/qsystem/barrier/barrier_inserter.rs

@@ -20,6 +20,8 @@ use crate::extension::qsystem::barrier::barrier_ops::{
 use crate::extension::qsystem::lower::insert_function;
 use crate::extension::qsystem::LowerTk2Error;
 
+use super::qtype_analyzer::is_qubit_array;
+
 type Target = (Node, IncomingPort);
 
 /// Responsible for inserting runtime barriers into the HUGR
@@ -47,18 +49,13 @@ impl BarrierInserter {
             .type_row
             .iter()
             .enumerate()
-            .filter_map(|(i, typ)| {
-                let wc = self.op_factory.type_analyzer().unpack_type(typ);
-
-                if wc.is_qb_container() {
-                    let port = OutgoingPort::from(i);
-                    let target = hugr
-                        .single_linked_input(node, port)
-                        .expect("linearity violation.");
-                    Some((typ.clone(), target))
-                } else {
-                    None
-                }
+            .filter(|(_, typ)| self.op_factory.type_analyzer().is_qubit_container(typ))
+            .map(|(i, typ)| {
+                let port = OutgoingPort::from(i);
+                let target = hugr
+                    .single_linked_input(node, port)
+                    .expect("linearity violation.");
+                (typ.clone(), target)
             })
             .collect()
     }
@@ -72,7 +69,7 @@ impl BarrierInserter {
         target: Target,
     ) -> Option<Result<(), LowerTk2Error>> {
         // Check if this is an array of qubits
-        let size = self.op_factory.type_analyzer().is_qubit_array(typ)?;
+        let size = is_qubit_array(typ)?;
 
         // Build and insert the barrier
         Some(match build_runtime_barrier_op(size) {

tket2-hseries/src/extension/qsystem/barrier/barrier_ops.rs

@@ -18,10 +18,7 @@ use hugr::{
     Hugr, Wire,
 };
 
-use crate::extension::qsystem::{
-    barrier::qtype_analyzer::{QTypeAnalyzer, UnpackedRow},
-    QSystemOpBuilder,
-};
+use crate::extension::qsystem::{barrier::qtype_analyzer::QTypeAnalyzer, QSystemOpBuilder};
 
 use super::qtype_analyzer::{array_args, is_opt_qb};
 // use hugr::builder::{BuildError, DFGBuilder};
@@ -346,12 +343,9 @@ impl BarrierOperationFactory {
 
     /// Helper function for array arguments
     fn array_args(&mut self, size: u64, elem_ty: &Type) -> Option<[TypeArg; 3]> {
-        let UnpackedRow::QbContainer(row) = self
+        let row = self
             .type_analyzer
-            .unpack_type(&array_type(size, elem_ty.clone()))
-        else {
-            return None;
-        };
+            .unpack_type(&array_type(size, elem_ty.clone()))?;
         let args = [
             size.into(),
             elem_ty.clone().into(),
@@ -380,7 +374,7 @@ impl BarrierOperationFactory {
             }
         };
 
-        let inner_row_len = self.type_analyzer.unpack_type(elem_ty).num_wires();
+        let inner_row_len = self.type_analyzer.num_unpacked_wires(elem_ty);
 
         let mut outputs = self.apply_cached_operation(
             builder,
@@ -407,12 +401,9 @@ impl BarrierOperationFactory {
 
     /// Generate tuple arguments
     fn tuple_args(&mut self, tuple_row: &[Type]) -> Option<[TypeArg; 2]> {
-        let UnpackedRow::QbContainer(unpacked_row) = self
+        let unpacked_row = self
             .type_analyzer
-            .unpack_type(&Type::new_tuple(tuple_row.to_vec()))
-        else {
-            return None;
-        };
+            .unpack_type(&Type::new_tuple(tuple_row.to_vec()))?;
 
         let args = [
             TypeArg::Sequence {
@@ -455,7 +446,7 @@ impl BarrierOperationFactory {
         types
             .iter()
             .map(|typ| {
-                let wire_count = self.type_analyzer.unpack_type(typ).num_wires();
+                let wire_count = self.type_analyzer.num_unpacked_wires(typ);
                 let type_wires = wires.by_ref().take(wire_count).collect();
                 self.repack_container(builder, typ, type_wires)
             })