Delete the previous LoadedParameter

Author: aborgna-q

tket/src/serialize/pytket/decoder.rs

@@ -3,6 +3,12 @@
 mod op;
 mod param;
 
+#[expect(
+    unused_imports,
+    reason = "Temporarily unused while we refactor the pytket decoder"
+)]
+pub use param::{LoadedParameter, LoadedParameterType};
+
 use std::collections::{HashMap, HashSet};
 
 use hugr::builder::{Container, Dataflow, DataflowHugr, FunctionBuilder};
@@ -14,7 +20,6 @@ use hugr::std_extensions::arithmetic::float_types::ConstF64;
 use hugr::types::Signature;
 use hugr::{Hugr, Wire};
 
-use derive_more::Display;
 use indexmap::IndexMap;
 use itertools::{EitherOrBoth, Itertools};
 use serde_json::json;
@@ -27,7 +32,7 @@ use super::{
     METADATA_B_REGISTERS, METADATA_OPGROUP, METADATA_PHASE, METADATA_Q_OUTPUT_REGISTERS,
     METADATA_Q_REGISTERS,
 };
-use crate::extension::rotation::{rotation_type, RotationOp};
+use crate::extension::rotation::rotation_type;
 use crate::serialize::pytket::METADATA_INPUT_PARAMETERS;
 use crate::symbolic_constant_op;
 use op::Tk1Op;
@@ -354,84 +359,3 @@ fn check_register(register: &register::ElementId) -> Result<(), Tk1ConvertError>
         Ok(())
     }
 }
-
-/// The type of a loaded parameter in the Hugr.
-#[derive(Debug, Display, Clone, Copy, Hash, PartialEq, Eq)]
-enum LoadedParameterType {
-    Float,
-    Rotation,
-}
-
-/// A loaded parameter in the Hugr.
-///
-/// Tracking the type of the wire lets us delay conversion between the types
-/// until they are actually needed.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
-struct LoadedParameter {
-    /// The type of the parameter.
-    pub typ: LoadedParameterType,
-    /// The wire where the parameter is loaded.
-    pub wire: Wire,
-}
-
-impl LoadedParameter {
-    /// Returns a `LoadedParameter` for a float param.
-    pub fn float(wire: Wire) -> LoadedParameter {
-        LoadedParameter {
-            typ: LoadedParameterType::Float,
-            wire,
-        }
-    }
-
-    /// Returns a `LoadedParameter` for a rotation param.
-    pub fn rotation(wire: Wire) -> LoadedParameter {
-        LoadedParameter {
-            typ: LoadedParameterType::Rotation,
-            wire,
-        }
-    }
-
-    /// Convert the parameter into a given type, if necessary.
-    ///
-    /// Adds the necessary operations to the Hugr and returns a new wire.
-    pub fn as_type(
-        &self,
-        typ: LoadedParameterType,
-        hugr: &mut FunctionBuilder<Hugr>,
-    ) -> LoadedParameter {
-        match (self.typ, typ) {
-            (LoadedParameterType::Float, LoadedParameterType::Rotation) => {
-                let wire = hugr
-                    .add_dataflow_op(RotationOp::from_halfturns_unchecked, [self.wire])
-                    .unwrap()
-                    .out_wire(0);
-                LoadedParameter::rotation(wire)
-            }
-            (LoadedParameterType::Rotation, LoadedParameterType::Float) => {
-                let wire = hugr
-                    .add_dataflow_op(RotationOp::to_halfturns, [self.wire])
-                    .unwrap()
-                    .out_wire(0);
-                LoadedParameter::float(wire)
-            }
-            _ => {
-                debug_assert_eq!(self.typ, typ, "cannot convert {} to {}", self.typ, typ);
-                *self
-            }
-        }
-    }
-
-    /// Convert the parameter into a float, if necessary.
-    ///
-    /// Adds the necessary operations to the Hugr and returns a new wire.
-    pub fn as_float(&self, hugr: &mut FunctionBuilder<Hugr>) -> LoadedParameter {
-        self.as_type(LoadedParameterType::Float, hugr)
-    }
-
-    /// Convert the parameter into a rotation, if necessary.
-    ///
-    /// Adds the necessary operations to the Hugr and returns a new wire.
-    pub fn as_rotation(&self, hugr: &mut FunctionBuilder<Hugr>) -> LoadedParameter {
-        self.as_type(LoadedParameterType::Rotation, hugr)
-    }
-}

tket/src/serialize/pytket/decoder/param.rs

@@ -1,9 +1,4 @@
 //! Definition of a loaded parameter (either floating point or a rotation type) attached to a HUGR wire.
-#![expect(
-    dead_code,
-    reason = "Temporarily unused while we refactor the pytket decoder"
-)]
-
 pub(super) mod parser;
 use std::sync::LazyLock;
 
@@ -53,6 +48,10 @@ impl LoadedParameter {
     }
 
     /// Returns the hugr type for the parameter.
+    #[expect(
+        dead_code,
+        reason = "Temporarily unused while we refactor the pytket decoder"
+    )]
     pub fn wire_type(&self) -> &Type {
         static FLOAT_TYPE: LazyLock<Type> = LazyLock::new(float64_type);
         static ROTATION_TYPE: LazyLock<Type> = LazyLock::new(rotation_type);