Struct Replacement

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

Specification of a Replace operation

Fields

removal: Vec<Node>

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, Node>

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>

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>

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

mu_new: Vec<NewEdgeSpec>

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 Clone for Replacement

fn clone(&self) -> Replacement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Replacement

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

Formats the value using the given formatter.

impl PartialEq for Replacement

fn eq(&self, other: &Replacement) -> 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 Rewrite for Replacement

type ApplyResult = HashMap<Node, Node>

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.

type Error = ReplaceError

The type of Error with which this Rewrite may fail

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

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

fn apply(self, h: &mut impl HugrMut) -> Result<Self::ApplyResult, Self::Error>

Mutate the specified Hugr, or fail with an error. Returns Self::ApplyResult if successful. If [self.unchanged_on_failure] is true, then h must be unchanged if Err is returned. See also [self.verify]

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

Returns a set of nodes referenced by the rewrite. Modifying any of these nodes will invalidate it.

impl StructuralPartialEq for Replacement