Struct Replacement

pub struct Replacement<HostNode = Node> {
    pub removal: Vec<HostNode>,
    pub replacement: Hugr,
    pub adoptions: HashMap<Node, HostNode>,
    pub mu_inp: Vec<NewEdgeSpec<HostNode, Node>>,
    pub mu_out: Vec<NewEdgeSpec<Node, HostNode>>,
    pub mu_new: Vec<NewEdgeSpec<HostNode, HostNode>>,
}

Specification of a Replace operation

Fields

removal: Vec<HostNode>

The nodes to remove from the existing Hugr (known as Gamma). These must all have a common parent (i.e. be siblings). Called “S” in the spec. Must be non-empty - otherwise there is no parent under which to place Self::replacement, and there would be no possible Self::mu_inp, Self::mu_out or Self::adoptions.

replacement: Hugr

A hugr (not necessarily valid, as it may be missing edges and/or nodes), whose root is the same type as the root of Self::replacement. “G” in the spec.

adoptions: HashMap<Node, HostNode>

Describes how parts of the Hugr that would otherwise be removed should instead be preserved but with new parents amongst the newly-inserted nodes. This is a Map from container nodes in Self::replacement that have no children, to container nodes that are descended from Self::removal. The keys are the new parents for the children of the values. Note no value may be ancestor or descendant of another. This is “B” in the spec; “R” is the set of descendants of Self::removal that are not descendants of values here.

mu_inp: Vec<NewEdgeSpec<HostNode, Node>>

Edges from nodes in the existing Hugr that are not removed (NewEdgeSpec::src in Gamma\R) to inserted nodes (NewEdgeSpec::tgt in Self::replacement).

mu_out: Vec<NewEdgeSpec<Node, HostNode>>

Edges from inserted nodes (NewEdgeSpec::src in Self::replacement) to existing nodes not removed (NewEdgeSpec::tgt in Gamma \ R).

mu_new: Vec<NewEdgeSpec<HostNode, HostNode>>

Edges to add between existing nodes (both NewEdgeSpec::src and NewEdgeSpec::tgt in Gamma \ R). For example, in cases where the source had an edge to a removed node, and the target had an edge from a removed node, this would allow source to be directly connected to target.

Trait Implementations

impl<HostNode: Clone> Clone for Replacement<HostNode>

fn clone(&self) -> Replacement<HostNode>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<HostNode: Debug> Debug for Replacement<HostNode>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<HostNode: PartialEq> PartialEq for Replacement<HostNode>

fn eq(&self, other: &Replacement<HostNode>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<HostNode: HugrNode> PatchHugrMut for Replacement<HostNode>

type Outcome = HashMap<Node, HostNode>

Map from Node in replacement to corresponding Node in the result Hugr

const UNCHANGED_ON_FAILURE: bool = false

If true, [self.apply]’s of this rewrite guarantee that they do not mutate the Hugr when they return an Err. If false, there is no guarantee; the Hugr should be assumed invalid when Err is returned.

fn apply_hugr_mut( self, h: &mut impl HugrMut<Node = HostNode>, ) -> Result<Self::Outcome, Self::Error>

Mutate the specified Hugr, or fail with an error.

impl<HostNode: HugrNode> PatchVerification for Replacement<HostNode>

type Error = ReplaceError<HostNode>

The type of Error with which this Rewrite may fail

type Node = HostNode

The node type of the HugrView that this patch applies to.

fn verify(&self, h: &impl HugrView<Node = HostNode>) -> Result<(), Self::Error>

Checks whether the rewrite would succeed on the specified Hugr. If this call succeeds, Patch::apply should also succeed on the same h If this calls fails, Patch::apply would fail with the same error.

fn invalidated_nodes( &self, _: &impl HugrView<Node = Self::Node>, ) -> impl Iterator<Item = Self::Node>

Returns the nodes removed or altered by the rewrite. Modifying any of these nodes will invalidate the rewrite.

fn invalidation_set(&self) -> impl Iterator<Item = Self::Node>

👎Deprecated: Use/implement invalidated_nodes instead

The nodes invalidated by the rewrite. Deprecated: implement Self::invalidated_nodes instead. The default returns the empty iterator; this should be fine as there are no external calls.

impl<HostNode> StructuralPartialEq for Replacement<HostNode>