Enum NodeLinkingDirective 

#[non_exhaustive]
pub enum NodeLinkingDirective<TN = Node> {
    Add {
        replace: Vec<TN>,
    },
    UseExisting(TN),
}

Directive for how to treat a particular module-child in the source Hugr. (TN is a node in the target Hugr.)

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Add

Insert the module-child (with subtree if any) into the target Hugr.

Fields

replace: Vec<TN>

Existing/old nodes in the target which will be removed (with their subtrees), and any static (EdgeKind::Function/EdgeKind::Const) edges from them changed to leave the newly-inserted node instead. (Typically, this Vec would contain at most one FuncDefn, or perhaps-multiple, aliased, FuncDecls.)

UseExisting(TN)

Do not insert the node/subtree from the source, but for any static edge from it to an inserted node, instead add an edge from the specified node already existing in the target Hugr. (Static edges are EdgeKind::Function and EdgeKind::Const.)

Implementations

impl<TN> NodeLinkingDirective<TN>

pub const fn add() -> Self

Just add the node (and any subtree) into the target. (Could lead to an invalid Hugr if the target Hugr already has another with the same name and both are Public)

pub fn replace(nodes: impl IntoIterator<Item = TN>) -> Self

The new node should replace the specified node(s) already existing in the target.

(Could lead to an invalid Hugr if they have different signatures, or if the target already has another function with the same name and both are public.)

Trait Implementations

impl<TN: Clone> Clone for NodeLinkingDirective<TN>

fn clone(&self) -> NodeLinkingDirective<TN>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<TN: Debug> Debug for NodeLinkingDirective<TN>

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

Formats the value using the given formatter.

impl<TN: Hash> Hash for NodeLinkingDirective<TN>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<TN: PartialEq> PartialEq for NodeLinkingDirective<TN>

fn eq(&self, other: &NodeLinkingDirective<TN>) -> 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<TN: Eq> Eq for NodeLinkingDirective<TN>

impl<TN> StructuralPartialEq for NodeLinkingDirective<TN>