Solve some warnings

badger-optimiser/src/main.rs

@@ -15,7 +15,7 @@ use tket2::optimiser::badger::log::BadgerLogger;
 use tket2::optimiser::badger::BadgerOptions;
 use tket2::optimiser::BadgerOptimiser;
 use tket2::optimiser::DiffBadgerOptimiser;
-use tket2::serialize::{load_tk1_json_file, save_tk1_json_file};
+use tket2::serialize::load_tk1_json_file;
 use tket2::static_circ::StaticSizeCircuit;
 
 #[cfg(feature = "peak_alloc")]

tket2-py/src/optimiser.rs

@@ -7,11 +7,11 @@ use portdiff::PortDiffGraph;
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use tket2::optimiser::badger::BadgerOptions;
-use tket2::optimiser::{BadgerLogger, DefaultBadgerOptimiser, DiffBadgerOptimiser};
+use tket2::optimiser::{BadgerLogger, DiffBadgerOptimiser};
 use tket2::static_circ::StaticSizeCircuit;
 use tket2::Circuit;
 
-use crate::circuit::{try_with_circ, update_circ};
+use crate::circuit::try_with_circ;
 
 /// The module definition
 pub fn module(py: Python<'_>) -> PyResult<Bound<'_, PyModule>> {

tket2-py/src/passes.rs

@@ -2,18 +2,18 @@
 
 pub mod chunks;
 
-use std::{cmp::min, convert::TryInto, fs, num::NonZeroUsize, path::PathBuf};
+// use std::{cmp::min, convert::TryInto, fs, num::NonZeroUsize, path::PathBuf};
 
 use pyo3::{prelude::*, types::IntoPyDict};
-use tket2::optimiser::badger::BadgerOptions;
+// use tket2::optimiser::badger::BadgerOptions;
 use tket2::passes;
-use tket2::{op_matches, Tk2Op};
+// use tket2::{op_matches, Tk2Op};
 
 use crate::circuit::CircuitType;
 use crate::utils::{create_py_exception, ConvertPyErr};
 use crate::{
-    circuit::{try_update_circ, try_with_circ},
-    optimiser::PyBadgerOptimiser,
+    circuit::try_with_circ,
+    // optimiser::PyBadgerOptimiser,
 };
 
 /// The module definition
@@ -62,7 +62,7 @@ fn greedy_depth_reduce<'py>(circ: &Bound<'py, PyAny>) -> PyResult<(Bound<'py, Py
 /// from pytket.passes.auto_rebase import auto_rebase_pass
 /// from pytket import OpType
 /// auto_rebase_pass({OpType.CX, OpType.Rz, OpType.H}).apply(circ)"
-// ```
+/// ```
 fn rebase_nam(circ: &Bound<PyAny>) -> PyResult<()> {
     let py = circ.py();
     let auto_rebase = py

tket2/src/optimiser.rs

@@ -4,6 +4,5 @@
 
 #[cfg(feature = "portmatching")]
 pub mod badger;
-
 #[cfg(feature = "portmatching")]
 pub use badger::{BadgerLogger, BadgerOptimiser, DefaultBadgerOptimiser, DiffBadgerOptimiser};

tket2/src/optimiser/badger.rs

@@ -20,11 +20,10 @@ mod qtz_circuit;
 
 pub use eq_circ_class::{load_eccs_json_file, EqCircClass};
 use fxhash::{FxHashMap, FxHashSet};
-use itertools::Itertools;
 pub use log::BadgerLogger;
 use portdiff::{PortDiff, PortDiffGraph};
 
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeMap;
 use std::iter::Sum;
 use std::num::NonZeroUsize;
 use std::ops::{AddAssign, Deref};
@@ -37,7 +36,7 @@ use crate::optimiser::badger::hugr_pqueue::{Entry, HugrPQ};
 use crate::portdiff::{DiffCircuit, DiffRewrite};
 use crate::rewrite::strategy::StrategyCost;
 use crate::rewrite::Rewriter;
-use crate::static_circ::{StaticSizeCircuit, UpdatableHash};
+use crate::static_circ::StaticSizeCircuit;
 
 /// Configuration options for the Badger optimiser.
 #[derive(Copy, Clone, Debug)]
@@ -832,12 +831,11 @@ mod tests {
         extension::prelude::QB_T,
         types::Signature,
     };
-    use rstest::{fixture, rstest};
+    use rstest::fixture;
 
     use crate::serialize::load_tk1_json_str;
     use crate::{extension::angle::ANGLE_TYPE, optimiser::badger::BadgerOptions};
     use crate::{extension::REGISTRY, Circuit, Tk2Op};
-    use crate::{optimiser::badger::BadgerOptions, static_circ::StaticSizeCircuit};
 
     use super::{BadgerOptimiser, DefaultBadgerOptimiser};
 

tket2/src/optimiser/badger/hugr_pqueue.rs

@@ -2,8 +2,6 @@ use delegate::delegate;
 use fxhash::FxHashMap;
 use priority_queue::DoublePriorityQueue;
 
-use crate::circuit::CircuitHash;
-
 /// A min-priority queue for Hugrs.
 ///
 /// The cost function provided will be used as the priority of the Hugrs.

tket2/src/portdiff.rs

@@ -10,7 +10,6 @@ pub use rewrite::DiffRewrite;
 
 use derive_more::Into;
 use hugr::{Direction, IncomingPort, OutgoingPort, Port, PortIndex};
-use itertools::Itertools;
 use portdiff::{self as pd, port_diff::Owned, BoundPort, EdgeEnd, Site};
 
 use crate::static_circ::{OpId, OpPosition, StaticSizeCircuit};
@@ -129,6 +128,7 @@ impl pd::Graph for StaticSizeCircuit {
     }
 }
 
+/// An edge in a StaticSizeCircuit.
 #[derive(
     Debug,
     Clone,
@@ -149,6 +149,7 @@ pub struct EdgeId {
 }
 
 impl EdgeId {
+    /// Create an edge from a site in the circuit.
     pub fn try_from_site(site: Site<OpId, Port>, circuit: &StaticSizeCircuit) -> Option<Self> {
         let (opp_port, opp_node) = circuit.linked_op(site.node, site.port)?;
         let (out_port, source) = match site.port.direction() {
@@ -159,34 +160,48 @@ impl EdgeId {
         Some(Self { source, out_port })
     }
 
+    /// Get the source of the edge.
     pub fn source(&self) -> OpId {
         self.source
     }
 
+    /// Get the source port of the edge.
     pub fn source_port(&self) -> OutgoingPort {
         self.out_port
     }
 
+    /// Get the source position of the edge.
+    ///
+    /// This requires the `circuit` the edge belongs to.
     pub fn source_position(&self, circuit: &StaticSizeCircuit) -> OpPosition {
         circuit
             .get_position(self.source(), self.source_port().index())
             .expect("invalid edge ID")
     }
 
+    /// Get the target of the edge.
+    ///
+    /// This requires the `circuit` the edge belongs to.
     pub fn target(&self, circuit: &StaticSizeCircuit) -> OpId {
         let (_, target) = circuit
             .linked_op(self.source().into(), self.source_port().into())
             .expect("invalid edge ID");
         target
     }
 
+    /// Get the target port of the edge.
+    ///
+    /// This requires the `circuit` the edge belongs to.
     pub fn target_port(&self, circuit: &StaticSizeCircuit) -> IncomingPort {
         let (target_port, _) = circuit
             .linked_op(self.source().into(), self.source_port().into())
             .expect("invalid edge ID");
         target_port.as_incoming().expect("invalid edge ID")
     }
 
+    /// Get the target position of the edge.
+    ///
+    /// This requires the `circuit` the edge belongs to.
     pub fn target_position(&self, circuit: &StaticSizeCircuit) -> OpPosition {
         circuit
             .get_position(self.target(circuit), self.target_port(circuit).index())

tket2/src/portmatching/constraint.rs

@@ -1,3 +1,4 @@
+//! Constraints for port matching.
 use std::collections::BTreeSet;
 
 use super::{indexing::PatternOpPosition, predicate::Predicate};

tket2/src/portmatching/indexing.rs

@@ -1,3 +1,5 @@
+//! Indexing scheme into StaticSizeCircuit.
+
 mod pattern;
 
 pub use pattern::{DisconnectedCircuit, PatternOpPosition};

tket2/src/portmatching/indexing/pattern.rs

@@ -6,7 +6,7 @@
 
 use std::collections::VecDeque;
 
-use crate::static_circ::{OpPosition, StaticQubitIndex, StaticSizeCircuit};
+use crate::static_circ::{OpPosition, StaticSizeCircuit};
 
 use itertools::Itertools;
 use thiserror::Error;
@@ -35,20 +35,24 @@ impl Ord for PatternOpPosition {
 }
 
 impl PatternOpPosition {
+    /// Create a new position in a pattern.
     pub fn new(qubit: CircuitPath, op_idx: i8) -> Self {
         Self { qubit, op_idx }
     }
 
+    /// Create a new position with a different operation index.
     pub fn with_op_idx(self, op_idx: i8) -> Self {
         Self { op_idx, ..self }
     }
 
+    /// Create a new position from an operation position.
     pub fn from_position(loc: OpPosition, starts: &[(CircuitPath, usize)]) -> Self {
         let (qubit_path, start) = starts[loc.qubit.0];
         let offset = (loc.index as i8) - (start as i8);
         PatternOpPosition::new(qubit_path, offset)
     }
 
+    /// Create the root pattern position.   
     pub fn root() -> Self {
         Self {
             qubit: CircuitPath([0; MAX_PATH_LEN * 2]),

tket2/src/portmatching/predicate.rs

@@ -1,3 +1,5 @@
+//! Pattern matching predicates.
+
 use std::collections::BTreeSet;
 
 use itertools::Itertools;
@@ -17,13 +19,28 @@ use super::{indexing::PatternOpPosition, Constraint};
 )]
 pub enum Predicate {
     /// An edge from `out_port` to `in_port`.
-    Link { out_port: usize, in_port: usize },
+    Link {
+        /// The outgoing source port of the edge.
+        out_port: usize,
+        /// The incoming target port of the edge.
+        in_port: usize,
+    },
     /// An operation of type `op`.
-    IsOp { op: Tk2Op },
+    IsOp {
+        /// The operation type to match.
+        op: Tk2Op,
+    },
     /// All locations are the same operation.
-    SameOp { arity: usize },
+    SameOp {
+        /// The arity of the predicate, i.e. the number of positions
+        /// that share the same op.
+        arity: usize,
+    },
     /// Check that the first qubit is distinct from all others.
-    DistinctQubits { n_qubits: usize },
+    DistinctQubits {
+        /// The number of positions to check.
+        n_qubits: usize,
+    },
 }
 
 impl pm::ArityPredicate for Predicate {

tket2/src/rewrite.rs

@@ -148,11 +148,14 @@ impl CircuitRewrite {
     }
 }
 
+/// The cost delta type for a rewrite rule.
 pub type CostDelta<S> = <<S as StrategyCost>::OpCost as CircuitCost>::CostDelta;
 
 /// Generate rewrite rules for circuits.
 pub trait Rewriter<C> {
+    /// The rewrite object type.
     type CircuitRewrite;
+    /// The error type for rewrite rules.
     type Error;
 
     /// Get the rewrite rules for a circuit.