Struct SimpleReplacement

pub struct SimpleReplacement<HostNode = Node> { /* private fields */ }

Specification of a simple replacement operation.

Type parameters

• N: The type of nodes in the host hugr.

Implementations

impl<N> SimpleReplacement<N>

pub fn from_serial<H: Into<Hugr>>(value: SerialSimpleReplacement<H, N>) -> Self

Create a new SimpleReplacement from its serialized format

pub fn into_serial<H: From<Hugr>>(self) -> SerialSimpleReplacement<H, N>

Convert a SimpleReplacement into its serialized format

pub fn to_serial<'a, H>(&'a self) -> SerialSimpleReplacement<H, N>

where N: Clone, H: From<&'a Hugr>,

Create its serialized format from a reference to SimpleReplacement

impl<HostNode: HugrNode> SimpleReplacement<HostNode>

pub fn new_unchecked( subgraph: SiblingSubgraph<HostNode>, replacement: Hugr, ) -> Self

Create a new SimpleReplacement specification without checking that the replacement has the same signature as the subgraph.

pub fn try_new( subgraph: SiblingSubgraph<HostNode>, host: &impl HugrView<Node = HostNode>, replacement: Hugr, ) -> Result<Self, InvalidReplacement>

Create a new SimpleReplacement specification.

Return a InvalidReplacement::InvalidSignature error if subgraph and replacement have different signatures.

pub fn replacement(&self) -> &Hugr

The replacement hugr.

pub fn into_replacement(self) -> Hugr

Consume self and return the replacement hugr.

pub fn subgraph(&self) -> &SiblingSubgraph<HostNode>

Subgraph to be replaced.

pub fn is_valid_rewrite( &self, h: &impl HugrView<Node = HostNode>, ) -> Result<(), SimpleReplacementError>

Check if the replacement can be applied to the given hugr.

pub fn get_replacement_io(&self) -> [Node; 2]

Get the input and output nodes of the replacement hugr.

pub fn linked_replacement_output( &self, port: impl Into<HostPort<HostNode, IncomingPort>>, host: &impl HugrView<Node = HostNode>, boundary: BoundaryMode, ) -> Option<BoundaryPort<HostNode, OutgoingPort>>

Traverse output boundary edge from host to replacement.

Given an incoming port in host linked to an output boundary port of subgraph, return the port it will be linked to after application of self.

The returned port will be in replacement, unless the wire in the replacement is empty and boundary is BoundaryMode::SnapToHost (the default), in which case it will be another host port. If BoundaryMode::IncludeIO is passed, the returned port will always be in replacement even if it is invalid (i.e. it is an IO node in the replacement).

pub fn linked_host_outputs( &self, port: impl Into<ReplacementPort<OutgoingPort>>, host: &impl HugrView<Node = HostNode>, ) -> impl Iterator<Item = HostPort<HostNode, IncomingPort>>

Traverse output boundary edge from replacement to host.

port must be an outgoing port linked to the output node of replacement.

This is the inverse of Self::linked_replacement_output, in the case where the latter returns a BoundaryPort::Replacement port.

pub fn linked_replacement_inputs<'a>( &'a self, port: impl Into<HostPort<HostNode, OutgoingPort>>, host: &'a impl HugrView<Node = HostNode>, boundary: BoundaryMode, ) -> impl Iterator<Item = BoundaryPort<HostNode, IncomingPort>> + 'a

Traverse input boundary edge from host to replacement.

Given an outgoing port in host linked to an input boundary port of subgraph, return the ports it will be linked to after application of self.

The returned ports will be in replacement, unless the wires in the replacement are empty and boundary is BoundaryMode::SnapToHost (the default), in which case they will be other host ports. If BoundaryMode::IncludeIO is passed, the returned ports will always be in replacement even if they are invalid (i.e. they are an IO node in the replacement).

pub fn linked_host_input( &self, port: impl Into<ReplacementPort<IncomingPort>>, host: &impl HugrView<Node = HostNode>, ) -> HostPort<HostNode, OutgoingPort>

Traverse output boundary edge from replacement to host.

port must be an outgoing port linked to the output node of replacement.

This is the inverse of Self::linked_replacement_output, in the case where the latter returns a BoundaryPort::Replacement port.

pub fn incoming_boundary<'a>( &'a self, host: &'a impl HugrView<Node = HostNode>, ) -> impl Iterator<Item = (HostPort<HostNode, OutgoingPort>, ReplacementPort<IncomingPort>)> + 'a

Get all edges that the replacement would add from outgoing ports in host to incoming ports in self.replacement.

For each pair in the returned vector, the first element is a port in host and the second is a port in self.replacement:

• The outgoing host ports are always linked to the input boundary of subgraph, i.e. the ports returned by SiblingSubgraph::incoming_ports,
• The incoming replacement ports are always linked to output ports of the OpTag::Input node of self.replacement.

pub fn outgoing_boundary<'a>( &'a self, host: &'a impl HugrView<Node = HostNode>, ) -> impl Iterator<Item = (ReplacementPort<OutgoingPort>, HostPort<HostNode, IncomingPort>)> + 'a

Get all edges that the replacement would add from outgoing ports in self.replacement to incoming ports in host.

For each pair in the returned vector, the first element is a port in self.replacement and the second is a port in host:

• The outgoing replacement ports are always linked to inputs of the OpTag::Output node of self.replacement,
• The incoming host ports are always linked to the output boundary of subgraph, i.e. the ports returned by SiblingSubgraph::outgoing_ports,

This panics if self.replacement is not a DFG.

pub fn host_to_host_boundary<'a>( &'a self, host: &'a impl HugrView<Node = HostNode>, ) -> impl Iterator<Item = (HostPort<HostNode, OutgoingPort>, HostPort<HostNode, IncomingPort>)> + 'a

Get all edges that the replacement would add between ports in host.

These correspond to direct edges between the input and output nodes in the replacement graph.

For each pair in the returned vector, both ports are in host:

• The outgoing host ports are linked to the input boundary of subgraph, i.e. the ports returned by SiblingSubgraph::incoming_ports,
• The incoming host ports are linked to the output boundary of subgraph, i.e. the ports returned by SiblingSubgraph::outgoing_ports.

This panics if self.replacement is not a DFG.

pub fn map_host_output( &self, port: impl Into<HostPort<HostNode, OutgoingPort>>, ) -> Option<ReplacementPort<IncomingPort>>

Get the incoming port at the output node of self.replacement that corresponds to the given outgoing port on the subgraph output boundary.

The host port should be a port in self.subgraph().outgoing_ports().

This panics if self.replacement is not a DFG.

pub fn map_replacement_input( &self, port: impl Into<ReplacementPort<OutgoingPort>>, ) -> impl Iterator<Item = HostPort<HostNode, IncomingPort>> + '_

Get the incoming port in subgraph that corresponds to the given replacement input port.

This panics if self.replacement is not a DFG.

pub fn all_boundary_edges<'a>( &'a self, host: &'a impl HugrView<Node = HostNode>, ) -> impl Iterator<Item = (BoundaryPort<HostNode, OutgoingPort>, BoundaryPort<HostNode, IncomingPort>)> + 'a

Get all edges that the replacement would add between host and self.replacement.

This is equivalent to chaining the results of Self::incoming_boundary, Self::outgoing_boundary, and Self::host_to_host_boundary.

This panics if self.replacement is not a DFG.

pub fn map_host_nodes<N: HugrNode>( &self, node_map: impl Fn(HostNode) -> N, new_host: &impl HugrView<Node = N>, ) -> Result<SimpleReplacement<N>, InvalidReplacement>

Map the host nodes in self according to node_map.

node_map must map nodes in the current HUGR of the subgraph to its equivalent nodes in some new_host.

This converts a replacement that acts on nodes of type HostNode to a replacement that acts on new_host, with nodes of type N.

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

Allows to get the Self::invalidated_nodes without requiring a HugrView.

Trait Implementations

impl<HostNode: Clone> Clone for SimpleReplacement<HostNode>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<HostNode: Debug> Debug for SimpleReplacement<HostNode>

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

Formats the value using the given formatter.

impl<H: Into<Hugr>, N> From<SerialSimpleReplacement<H, N>> for SimpleReplacement<N>

fn from(value: SerialSimpleReplacement<H, N>) -> Self

Converts to this type from the input type.

impl<N, H: From<Hugr>> From<SimpleReplacement<N>> for SerialSimpleReplacement<H, N>

fn from(value: SimpleReplacement<N>) -> Self

Converts to this type from the input type.

impl<N: HugrNode> PatchHugrMut for SimpleReplacement<N>

const UNCHANGED_ON_FAILURE: bool = true

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 Outcome = Outcome<N>

The type returned on successful application of the rewrite.

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

Mutate the specified Hugr, or fail with an error.

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

type Error = SimpleReplacementError

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<(), SimpleReplacementError>

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.