Struct Walker

pub struct Walker<'a> { /* private fields */ }

A walker over a CommitStateSpace.

A walker is given by a set of selected commits, along with a set of pinned nodes that belong to those selected commits. The selected commits determine which replacements in the state space are applied. Meanwhile, the pinned nodes within these commits determine which nodes are “frozen” in the exploration: no further commit can be selected that would invalidate any pinned node.

The set of selected commits of a walker defines a PersistentHugr instance that can be retrieved by calling Walker::into_persistent_hugr. As the walker is expanded and more of the state space is explored, more commits are selected, and the PersistentHugr will change accordingly. Pinned nodes (and pinned ports, i.e. ports at pinned nodes) are guaranteed to be valid in all PersistentHugr instances obtained as a result of expansions of the current walker. current walker.

Implementations

impl<'a> Walker<'a>

pub fn new(state_space: impl Into<Cow<'a, CommitStateSpace>>) -> Self

Create a new Walker over the given state space.

No nodes are pinned initially. The Walker starts with only the base Hugr state_space.base_hugr() selected.

pub fn from_pinned_node( node: PatchNode, state_space: impl Into<Cow<'a, CommitStateSpace>>, ) -> Self

Create a new Walker with a single pinned node.

pub fn try_pin_node(&mut self, node: PatchNode) -> Result<bool, PinNodeError>

Pin a node in the Walker.

This method allows pinning a specific node in the Walker, which restricts the possible paths that can be explored in the Walker.

Return true if node was not pinned already, and false otherwise.

If the node belongs to a commit that isn’t currently selected, the commit is added to the Walker, or an error is returned if this is not possible. The node is then added to the set of pinned nodes. If the node is already pinned, this method is a no-op.

pub fn get_wire(&self, node: PatchNode, port: impl Into<Port>) -> PinnedWire

Get the wire connected to a specified port of a pinned node.

Panics

Panics if node is not already pinned in this Walker.

pub fn into_persistent_hugr(self) -> PersistentHugr

Materialise the PersistentHugr containing all the compatible commits that have been selected during exploration.

pub fn as_hugr_view(&self) -> &PersistentHugr

View the PersistentHugr containing all the compatible commits that have been selected so far during exploration.

Of the space of all possible HUGRs that can be obtained from future expansions of the walker, this is the HUGR corresponding to selecting as few commits as possible (i.e. all the commits that have been selected so far and no more).

pub fn expand<'b>( &'b self, wire: &'b PinnedWire, dir: impl Into<Option<Direction>>, ) -> impl Iterator<Item = Walker<'a>> + 'b

Expand the Walker by pinning a node connected to the given wire.

To understand how Walkers are expanded, it is useful to understand how in a walker, the HUGR graph is partitioned into two parts:

• a subgraph made of pinned nodes: this part of the HUGR is frozen: it cannot be modified by further expansions the Walker.
• the complement subgraph: the unpinned part of the HUGR has not been explored yet. Multiple alternative HUGRs can be obtained depending on which commits are selected.

To every walker thus corresponds a space of possible HUGRs that can be obtained, depending on which commits are selected and which further nodes are pinned. The expansion of a walker returns a set of walkers, which together cover the same space of possible HUGRs, each having a different additional node pinned.

Return an iterator over all possible Walkers that can be created by pinning exactly one additional node connected to wire. Each returned Walker represents a different alternative Hugr in the exploration space.

Optionally, the expansion can be restricted to only ports with the given direction (incoming or outgoing).

Repeatedly calling expand on a wire will progressively pin all its endpoints. The multiple alternative Walkers returned then form a branching search space to be explored by the user. When a wire is fully pinned in the specified direction, i.e. wire.is_complete(dir) is true, then an empty iterator is returned.

Trait Implementations

impl<'a> Clone for Walker<'a>

fn clone(&self) -> Walker<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Walker<'a>

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

Formats the value using the given formatter.