refactor: clean up fat.rs

doug-q · doug-q · commit 68ce052fa26a · 2024-06-21T12:22:55.000+01:00
diff --git a/src/emit.rs b/src/emit.rs
@@ -357,10 +357,8 @@ impl<'c, H: HugrView> EmitHugr<'c, H> {
     /// are not emitted directly, but instead by [hugr::ops::LoadConstant] emission. So
     /// [FuncDefn] and [FuncDecl] are the only interesting children.
     pub fn emit_module(mut self, node: FatNode<'c, hugr::ops::Module, H>) -> Result<Self> {
-        println!("emit module");
         for c in node.children() {
-            println!("emit child: {}", &c);
-            match c.get() {
+            match c.as_ref() {
                 OpType::FuncDefn(ref fd) => {
                     self = self.emit_global(c.into_ot(fd))?;
                 }
diff --git a/src/emit/args.rs b/src/emit/args.rs
@@ -25,9 +25,9 @@ impl<'c, OT, H> EmitOpArgs<'c, OT, H> {
 
 impl<'c, H: HugrView> EmitOpArgs<'c, OpType, H> {
     /// Attempt to specialise the internal [FatNode].
-    pub fn try_into_ot<OT: 'c>(self) -> Result<EmitOpArgs<'c, OT, H>, Self>
+    pub fn try_into_ot<OT>(self) -> Result<EmitOpArgs<'c, OT, H>, Self>
     where
-        &'c OpType: TryInto<&'c OT>,
+        for<'a> &'a OpType: TryInto<&'a OT>,
     {
         let EmitOpArgs {
             node,
diff --git a/src/emit/ops.rs b/src/emit/ops.rs
@@ -78,11 +78,9 @@ struct DataflowParentEmitter<'c, 'd, OT, H: HugrView> {
     outputs: Option<RowPromise<'c>>,
 }
 
-impl<'c, 'd, OT: OpTrait + 'c, H: HugrView> DataflowParentEmitter<'c, 'd, OT, H>
+impl<'c, 'd, OT: OpTrait, H: HugrView> DataflowParentEmitter<'c, 'd, OT, H>
 where
-    &'c OpType: TryInto<&'c OT>,
-    // &'c OpType: TryInto<&'c OT>,
-    // <&'c OpType as TryInto<&'c OT>>::Error: std::fmt::Debug,
+    for<'a> &'a OpType: TryInto<&'a OT>,
 {
     pub fn new(context: &'d mut EmitFuncContext<'c, H>, args: EmitOpArgs<'c, OT, H>) -> Self {
         Self {
@@ -111,10 +109,9 @@ where
     }
 
     pub fn emit_children(mut self) -> Result<()> {
-        use hugr::hugr::views::HierarchyView;
         use petgraph::visit::Topo;
         let node = self.node.clone();
-        if !OpTag::DataflowParent.is_superset(OpTrait::tag(node.get())) {
+        if !OpTag::DataflowParent.is_superset(node.tag()) {
             Err(anyhow!("Not a dataflow parent"))?
         };
 
@@ -124,7 +121,7 @@ where
         debug_assert!(i.out_value_types().count() == self.inputs.as_ref().unwrap().len());
         debug_assert!(o.in_value_types().count() == self.outputs.as_ref().unwrap().len());
 
-        let region: SiblingGraph = SiblingGraph::try_new(node.hugr(), node.node()).unwrap();
+        let region: SiblingGraph = node.try_new_hierarchy_view().unwrap();
         Topo::new(&region.as_petgraph())
             .iter(&region.as_petgraph())
             .filter(|x| (*x != node.node()))
@@ -142,17 +139,16 @@ where
     }
 }
 
-impl<'c, OT: OpTrait + 'c, H: HugrView> EmitOp<'c, OpType, H>
-    for DataflowParentEmitter<'c, '_, OT, H>
+impl<'c, OT: OpTrait, H: HugrView> EmitOp<'c, OpType, H> for DataflowParentEmitter<'c, '_, OT, H>
 where
-    &'c OpType: TryInto<&'c OT>,
+    for<'a> &'a OpType: TryInto<&'a OT>,
 {
     fn emit(&mut self, args: EmitOpArgs<'c, OpType, H>) -> Result<()> {
         if !OpTag::DataflowChild.is_superset(args.node().tag()) {
             Err(anyhow!("Not a dataflow child"))?
         };
 
-        match args.node().get() {
+        match args.node().as_ref() {
             OpType::Input(_) => {
                 let i = self.take_input()?;
                 args.outputs.finish(self.builder(), i)
@@ -283,12 +279,12 @@ pub fn emit_value<'c, H: HugrView>(
     }
 }
 
-pub(crate) fn emit_dataflow_parent<'c, OT: OpTrait + 'c, H: HugrView>(
+pub(crate) fn emit_dataflow_parent<'c, OT: OpTrait, H: HugrView>(
     context: &mut EmitFuncContext<'c, H>,
     args: EmitOpArgs<'c, OT, H>,
 ) -> Result<()>
 where
-    &'c OpType: TryInto<&'c OT>,
+    for<'a> &'a OpType: TryInto<&'a OT>,
 {
     DataflowParentEmitter::new(context, args).emit_children()
 }
@@ -347,7 +343,7 @@ fn emit_call<'c, H: HugrView>(
         .node
         .single_linked_output(args.node.called_function_port())
         .unwrap();
-    let func = match func_node.get() {
+    let func = match func_node.as_ref() {
         OpType::FuncDecl(_) => context.get_func_decl(func_node.try_into_ot().unwrap()),
         OpType::FuncDefn(_) => context.get_func_defn(func_node.try_into_ot().unwrap()),
         _ => Err(anyhow!("emit_call: Not a Decl or Defn")),
@@ -371,7 +367,7 @@ fn emit_optype<'c, H: HugrView>(
     args: EmitOpArgs<'c, OpType, H>,
 ) -> Result<()> {
     let node = args.node();
-    match node.get() {
+    match node.as_ref() {
         OpType::MakeTuple(ref mt) => emit_make_tuple(context, args.into_ot(mt)),
         OpType::UnpackTuple(ref ut) => emit_unpack_tuple(context, args.into_ot(ut)),
         OpType::Tag(ref tag) => emit_tag(context, args.into_ot(tag)),
diff --git a/src/fat.rs b/src/fat.rs
@@ -5,6 +5,7 @@
 use std::{cmp::Ordering, hash::Hash, marker::PhantomData, ops::Deref};
 
 use hugr::{
+    hugr::{views::HierarchyView, HugrError},
     ops::{DataflowBlock, ExitBlock, Input, NamedOp, OpType, Output, CFG},
     types::Type,
     Hugr, HugrView, IncomingPort, Node, NodeIndex, OutgoingPort,
@@ -23,7 +24,7 @@ use itertools::Itertools as _;
 /// different base [Hugr]s. Note that [Node] has this same behaviour.
 ///
 /// [FuncDefn]: [hugr::ops::FuncDefn]
-#[derive(Debug, Copy)]
+#[derive(Debug)]
 pub struct FatNode<'c, OT = OpType, H = Hugr>
 where
     H: ?Sized,
@@ -33,9 +34,9 @@ where
     marker: PhantomData<OT>,
 }
 
-impl<'c, OT: 'c, H: HugrView + ?Sized> FatNode<'c, OT, H>
+impl<'c, OT, H: HugrView + ?Sized> FatNode<'c, OT, H>
 where
-    &'c OpType: TryInto<&'c OT>,
+    for<'a> &'a OpType: TryInto<&'a OT>,
 {
     /// Create a `FatNode` from a [HugrView] and a [Node].
     ///
@@ -46,7 +47,7 @@ where
     /// do not verify that it is actually equal to `ot`.
     pub fn new(hugr: &'c H, node: Node, #[allow(unused)] ot: &OT) -> Self {
         assert!(hugr.valid_node(node));
-        assert!(TryInto::<&'c OT>::try_into(hugr.get_optype(node)).is_ok());
+        assert!(TryInto::<&OT>::try_into(hugr.get_optype(node)).is_ok());
         // We don't actually check `ot == hugr.get_optype(node)` so as to not require OT: PartialEq`
         Self {
             hugr,
@@ -68,9 +69,14 @@ where
         ))
     }
 
-    /// Gets the [OpType] of the `FatNode`.
-    pub fn get(&self) -> &'c OT {
-        self.hugr.get_optype(self.node).try_into().ok().unwrap()
+    /// Create a general `FatNode` from a specific one.
+    pub fn generalise(self) -> FatNode<'c, OpType, H> {
+        // guaranteed to be valid becasue self is valid
+        FatNode {
+            hugr: self.hugr,
+            node: self.node,
+            marker: PhantomData,
+        }
     }
 }
 
@@ -96,9 +102,9 @@ impl<'c, H: HugrView + ?Sized> FatNode<'c, OpType, H> {
     }
 
     /// Tries to downcast a general `FatNode` into a specific `OT`.
-    pub fn try_into_ot<OT: 'c>(&self) -> Option<FatNode<'c, OT, H>>
+    pub fn try_into_ot<OT>(&self) -> Option<FatNode<'c, OT, H>>
     where
-        &'c OpType: TryInto<&'c OT>,
+        for<'a> &'a OpType: TryInto<&'a OT>,
     {
         FatNode::try_new(self.hugr, self.node)
     }
@@ -110,7 +116,7 @@ impl<'c, H: HugrView + ?Sized> FatNode<'c, OpType, H> {
     ///
     /// Note that while we do check the type of the node's `get_optype`, we
     /// do not verify that it is actually equal to `ot`.
-    pub fn into_ot<OT: PartialEq + 'c>(self, ot: &OT) -> FatNode<'c, OT, H>
+    pub fn into_ot<OT>(self, ot: &OT) -> FatNode<'c, OT, H>
     where
         for<'a> &'a OpType: TryInto<&'a OT>,
     {
@@ -159,28 +165,24 @@ impl<'c, OT, H: HugrView + ?Sized> FatNode<'c, OT, H> {
         ))
     }
 
-    pub fn node_outputs(&self) -> impl Iterator<Item = OutgoingPort> + '_ {
+    /// Iterator over output ports of node.
+    pub fn node_outputs(&self) -> impl Iterator<Item = OutgoingPort> + 'c {
         self.hugr.node_outputs(self.node)
     }
 
-    pub fn output_neighbours(&self) -> impl Iterator<Item = FatNode<'c, OpType, H>> + '_ {
+    /// Iterates over the output neighbours of the `node`.
+    pub fn output_neighbours(&self) -> impl Iterator<Item = FatNode<'c, OpType, H>> + 'c {
         self.hugr
             .output_neighbours(self.node)
             .map(|n| FatNode::new_optype(self.hugr, n))
     }
 
-    /// Create a general `FatNode` from a specific one.
-    pub fn generalise(self) -> FatNode<'c, OpType, H>
+    /// Delegates to `HV::try_new` with the internal [HugrView] and [Node].
+    pub fn try_new_hierarchy_view<HV: HierarchyView<'c>>(&self) -> Result<HV, HugrError>
     where
-        for<'a> &'a OpType: TryInto<&'a OT>,
-        OT: 'c,
+        H: Sized,
     {
-        // guaranteed to be valid becasue self is valid
-        FatNode {
-            hugr: self.hugr,
-            node: self.node,
-            marker: PhantomData,
-        }
+        HV::try_new(self.hugr, self.node)
     }
 }
 
@@ -204,79 +206,79 @@ impl<'c, H: HugrView> FatNode<'c, CFG, H> {
     }
 }
 
-impl<'c, OT, H> PartialEq<Node> for FatNode<'c, OT, H> {
+impl<OT, H> PartialEq<Node> for FatNode<'_, OT, H> {
     fn eq(&self, other: &Node) -> bool {
         &self.node == other
     }
 }
 
-impl<'c, OT, H> PartialEq<FatNode<'c, OT, H>> for Node {
-    fn eq(&self, other: &FatNode<'c, OT, H>) -> bool {
+impl<OT, H> PartialEq<FatNode<'_, OT, H>> for Node {
+    fn eq(&self, other: &FatNode<'_, OT, H>) -> bool {
         self == &other.node
     }
 }
 
-impl<'c, 'd, OT1, OT2, H1, H2> PartialEq<FatNode<'d, OT1, H1>> for FatNode<'c, OT2, H2> {
-    fn eq(&self, other: &FatNode<'d, OT1, H1>) -> bool {
+impl<OT1, OT2, H1, H2> PartialEq<FatNode<'_, OT1, H1>> for FatNode<'_, OT2, H2> {
+    fn eq(&self, other: &FatNode<'_, OT1, H1>) -> bool {
         self.node == other.node
     }
 }
 
-impl<'c, OT, H> Eq for FatNode<'c, OT, H> {}
+impl<OT, H> Eq for FatNode<'_, OT, H> {}
 
-impl<'c, OT, H> PartialOrd<Node> for FatNode<'c, OT, H> {
+impl<OT, H> PartialOrd<Node> for FatNode<'_, OT, H> {
     fn partial_cmp(&self, other: &Node) -> Option<Ordering> {
         self.node.partial_cmp(other)
     }
 }
 
-impl<'c, OT, H> PartialOrd<FatNode<'c, OT, H>> for Node {
-    fn partial_cmp(&self, other: &FatNode<'c, OT, H>) -> Option<Ordering> {
+impl<OT, H> PartialOrd<FatNode<'_, OT, H>> for Node {
+    fn partial_cmp(&self, other: &FatNode<'_, OT, H>) -> Option<Ordering> {
         self.partial_cmp(&other.node)
     }
 }
 
-impl<'c, 'd, OT1, OT2, H1, H2> PartialOrd<FatNode<'d, OT1, H1>> for FatNode<'c, OT2, H2> {
-    fn partial_cmp(&self, other: &FatNode<'d, OT1, H1>) -> Option<Ordering> {
+impl<OT1, OT2, H1, H2> PartialOrd<FatNode<'_, OT1, H1>> for FatNode<'_, OT2, H2> {
+    fn partial_cmp(&self, other: &FatNode<'_, OT1, H1>) -> Option<Ordering> {
         self.partial_cmp(&other.node)
     }
 }
 
-impl<'c, OT, H> Ord for FatNode<'c, OT, H> {
+impl<OT, H> Ord for FatNode<'_, OT, H> {
     fn cmp(&self, other: &Self) -> Ordering {
         self.node.cmp(&other.node)
     }
 }
 
-impl<'c, OT, H> Hash for FatNode<'c, OT, H> {
+impl<OT, H> Hash for FatNode<'_, OT, H> {
     fn hash<HA: std::hash::Hasher>(&self, state: &mut HA) {
         self.node.hash(state);
     }
 }
 
-impl<'c, OT: 'c, H: HugrView + ?Sized> AsRef<OT> for FatNode<'c, OT, H>
+impl<OT, H: HugrView + ?Sized> AsRef<OT> for FatNode<'_, OT, H>
 where
     for<'a> &'a OpType: TryInto<&'a OT>,
 {
     fn as_ref(&self) -> &OT {
-        self.get()
+        self.hugr.get_optype(self.node).try_into().ok().unwrap()
     }
 }
 
-impl<'c, OT, H: HugrView + ?Sized> Deref for FatNode<'c, OT, H>
+impl<OT, H: HugrView + ?Sized> Deref for FatNode<'_, OT, H>
 where
-    &'c OpType: TryInto<&'c OT>,
-    <&'c OpType as TryInto<&'c OT>>::Error: std::fmt::Debug,
-    OT: 'c,
+    for<'a> &'a OpType: TryInto<&'a OT>,
 {
     type Target = OT;
 
     fn deref(&self) -> &Self::Target {
-        self.get()
+        self.as_ref()
     }
 }
 
-impl<'c, OT, H> Clone for FatNode<'c, OT, H> {
+impl<OT, H> Copy for FatNode<'_, OT, H> {}
+
+impl<OT, H> Clone for FatNode<'_, OT, H> {
     fn clone(&self) -> Self {
         Self {
             hugr: self.hugr,
@@ -288,22 +290,20 @@ impl<'c, OT, H> Clone for FatNode<'c, OT, H> {
 
 impl<'c, OT: NamedOp, H: HugrView + ?Sized> std::fmt::Display for FatNode<'c, OT, H>
 where
-    &'c OpType: TryInto<&'c OT>,
-    <&'c OpType as TryInto<&'c OT>>::Error: std::fmt::Debug,
-    OT: 'c,
+    for<'a> &'a OpType: TryInto<&'a OT>,
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_fmt(format_args!("N<{}:{}>", self.get().name(), self.node))
+        f.write_fmt(format_args!("N<{}:{}>", self.as_ref().name(), self.node))
     }
 }
 
-impl<'c, OT, H> NodeIndex for FatNode<'c, OT, H> {
+impl<OT, H> NodeIndex for FatNode<'_, OT, H> {
     fn index(self) -> usize {
         self.node.index()
     }
 }
 
-impl<'c, OT, H> NodeIndex for &FatNode<'c, OT, H> {
+impl<OT, H> NodeIndex for &FatNode<'_, OT, H> {
     fn index(self) -> usize {
         self.node.index()
     }
@@ -316,7 +316,7 @@ impl<'c, OT, H> NodeIndex for &FatNode<'c, OT, H> {
 /// TODO: Add the remaining [HugrView] equivalents that make sense.
 pub trait FatExt: HugrView {
     /// Try to create a specific [FatNode] for a given [Node].
-    fn try_fat<'c, OT: 'c>(&'c self, node: Node) -> Option<FatNode<'c, OT, Self>>
+    fn try_fat<OT>(&self, node: Node) -> Option<FatNode<OT, Self>>
     where
         for<'a> &'a OpType: TryInto<&'a OT>,
     {

Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`use std::{cmp::Ordering, hash::Hash, marker::PhantomData, ops::Deref};`
`6`	`6`
`7`	`7`	`use hugr::{`
	`8`	`+ hugr::{views::HierarchyView, HugrError},`
`8`	`9`	`ops::{DataflowBlock, ExitBlock, Input, NamedOp, OpType, Output, CFG},`
`9`	`10`	`types::Type,`
`10`	`11`	`Hugr, HugrView, IncomingPort, Node, NodeIndex, OutgoingPort,`
`@@ -23,7 +24,7 @@ use itertools::Itertools as _;`
`23`	`24`	`/// different base [Hugr]s. Note that [Node] has this same behaviour.`
`24`	`25`	`///`
`25`	`26`	`/// [FuncDefn]: [hugr::ops::FuncDefn]`
`26`		`-#[derive(Debug, Copy)]`
	`27`	`+#[derive(Debug)]`
`27`	`28`	`pub struct FatNode<'c, OT = OpType, H = Hugr>`
`28`	`29`	`where`
`29`	`30`	`H: ?Sized,`
`@@ -33,9 +34,9 @@ where`
`33`	`34`	`marker: PhantomData<OT>,`
`34`	`35`	`}`
`35`	`36`
`36`		`-impl<'c, OT: 'c, H: HugrView + ?Sized> FatNode<'c, OT, H>`
	`37`	`+impl<'c, OT, H: HugrView + ?Sized> FatNode<'c, OT, H>`
`37`	`38`	`where`
`38`		`- &'c OpType: TryInto<&'c OT>,`
	`39`	`+ for<'a> &'a OpType: TryInto<&'a OT>,`
`39`	`40`	`{`
`40`	`41`	/// Create a `FatNode` from a [HugrView] and a [Node].
`41`	`42`	`///`
`@@ -46,7 +47,7 @@ where`
`46`	`47`	/// do not verify that it is actually equal to `ot`.
`47`	`48`	`pub fn new(hugr: &'c H, node: Node, #[allow(unused)] ot: &OT) -> Self {`
`48`	`49`	`assert!(hugr.valid_node(node));`
`49`		`- assert!(TryInto::<&'c OT>::try_into(hugr.get_optype(node)).is_ok());`
	`50`	`+ assert!(TryInto::<&OT>::try_into(hugr.get_optype(node)).is_ok());`
`50`	`51`	// We don't actually check `ot == hugr.get_optype(node)` so as to not require OT: PartialEq`
`51`	`52`	`Self {`
`52`	`53`	`hugr,`
`@@ -68,9 +69,14 @@ where`
`68`	`69`	`))`
`69`	`70`	`}`
`70`	`71`
`71`		- /// Gets the [OpType] of the `FatNode`.
`72`		`- pub fn get(&self) -> &'c OT {`
`73`		`- self.hugr.get_optype(self.node).try_into().ok().unwrap()`
	`72`	+ /// Create a general `FatNode` from a specific one.
	`73`	`+ pub fn generalise(self) -> FatNode<'c, OpType, H> {`
	`74`	`+ // guaranteed to be valid becasue self is valid`
	`75`	`+ FatNode {`
	`76`	`+ hugr: self.hugr,`
	`77`	`+ node: self.node,`
	`78`	`+ marker: PhantomData,`
	`79`	`+ }`
`74`	`80`	`}`
`75`	`81`	`}`
`76`	`82`
`@@ -96,9 +102,9 @@ impl<'c, H: HugrView + ?Sized> FatNode<'c, OpType, H> {`
`96`	`102`	`}`
`97`	`103`
`98`	`104`	/// Tries to downcast a general `FatNode` into a specific `OT`.
`99`		`- pub fn try_into_ot<OT: 'c>(&self) -> Option<FatNode<'c, OT, H>>`
	`105`	`+ pub fn try_into_ot<OT>(&self) -> Option<FatNode<'c, OT, H>>`
`100`	`106`	`where`
`101`		`- &'c OpType: TryInto<&'c OT>,`
	`107`	`+ for<'a> &'a OpType: TryInto<&'a OT>,`
`102`	`108`	`{`
`103`	`109`	`FatNode::try_new(self.hugr, self.node)`
`104`	`110`	`}`
`@@ -110,7 +116,7 @@ impl<'c, H: HugrView + ?Sized> FatNode<'c, OpType, H> {`
`110`	`116`	`///`
`111`	`117`	/// Note that while we do check the type of the node's `get_optype`, we
`112`	`118`	/// do not verify that it is actually equal to `ot`.
`113`		`- pub fn into_ot<OT: PartialEq + 'c>(self, ot: &OT) -> FatNode<'c, OT, H>`
	`119`	`+ pub fn into_ot<OT>(self, ot: &OT) -> FatNode<'c, OT, H>`
`114`	`120`	`where`
`115`	`121`	`for<'a> &'a OpType: TryInto<&'a OT>,`
`116`	`122`	`{`
`@@ -159,28 +165,24 @@ impl<'c, OT, H: HugrView + ?Sized> FatNode<'c, OT, H> {`
`159`	`165`	`))`
`160`	`166`	`}`
`161`	`167`
`162`		`- pub fn node_outputs(&self) -> impl Iterator<Item = OutgoingPort> + '_ {`
	`168`	`+ /// Iterator over output ports of node.`
	`169`	`+ pub fn node_outputs(&self) -> impl Iterator<Item = OutgoingPort> + 'c {`
`163`	`170`	`self.hugr.node_outputs(self.node)`
`164`	`171`	`}`
`165`	`172`
`166`		`- pub fn output_neighbours(&self) -> impl Iterator<Item = FatNode<'c, OpType, H>> + '_ {`
	`173`	+ /// Iterates over the output neighbours of the `node`.
	`174`	`+ pub fn output_neighbours(&self) -> impl Iterator<Item = FatNode<'c, OpType, H>> + 'c {`
`167`	`175`	`self.hugr`
`168`	`176`	`.output_neighbours(self.node)`
`169`	`177`	`.map(\|n\| FatNode::new_optype(self.hugr, n))`
`170`	`178`	`}`
`171`	`179`
`172`		- /// Create a general `FatNode` from a specific one.
`173`		`- pub fn generalise(self) -> FatNode<'c, OpType, H>`
	`180`	+ /// Delegates to `HV::try_new` with the internal [HugrView] and [Node].
	`181`	`+ pub fn try_new_hierarchy_view<HV: HierarchyView<'c>>(&self) -> Result<HV, HugrError>`
`174`	`182`	`where`
`175`		`- for<'a> &'a OpType: TryInto<&'a OT>,`
`176`		`- OT: 'c,`
	`183`	`+ H: Sized,`
`177`	`184`	`{`
`178`		`- // guaranteed to be valid becasue self is valid`
`179`		`- FatNode {`
`180`		`- hugr: self.hugr,`
`181`		`- node: self.node,`
`182`		`- marker: PhantomData,`
`183`		`- }`
	`185`	`+ HV::try_new(self.hugr, self.node)`
`184`	`186`	`}`
`185`	`187`	`}`
`186`	`188`
`@@ -204,79 +206,79 @@ impl<'c, H: HugrView> FatNode<'c, CFG, H> {`
`204`	`206`	`}`
`205`	`207`	`}`
`206`	`208`
`207`		`-impl<'c, OT, H> PartialEq<Node> for FatNode<'c, OT, H> {`
	`209`	`+impl<OT, H> PartialEq<Node> for FatNode<'_, OT, H> {`
`208`	`210`	`fn eq(&self, other: &Node) -> bool {`
`209`	`211`	`&self.node == other`
`210`	`212`	`}`
`211`	`213`	`}`
`212`	`214`
`213`		`-impl<'c, OT, H> PartialEq<FatNode<'c, OT, H>> for Node {`
`214`		`- fn eq(&self, other: &FatNode<'c, OT, H>) -> bool {`
	`215`	`+impl<OT, H> PartialEq<FatNode<'_, OT, H>> for Node {`
	`216`	`+ fn eq(&self, other: &FatNode<'_, OT, H>) -> bool {`
`215`	`217`	`self == &other.node`
`216`	`218`	`}`
`217`	`219`	`}`
`218`	`220`
`219`		`-impl<'c, 'd, OT1, OT2, H1, H2> PartialEq<FatNode<'d, OT1, H1>> for FatNode<'c, OT2, H2> {`
`220`		`- fn eq(&self, other: &FatNode<'d, OT1, H1>) -> bool {`
	`221`	`+impl<OT1, OT2, H1, H2> PartialEq<FatNode<'_, OT1, H1>> for FatNode<'_, OT2, H2> {`
	`222`	`+ fn eq(&self, other: &FatNode<'_, OT1, H1>) -> bool {`
`221`	`223`	`self.node == other.node`
`222`	`224`	`}`
`223`	`225`	`}`
`224`	`226`
`225`		`-impl<'c, OT, H> Eq for FatNode<'c, OT, H> {}`
	`227`	`+impl<OT, H> Eq for FatNode<'_, OT, H> {}`
`226`	`228`
`227`		`-impl<'c, OT, H> PartialOrd<Node> for FatNode<'c, OT, H> {`
	`229`	`+impl<OT, H> PartialOrd<Node> for FatNode<'_, OT, H> {`
`228`	`230`	`fn partial_cmp(&self, other: &Node) -> Option<Ordering> {`
`229`	`231`	`self.node.partial_cmp(other)`
`230`	`232`	`}`
`231`	`233`	`}`
`232`	`234`
`233`		`-impl<'c, OT, H> PartialOrd<FatNode<'c, OT, H>> for Node {`
`234`		`- fn partial_cmp(&self, other: &FatNode<'c, OT, H>) -> Option<Ordering> {`
	`235`	`+impl<OT, H> PartialOrd<FatNode<'_, OT, H>> for Node {`
	`236`	`+ fn partial_cmp(&self, other: &FatNode<'_, OT, H>) -> Option<Ordering> {`
`235`	`237`	`self.partial_cmp(&other.node)`
`236`	`238`	`}`
`237`	`239`	`}`
`238`	`240`
`239`		`-impl<'c, 'd, OT1, OT2, H1, H2> PartialOrd<FatNode<'d, OT1, H1>> for FatNode<'c, OT2, H2> {`
`240`		`- fn partial_cmp(&self, other: &FatNode<'d, OT1, H1>) -> Option<Ordering> {`
	`241`	`+impl<OT1, OT2, H1, H2> PartialOrd<FatNode<'_, OT1, H1>> for FatNode<'_, OT2, H2> {`
	`242`	`+ fn partial_cmp(&self, other: &FatNode<'_, OT1, H1>) -> Option<Ordering> {`
`241`	`243`	`self.partial_cmp(&other.node)`
`242`	`244`	`}`
`243`	`245`	`}`
`244`	`246`
`245`		`-impl<'c, OT, H> Ord for FatNode<'c, OT, H> {`
	`247`	`+impl<OT, H> Ord for FatNode<'_, OT, H> {`
`246`	`248`	`fn cmp(&self, other: &Self) -> Ordering {`
`247`	`249`	`self.node.cmp(&other.node)`
`248`	`250`	`}`
`249`	`251`	`}`
`250`	`252`
`251`		`-impl<'c, OT, H> Hash for FatNode<'c, OT, H> {`
	`253`	`+impl<OT, H> Hash for FatNode<'_, OT, H> {`
`252`	`254`	`fn hash<HA: std::hash::Hasher>(&self, state: &mut HA) {`
`253`	`255`	`self.node.hash(state);`
`254`	`256`	`}`
`255`	`257`	`}`
`256`	`258`
`257`		`-impl<'c, OT: 'c, H: HugrView + ?Sized> AsRef<OT> for FatNode<'c, OT, H>`
	`259`	`+impl<OT, H: HugrView + ?Sized> AsRef<OT> for FatNode<'_, OT, H>`
`258`	`260`	`where`
`259`	`261`	`for<'a> &'a OpType: TryInto<&'a OT>,`
`260`	`262`	`{`
`261`	`263`	`fn as_ref(&self) -> &OT {`
`262`		`- self.get()`
	`264`	`+ self.hugr.get_optype(self.node).try_into().ok().unwrap()`
`263`	`265`	`}`
`264`	`266`	`}`
`265`	`267`
`266`		`-impl<'c, OT, H: HugrView + ?Sized> Deref for FatNode<'c, OT, H>`
	`268`	`+impl<OT, H: HugrView + ?Sized> Deref for FatNode<'_, OT, H>`
`267`	`269`	`where`
`268`		`- &'c OpType: TryInto<&'c OT>,`
`269`		`- <&'c OpType as TryInto<&'c OT>>::Error: std::fmt::Debug,`
`270`		`- OT: 'c,`
	`270`	`+ for<'a> &'a OpType: TryInto<&'a OT>,`
`271`	`271`	`{`
`272`	`272`	`type Target = OT;`
`273`	`273`
`274`	`274`	`fn deref(&self) -> &Self::Target {`
`275`		`- self.get()`
	`275`	`+ self.as_ref()`
`276`	`276`	`}`
`277`	`277`	`}`
`278`	`278`
`279`		`-impl<'c, OT, H> Clone for FatNode<'c, OT, H> {`
	`279`	`+impl<OT, H> Copy for FatNode<'_, OT, H> {}`
	`280`	`+`
	`281`	`+impl<OT, H> Clone for FatNode<'_, OT, H> {`
`280`	`282`	`fn clone(&self) -> Self {`
`281`	`283`	`Self {`
`282`	`284`	`hugr: self.hugr,`
`@@ -288,22 +290,20 @@ impl<'c, OT, H> Clone for FatNode<'c, OT, H> {`
`288`	`290`
`289`	`291`	`impl<'c, OT: NamedOp, H: HugrView + ?Sized> std::fmt::Display for FatNode<'c, OT, H>`
`290`	`292`	`where`
`291`		`- &'c OpType: TryInto<&'c OT>,`
`292`		`- <&'c OpType as TryInto<&'c OT>>::Error: std::fmt::Debug,`
`293`		`- OT: 'c,`
	`293`	`+ for<'a> &'a OpType: TryInto<&'a OT>,`
`294`	`294`	`{`
`295`	`295`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`296`		`- f.write_fmt(format_args!("N<{}:{}>", self.get().name(), self.node))`
	`296`	`+ f.write_fmt(format_args!("N<{}:{}>", self.as_ref().name(), self.node))`
`297`	`297`	`}`
`298`	`298`	`}`
`299`	`299`
`300`		`-impl<'c, OT, H> NodeIndex for FatNode<'c, OT, H> {`
	`300`	`+impl<OT, H> NodeIndex for FatNode<'_, OT, H> {`
`301`	`301`	`fn index(self) -> usize {`
`302`	`302`	`self.node.index()`
`303`	`303`	`}`
`304`	`304`	`}`
`305`	`305`
`306`		`-impl<'c, OT, H> NodeIndex for &FatNode<'c, OT, H> {`
	`306`	`+impl<OT, H> NodeIndex for &FatNode<'_, OT, H> {`
`307`	`307`	`fn index(self) -> usize {`
`308`	`308`	`self.node.index()`
`309`	`309`	`}`
`@@ -316,7 +316,7 @@ impl<'c, OT, H> NodeIndex for &FatNode<'c, OT, H> {`
`316`	`316`	`/// TODO: Add the remaining [HugrView] equivalents that make sense.`
`317`	`317`	`pub trait FatExt: HugrView {`
`318`	`318`	`/// Try to create a specific [FatNode] for a given [Node].`
`319`		`- fn try_fat<'c, OT: 'c>(&'c self, node: Node) -> Option<FatNode<'c, OT, Self>>`
	`319`	`+ fn try_fat<OT>(&self, node: Node) -> Option<FatNode<OT, Self>>`
`320`	`320`	`where`
`321`	`321`	`for<'a> &'a OpType: TryInto<&'a OT>,`
`322`	`322`	`{`