Cleanup file structure, use better emitter names

Author: aborgna-q

tket2/src/ops.rs

@@ -1,7 +1,7 @@
 use std::sync::{Arc, Weak};
 
 use crate::extension::rotation::rotation_type;
-use crate::extension::sympy::{SympyOpDef, SYM_OP_ID};
+use crate::extension::sympy::SympyOpDef;
 use crate::extension::{TKET2_EXTENSION, TKET2_EXTENSION_ID as EXTENSION_ID};
 use hugr::ops::custom::ExtensionOp;
 use hugr::ops::NamedOp;
@@ -14,7 +14,7 @@ use hugr::{
     },
     ops::OpType,
     type_row,
-    types::{type_param::TypeArg, Signature},
+    types::Signature,
 };
 
 use derive_more::{Display, Error};
@@ -185,29 +185,6 @@ pub fn symbolic_constant_op(arg: String) -> OpType {
     SympyOpDef.with_expr(arg).into()
 }
 
-/// match against a symbolic constant
-pub(crate) fn match_symb_const_op(op: &OpType) -> Option<String> {
-    // Extract the symbol for a symbolic operation node.
-    let symbol_from_typeargs = |args: &[TypeArg]| -> String {
-        args.first()
-            .and_then(|arg| match arg {
-                TypeArg::String { arg } => Some(arg.clone()),
-                _ => None,
-            })
-            .unwrap_or_else(|| panic!("Found an invalid type arg in a symbolic operation node."))
-    };
-
-    if let OpType::ExtensionOp(e) = op {
-        if e.def().name() == &SYM_OP_ID && e.def().extension_id() == &EXTENSION_ID {
-            Some(symbol_from_typeargs(e.args()))
-        } else {
-            None
-        }
-    } else {
-        None
-    }
-}
-
 #[cfg(test)]
 pub(crate) mod test {
 

tket2/src/serialize/pytket.rs

@@ -3,11 +3,9 @@
 mod decoder;
 mod encoder;
 pub mod extension;
-mod op;
-mod param;
 
 pub use encoder::{default_encoder_config, Tk1EncoderConfig, Tk1EncoderContext};
-pub use extension::Tk1Encoder;
+pub use extension::PytketEmitter;
 
 use hugr::core::HugrNode;
 use hugr::types::Type;

tket2/src/serialize/pytket/decoder.rs

@@ -1,5 +1,8 @@
 //! Intermediate structure for decoding [`SerialCircuit`]s into [`Hugr`]s.
 
+mod op;
+mod param;
+
 use std::collections::{HashMap, HashSet};
 
 use hugr::builder::{Container, Dataflow, DataflowHugr, FunctionBuilder};
@@ -19,8 +22,6 @@ use tket_json_rs::circuit_json;
 use tket_json_rs::circuit_json::SerialCircuit;
 use tket_json_rs::register;
 
-use super::op::Tk1Op;
-use super::param::decode::{parse_pytket_param, PytketParam};
 use super::{
     OpConvertError, RegisterHash, Tk1ConvertError, METADATA_B_OUTPUT_REGISTERS,
     METADATA_B_REGISTERS, METADATA_OPGROUP, METADATA_PHASE, METADATA_Q_OUTPUT_REGISTERS,
@@ -30,6 +31,8 @@ use crate::extension::rotation::{rotation_type, RotationOp};
 use crate::extension::TKET1_EXTENSION_ID;
 use crate::serialize::pytket::METADATA_INPUT_PARAMETERS;
 use crate::symbolic_constant_op;
+use op::Tk1Op;
+use param::{parse_pytket_param, PytketParam};
 
 /// The state of an in-progress [`FunctionBuilder`] being built from a [`SerialCircuit`].
 ///

tket2/src/serialize/pytket/op.rs renamed to tket2/src/serialize/pytket/decoder/op.rs

@@ -11,7 +11,7 @@ use hugr::IncomingPort;
 use tk2op::NativeOp;
 use tket_json_rs::circuit_json;
 
-use super::extension::OpaqueTk1Op;
+use super::super::extension::OpaqueTk1Op;
 
 pub mod tk2op;
 

tket2/src/serialize/pytket/op/tk2op.rs renamed to tket2/src/serialize/pytket/decoder/op/tk2op.rs

@@ -55,7 +55,7 @@ pub fn parse_pytket_param(param: &str) -> PytketParam<'_> {
 }
 
 #[derive(Parser)]
-#[grammar = "serialize/pytket/param/param.pest"]
+#[grammar = "serialize/pytket/decoder/param.pest"]
 struct ParamParser;
 
 lazy_static::lazy_static! {

tket2/src/serialize/pytket/param/param.pest renamed to tket2/src/serialize/pytket/decoder/param.pest

@@ -55,12 +55,12 @@ pub struct Tk1EncoderContext<H: HugrView> {
     unsupported: UnsupportedTracker<H::Node>,
     /// Configuration for the encoding.
     ///
-    /// Contains custom operation/type encoders.
+    /// Contains custom operation/type/const emitters.
     config: Arc<Tk1EncoderConfig<H>>,
 }
 
 impl<H: HugrView> Tk1EncoderContext<H> {
-    /// Create a new [`JsonEncoder`] from a [`Circuit`].
+    /// Create a new [`Tk1EncoderContext`] from a [`Circuit`].
     pub(super) fn new(
         circ: &Circuit<H>,
         config: Tk1EncoderConfig<H>,
@@ -117,7 +117,7 @@ impl<H: HugrView> Tk1EncoderContext<H> {
             portgraph::algorithms::toposort(region, initials, portgraph::Direction::Outgoing);
         let io_nodes = circ.io_nodes();
         // TODO: Use weighted topological sort to try and explore unsupported
-        // ops first (that is, ops with no available encoder in `self.config`),
+        // ops first (that is, ops with no available emitter in `self.config`),
         // to ensure we group them as much as possible.
         for pg_node in topo {
             let node = hugr.get_node(pg_node);
@@ -771,7 +771,7 @@ impl<H: HugrView> Tk1EncoderContext<H> {
 }
 
 /// Initialize a tket1 [Operation](circuit_json::Operation) to pass to
-/// [`Tk1Encoder::emit_command`].
+/// [`Tk1EncoderContext::emit_command`].
 ///
 /// ## Arguments
 /// - `tk1_optype`: The operation type to use.

tket2/src/serialize/pytket/param/decode.rs renamed to tket2/src/serialize/pytket/decoder/param.rs

@@ -1,6 +1,6 @@
 //! Configuration for converting [`Circuit`]s into [`SerialCircuit`]
 //!
-//! A configuration struct contains a list of custom encoders that define translations
+//! A configuration struct contains a list of custom emitters that define translations
 //! of HUGR operations and types into pytket primitives.
 
 use std::collections::{BTreeSet, HashMap, VecDeque};
@@ -10,9 +10,9 @@ use hugr::ops::{ExtensionOp, Value};
 use hugr::types::{SumType, Type, TypeEnum};
 
 use crate::serialize::pytket::extension::{
-    FloatEncoder, PreludeEncoder, RotationEncoder, Tk1OpEncoder, Tk2OpEncoder,
+    FloatEmitter, PreludeEmitter, RotationEmitter, Tk1Emitter, Tk2Emitter,
 };
-use crate::serialize::pytket::{Tk1ConvertError, Tk1Encoder};
+use crate::serialize::pytket::{PytketEmitter, Tk1ConvertError};
 use crate::Circuit;
 
 use super::value_tracker::RegisterCount;
@@ -23,62 +23,61 @@ use itertools::Itertools;
 
 /// Default encoder configuration for [`Circuit`]s.
 ///
-/// Contains encoders for std and tket2 operations.
+/// Contains emitters for std and tket2 operations.
 pub fn default_encoder_config<H: HugrView>() -> Tk1EncoderConfig<H> {
-    // TODO: Add std & tket2 encoders
     let mut config = Tk1EncoderConfig::new();
-    config.add_encoder(PreludeEncoder);
-    config.add_encoder(FloatEncoder);
-    config.add_encoder(RotationEncoder);
-    config.add_encoder(Tk1OpEncoder);
-    config.add_encoder(Tk2OpEncoder);
+    config.add_emitter(PreludeEmitter);
+    config.add_emitter(FloatEmitter);
+    config.add_emitter(RotationEmitter);
+    config.add_emitter(Tk1Emitter);
+    config.add_emitter(Tk2Emitter);
     config
 }
 
 /// Configuration for converting [`Circuit`] into [`SerialCircuit`].
 ///
-/// Contains custom encoders that define translations for HUGR operations and types
-/// into pytket primitives.
+/// Contains custom emitters that define translations for HUGR operations,
+/// types, and consts into pytket primitives.
 #[derive(derive_more::Debug)]
 #[debug(bounds(H: HugrView))]
 pub struct Tk1EncoderConfig<H: HugrView> {
-    /// Operation encoders
+    /// Operation emitters
     #[debug(skip)]
-    pub(super) encoders: Vec<Box<dyn Tk1Encoder<H>>>,
-    /// Pre-computed map from extension ids to corresponding encoders in
-    /// `encoders`, identified by their index.
-    #[debug("{:?}", extension_encoders.keys().collect_vec())]
-    extension_encoders: HashMap<ExtensionId, Vec<usize>>,
-    /// Extensions that request to be called for all operations.
-    no_extension_encoders: Vec<usize>,
+    pub(super) enmitters: Vec<Box<dyn PytketEmitter<H>>>,
+    /// Pre-computed map from extension ids to corresponding emitters in
+    /// `emitters`, identified by their index.
+    #[debug("{:?}", extension_emitters.keys().collect_vec())]
+    extension_emitters: HashMap<ExtensionId, Vec<usize>>,
+    /// Emitters that request to be called for all operations.
+    no_extension_emitters: Vec<usize>,
 }
 
 impl<H: HugrView> Tk1EncoderConfig<H> {
     /// Create a new [`Tk1EncoderConfig`] with no encoders.
     pub fn new() -> Self {
         Self {
-            encoders: vec![],
-            extension_encoders: HashMap::new(),
-            no_extension_encoders: vec![],
+            enmitters: vec![],
+            extension_emitters: HashMap::new(),
+            no_extension_emitters: vec![],
         }
     }
 
     /// Add an encoder to the configuration.
-    pub fn add_encoder(&mut self, encoder: impl Tk1Encoder<H> + 'static) {
-        let idx = self.encoders.len();
+    pub fn add_emitter(&mut self, encoder: impl PytketEmitter<H> + 'static) {
+        let idx = self.enmitters.len();
 
         match encoder.extensions() {
             Some(extensions) => {
                 for ext in extensions {
-                    self.extension_encoders.entry(ext).or_default().push(idx);
+                    self.extension_emitters.entry(ext).or_default().push(idx);
                 }
             }
             // If the encoder does not specify an extension, it will be called
             // for all operations.
-            None => self.no_extension_encoders.push(idx),
+            None => self.no_extension_emitters.push(idx),
         }
 
-        self.encoders.push(Box::new(encoder));
+        self.enmitters.push(Box::new(encoder));
     }
 
     /// List the extensions supported by the encoders.
@@ -88,7 +87,7 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
     ///
     /// Use [`Tk1EncoderConfig::add_encoder`] to extend this list.
     pub fn supported_extensions(&self) -> impl Iterator<Item = &ExtensionId> {
-        self.extension_encoders.keys()
+        self.extension_emitters.keys()
     }
 
     /// Encode a HUGR operation using the registered custom encoders.
@@ -103,7 +102,7 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
     ) -> Result<bool, Tk1ConvertError<H::Node>> {
         let mut result = false;
         let extension = op.def().extension_id();
-        for enc in self.encoders_for_extension(extension) {
+        for enc in self.emitters_for_extension(extension) {
             if enc.op_to_pytket(node, op, circ, encoder)? {
                 result = true;
                 break;
@@ -146,7 +145,7 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
             }
             TypeEnum::Extension(custom) => {
                 let type_ext = custom.extension();
-                for encoder in self.encoders_for_extension(type_ext) {
+                for encoder in self.emitters_for_extension(type_ext) {
                     if let Some(count) = encoder.type_to_pytket(custom)? {
                         return Ok(Some(count));
                     }
@@ -185,7 +184,7 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
                 Value::Extension { e: opaque } => {
                     let type_exts = opaque.extension_reqs();
                     let mut encoded = false;
-                    for e in self.encoders_for_extensions(&type_exts) {
+                    for e in self.emitters_for_extensions(&type_exts) {
                         if let Some(vs) = e.const_to_pytket(opaque, encoder)? {
                             values.append(vs);
                             encoded = true;
@@ -202,40 +201,40 @@ impl<H: HugrView> Tk1EncoderConfig<H> {
         Ok(Some(values))
     }
 
-    /// Lists the encoders that can handle a given extension.
-    fn encoders_for_extension(
+    /// Lists the emitters that can handle a given extension.
+    fn emitters_for_extension(
         &self,
         ext: &ExtensionId,
-    ) -> impl Iterator<Item = &Box<dyn Tk1Encoder<H>>> {
-        self.extension_encoders
+    ) -> impl Iterator<Item = &Box<dyn PytketEmitter<H>>> {
+        self.extension_emitters
             .get(ext)
             .into_iter()
             .flatten()
-            .chain(self.no_extension_encoders.iter())
-            .map(move |idx| &self.encoders[*idx])
+            .chain(self.no_extension_emitters.iter())
+            .map(move |idx| &self.enmitters[*idx])
     }
 
-    /// Lists the encoders that can handle a given set extensions.
-    fn encoders_for_extensions(
+    /// Lists the emitters that can handle a given set extensions.
+    fn emitters_for_extensions(
         &self,
         exts: &ExtensionSet,
-    ) -> impl Iterator<Item = &Box<dyn Tk1Encoder<H>>> {
-        let encoder_ids: BTreeSet<usize> = exts
+    ) -> impl Iterator<Item = &Box<dyn PytketEmitter<H>>> {
+        let emitter_ids: BTreeSet<usize> = exts
             .iter()
-            .flat_map(|ext| self.extension_encoders.get(ext).into_iter().flatten())
-            .chain(self.no_extension_encoders.iter())
+            .flat_map(|ext| self.extension_emitters.get(ext).into_iter().flatten())
+            .chain(self.no_extension_emitters.iter())
             .copied()
             .collect();
-        encoder_ids.into_iter().map(move |idx| &self.encoders[idx])
+        emitter_ids.into_iter().map(move |idx| &self.enmitters[idx])
     }
 }
 
 impl<H: HugrView> Default for Tk1EncoderConfig<H> {
     fn default() -> Self {
         Self {
-            encoders: Default::default(),
-            extension_encoders: Default::default(),
-            no_extension_encoders: Default::default(),
+            enmitters: Default::default(),
+            extension_emitters: Default::default(),
+            no_extension_emitters: Default::default(),
         }
     }
 }

tket2/src/serialize/pytket/encoder.rs

@@ -173,7 +173,7 @@ struct TrackedWire {
 /// The number of pytket qubits, bits, and sympy parameters corresponding to a
 /// HUGR type.
 ///
-/// Used as return value for [`Tk1Encoder::type_to_pytket`](`super::Tk1Encoder::type_to_pytket`).
+/// Used as return value for [`PytketEmitter::type_to_pytket`](`super::PytketEmitter::type_to_pytket`).
 #[derive(
     Clone,
     Copy,

tket2/src/serialize/pytket/encoder/config.rs

@@ -1,6 +1,6 @@
 //! Extension encoder/decoders for the tket2 <-> `pytket` conversion.
 //!
-//! To add a new extension encoder, implement the [`Tk1Encoder`] trait and add
+//! To add a new extension encoder, implement the [`PytketEmitter`] trait and add
 //! it to the [`Tk1EncoderConfig`](crate::serialize::pytket::Tk1EncoderConfig)
 //! used for decoding.
 //!
@@ -15,12 +15,12 @@ mod rotation;
 mod tk1;
 mod tk2;
 
-pub use float::FloatEncoder;
+pub use float::FloatEmitter;
 use hugr::ops::constant::OpaqueValue;
-pub use prelude::PreludeEncoder;
-pub use rotation::RotationEncoder;
-pub use tk1::Tk1OpEncoder;
-pub use tk2::Tk2OpEncoder;
+pub use prelude::PreludeEmitter;
+pub use rotation::RotationEmitter;
+pub use tk1::Tk1Emitter;
+pub use tk2::Tk2Emitter;
 
 pub(crate) use tk1::OpaqueTk1Op;
 
@@ -41,10 +41,10 @@ use hugr::HugrView;
 /// constant in the HUGR being encoded, the configuration will call each of
 /// the encoders declaring support for the specific extension sequentially until
 /// one of them indicates a successful conversion.
-pub trait Tk1Encoder<H: HugrView> {
+pub trait PytketEmitter<H: HugrView> {
     /// The name of the extension this encoder/decoder is for.
     ///
-    /// [`Tk1Encoder::op_to_pytket`] and [`Tk1Encoder::type_to_pytket`] will
+    /// [`PytketEmitter::op_to_pytket`] and [`PytketEmitter::type_to_pytket`] will
     /// only be called for operations/types of these extensions.
     ///
     /// If the function returns `None`, the encoder will be called for all