Struct hugr_core :: hugr :: Hugr Copy item path

impl Hugr

pub fn validate( &self, extension_registry: &ExtensionRegistry, ) -> Result<(), ValidationError>

Check the validity of the HUGR, assuming that it has no open extension variables. TODO: Add a version of validation which allows for open extension variables (see github issue #457)

pub fn validate_no_extensions( &self, extension_registry: &ExtensionRegistry, ) -> Result<(), ValidationError>

Check the validity of the HUGR, but don’t check consistency of extension requirements between connected nodes or between parents and children.

pub fn validate_extensions(&self) -> Result<(), ValidationError>

Validate extensions, i.e. that extension deltas from parent nodes are reflected in their children.

impl Hugr

Public API for HUGRs.

pub fn new(root_node: impl Into<OpType>) -> Self

Create a new Hugr, with a single root node.

pub fn update_validate( &mut self, extension_registry: &ExtensionRegistry, ) -> Result<(), ValidationError>

Resolve extension ops, infer extensions used, and pass the closure into validation

pub fn infer_extensions(&mut self, remove: bool) -> Result<(), ExtensionError>

Infers an extension-delta for any non-function container node whose current extension_delta contains TO_BE_INFERRED. The inferred delta will be the smallest delta compatible with its children and that includes any other ExtensionIds in the current delta.

If remove is true, for such container nodes without TO_BE_INFERRED, ExtensionIds are removed from the delta if they are not used by any child node.

The non-function container nodes are: Case, CFG, Conditional, DataflowBlock, DFG, TailLoop

impl Hugr

Internal API for HUGRs, not intended for use by users.

pub fn canonicalize_nodes(&mut self, rekey: impl FnMut(Node, Node))

Compact the nodes indices of the hugr to be contiguous, and order them as a breadth-first traversal of the hierarchy.

The rekey function is called for each moved node with the old and new indices.

After this operation, a serialization and deserialization of the Hugr is guaranteed to preserve the indices.

Trait Implementations§

impl AsMut<Hugr> for Hugr

fn as_mut(&mut self) -> &mut Hugr

Converts this type into a mutable reference of the (usually inferred) input type.

impl AsRef<Hugr> for Hugr

fn as_ref(&self) -> &Hugr

Converts this type into a shared reference of the (usually inferred) input type.

impl<H: AsRef<Hugr>, Root> AsRef<Hugr> for RootChecked<H, Root>

fn as_ref(&self) -> &Hugr

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Hugr

fn clone(&self) -> Hugr

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl Debug for Hugr

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

Formats the value using the given formatter. Read more

impl Default for Hugr

fn default() -> Self

Returns the “default value” for a type. Read more

impl<'de> Deserialize<'de> for Hugr

fn deserialize<D>(deserializer: D) -> Result<Hugr, D::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

impl ExtractHugr for &Hugr

fn extract_hugr(self) -> Hugr

Extracts the view into an owned HUGR, rooted at the view’s root node and containing only the nodes and edges of the view.

impl ExtractHugr for &mut Hugr

fn extract_hugr(self) -> Hugr

Extracts the view into an owned HUGR, rooted at the view’s root node and containing only the nodes and edges of the view.

impl ExtractHugr for Hugr

fn extract_hugr(self) -> Hugr

Extracts the view into an owned HUGR, rooted at the view’s root node and containing only the nodes and edges of the view.

impl PartialEq for Hugr

fn eq(&self, other: &Hugr) -> bool

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

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

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

impl RootTagged for &Hugr

type RootHandle = Node

The kind of handle that can be used to refer to the root node. Read more

impl RootTagged for &mut Hugr

type RootHandle = Node

The kind of handle that can be used to refer to the root node. Read more

impl RootTagged for Hugr

type RootHandle = Node

The kind of handle that can be used to refer to the root node. Read more

impl Serialize for Hugr

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more

impl StructuralPartialEq for Hugr

Auto Trait Implementations§

impl !UnwindSafe for Hugr

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> CloneToUninit for T
where T: Clone,

default unsafe fn clone_to_uninit(&self, dst: *mut T)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dst. Read more

impl<T> Conv for T

fn conv<T>(self) -> T
where Self: Into<T>,

Converts self into T using Into<T>. Read more

impl<T> Downcast for T
where T: Any,

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.

impl<T> DowncastSync for T
where T: Any + Send + Sync,

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.

impl<T> FmtForward for T

fn fmt_binary(self) -> FmtBinary<Self>
where Self: Binary,

Causes self to use its Binary implementation when Debug-formatted.

fn fmt_display(self) -> FmtDisplay<Self>
where Self: Display,

Causes self to use its Display implementation when Debug-formatted.

fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where Self: LowerExp,

Causes self to use its LowerExp implementation when Debug-formatted.

fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where Self: LowerHex,

Causes self to use its LowerHex implementation when Debug-formatted.

fn fmt_octal(self) -> FmtOctal<Self>
where Self: Octal,

Causes self to use its Octal implementation when Debug-formatted.

fn fmt_pointer(self) -> FmtPointer<Self>
where Self: Pointer,

Causes self to use its Pointer implementation when Debug-formatted.

fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where Self: UpperExp,

Causes self to use its UpperExp implementation when Debug-formatted.

fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where Self: UpperHex,

Causes self to use its UpperHex implementation when Debug-formatted.

fn fmt_list(self) -> FmtList<Self>
where &'a Self: for<'a> IntoIterator,

Formats each item in a sequence. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> HugrInternals for T
where T: AsRef<Hugr>,

type Portgraph<'p> = &'p MultiPortGraph where T: 'p

The underlying portgraph view type.

fn portgraph(&self) -> <T as HugrInternals>::Portgraph<'_>

Returns a reference to the underlying portgraph.

fn base_hugr(&self) -> &Hugr

Returns the Hugr at the base of a chain of views.

fn root_node(&self) -> Node

Return the root node of this view.

impl<T> HugrMut for T
where T: RootTagged<RootHandle = Node> + AsMut<Hugr>,

fn add_node_with_parent( &mut self, parent: Node, node: impl Into<OpType>, ) -> Node

Add a node to the graph with a parent in the hierarchy. Read more

fn add_node_before( &mut self, sibling: Node, nodetype: impl Into<OpType>, ) -> Node

Add a node to the graph as the previous sibling of another node. Read more

fn add_node_after(&mut self, sibling: Node, op: impl Into<OpType>) -> Node

Add a node to the graph as the next sibling of another node. Read more

fn remove_node(&mut self, node: Node)

Remove a node from the graph. Read more

fn connect( &mut self, src: Node, src_port: impl Into<OutgoingPort>, dst: Node, dst_port: impl Into<IncomingPort>, )

Connect two nodes at the given ports. Read more

fn disconnect(&mut self, node: Node, port: impl Into<Port>)

Disconnects all edges from the given port. Read more

fn add_other_edge( &mut self, src: Node, dst: Node, ) -> (OutgoingPort, IncomingPort)

Adds a non-dataflow edge between two nodes. The kind is given by the operation’s OpTrait::other_input or OpTrait::other_output. Read more

fn insert_hugr(&mut self, root: Node, other: Hugr) -> InsertionResult

Insert another hugr into this one, under a given root node. Read more

fn insert_from_view( &mut self, root: Node, other: &impl HugrView, ) -> InsertionResult

Copy another hugr into this one, under a given root node. Read more

fn insert_subgraph( &mut self, root: Node, other: &impl HugrView, subgraph: &SiblingSubgraph, ) -> HashMap<Node, Node>

Copy a subgraph from another hugr into this one, under a given root node. Read more

fn get_metadata_mut( &mut self, node: Node, key: impl AsRef<str>, ) -> &mut NodeMetadata

Returns a metadata entry associated with a node. Read more

fn set_metadata( &mut self, node: Node, key: impl AsRef<str>, metadata: impl Into<NodeMetadata>, )

Sets a metadata value associated with a node. Read more

fn take_node_metadata(&mut self, node: Node) -> Option<NodeMetadataMap>

Retrieve the complete metadata map for a node.

fn overwrite_node_metadata( &mut self, node: Node, metadata: Option<NodeMetadataMap>, )

Overwrite the complete metadata map for a node. Read more

fn apply_rewrite<R, E>( &mut self, rw: impl Rewrite<ApplyResult = R, Error = E>, ) -> Result<R, E>
where Self: Sized,

Applies a rewrite to the graph.

impl<T> HugrMutInternals for T
where T: RootTagged<RootHandle = Node> + AsMut<Hugr>,

fn hugr_mut(&mut self) -> &mut Hugr

Returns the Hugr at the base of a chain of views.

fn set_num_ports(&mut self, node: Node, incoming: usize, outgoing: usize)

Set the number of ports on a node. This may invalidate the node’s PortIndex. Read more

fn add_ports( &mut self, node: Node, direction: Direction, amount: isize, ) -> Range<usize>

Alter the number of ports on a node and returns a range with the new port offsets, if any. This may invalidate the node’s PortIndex. Read more

fn set_parent(&mut self, node: Node, parent: Node)

Sets the parent of a node. Read more

fn move_after_sibling(&mut self, node: Node, after: Node)

Move a node in the hierarchy to be the subsequent sibling of another node. Read more

fn move_before_sibling(&mut self, node: Node, before: Node)

Move a node in the hierarchy to be the prior sibling of another node. Read more

fn replace_op( &mut self, node: Node, op: impl Into<OpType>, ) -> Result<OpType, HugrError>

Replace the OpType at node and return the old OpType. In general this invalidates the ports, which may need to be resized to match the OpType signature. TODO: Add a version which ignores input extensions Read more

impl<T> HugrView for T
where T: AsRef<Hugr>,

type Nodes<'a> = MapSpecialCase<Nodes<'a>, MapSpecialCaseFnInto<Node>> where T: 'a

An Iterator over the nodes in a Hugr(View)

type NodePorts<'a> = MapSpecialCase<NodePortOffsets, MapSpecialCaseFnInto<Port>> where T: 'a

An Iterator over (some or all) ports of a node

type Children<'a> = MapSpecialCase<Children<'a>, MapSpecialCaseFnInto<Node>> where T: 'a

An Iterator over the children of a node

type Neighbours<'a> = MapSpecialCase<Neighbours<'a>, MapSpecialCaseFnInto<Node>> where T: 'a

An Iterator over (some or all) the nodes neighbouring a node

type PortLinks<'a> = MapCtx<WithCtx<PortLinks<'a>, &'a Hugr>, (Node, Port)> where T: 'a

Iterator over the children of a node

type NodeConnections<'a> = MapCtx<WithCtx<NodeConnections<'a>, &'a Hugr>, [Port; 2]> where T: 'a

Iterator over the links between two nodes.

fn contains_node(&self, node: Node) -> bool

Returns whether the node exists.

fn node_count(&self) -> usize

Returns the number of nodes in the hugr.

fn edge_count(&self) -> usize

Returns the number of edges in the hugr.

fn nodes(&self) -> <T as HugrView>::Nodes<'_>

Iterates over the nodes in the port graph.

fn node_ports( &self, node: Node, dir: Direction, ) -> <T as HugrView>::NodePorts<'_>

Iterator over ports of node in a given direction.

fn all_node_ports(&self, node: Node) -> <T as HugrView>::NodePorts<'_>

Iterator over both the input and output ports of node.

fn linked_ports( &self, node: Node, port: impl Into<Port>, ) -> <T as HugrView>::PortLinks<'_>

Iterator over the nodes and ports connected to a port.

fn node_connections( &self, node: Node, other: Node, ) -> <T as HugrView>::NodeConnections<'_>

Iterator the links between two nodes.

fn num_ports(&self, node: Node, dir: Direction) -> usize

Number of ports in node for a given direction.

fn children(&self, node: Node) -> <T as HugrView>::Children<'_>

Return iterator over the direct children of node.

fn neighbours( &self, node: Node, dir: Direction, ) -> <T as HugrView>::Neighbours<'_>

Iterates over neighbour nodes in the given direction. May contain duplicates if the graph has multiple links between nodes.

fn all_neighbours(&self, node: Node) -> <T as HugrView>::Neighbours<'_>

Iterates over the input and output neighbours of the node in sequence.

fn root(&self) -> Node

Return the root node of this view.

fn root_type(&self) -> &OpType

Return the type of the HUGR root node.

fn valid_node(&self, node: Node) -> bool

Validates that a node is valid in the graph.

fn valid_non_root(&self, node: Node) -> bool

Validates that a node is a valid root descendant in the graph. Read more

fn get_parent(&self, node: Node) -> Option<Node>

Returns the parent of a node.

fn get_optype(&self, node: Node) -> &OpType

Returns the operation type of a node.

fn get_metadata( &self, node: Node, key: impl AsRef<str>, ) -> Option<&NodeMetadata>

Returns the metadata associated with a node.

fn get_node_metadata(&self, node: Node) -> Option<&NodeMetadataMap>

Retrieve the complete metadata map for a node.

fn node_outputs(&self, node: Node) -> OutgoingPorts<Self::NodePorts<'_>>

Iterator over output ports of node. Like node_ports(node, Direction::Outgoing) but preserves knowledge that the ports are OutgoingPorts.

fn node_inputs(&self, node: Node) -> IncomingPorts<Self::NodePorts<'_>>

Iterator over inputs ports of node. Like node_ports(node, Direction::Incoming) but preserves knowledge that the ports are IncomingPorts.

fn all_linked_ports( &self, node: Node, dir: Direction, ) -> Either<impl Iterator<Item = (Node, OutgoingPort)>, impl Iterator<Item = (Node, IncomingPort)>> ⓘ

Iterator over all the nodes and ports connected to a node in a given direction.

fn all_linked_outputs( &self, node: Node, ) -> impl Iterator<Item = (Node, OutgoingPort)>

Iterator over all the nodes and ports connected to a node’s inputs.

fn all_linked_inputs( &self, node: Node, ) -> impl Iterator<Item = (Node, IncomingPort)>

Iterator over all the nodes and ports connected to a node’s outputs.

fn single_linked_port( &self, node: Node, port: impl Into<Port>, ) -> Option<(Node, Port)>

If there is exactly one port connected to this port, return it and its node.

fn single_linked_output( &self, node: Node, port: impl Into<IncomingPort>, ) -> Option<(Node, OutgoingPort)>

If there is exactly one OutgoingPort connected to this IncomingPort, return it and its node.

fn single_linked_input( &self, node: Node, port: impl Into<OutgoingPort>, ) -> Option<(Node, IncomingPort)>

If there is exactly one IncomingPort connected to this OutgoingPort, return it and its node.

fn linked_outputs( &self, node: Node, port: impl Into<IncomingPort>, ) -> OutgoingNodePorts<Self::PortLinks<'_>>

Iterator over the nodes and output ports connected to a given input port. Like linked_ports but preserves knowledge that the linked ports are OutgoingPorts.

fn linked_inputs( &self, node: Node, port: impl Into<OutgoingPort>, ) -> IncomingNodePorts<Self::PortLinks<'_>>

Iterator over the nodes and input ports connected to a given output port Like linked_ports but preserves knowledge that the linked ports are IncomingPorts.

fn is_linked(&self, node: Node, port: impl Into<Port>) -> bool

Returns whether a port is connected.

fn num_inputs(&self, node: Node) -> usize

Number of inputs to a node. Shorthand for num_ports(node, Direction::Incoming).

fn num_outputs(&self, node: Node) -> usize

Number of outputs from a node. Shorthand for num_ports(node, Direction::Outgoing).

fn input_neighbours(&self, node: Node) -> Self::Neighbours<'_>

Iterates over the input neighbours of the node. Shorthand for neighbours(node, Direction::Incoming).

fn output_neighbours(&self, node: Node) -> Self::Neighbours<'_>

Iterates over the output neighbours of the node. Shorthand for neighbours(node, Direction::Outgoing).

fn get_io(&self, node: Node) -> Option<[Node; 2]>

Get the input and output child nodes of a dataflow parent. If the node isn’t a dataflow parent, then return None

fn inner_function_type(&self) -> Option<Signature>

Returns the function type defined by this dataflow HUGR. Read more

fn poly_func_type(&self) -> Option<PolyFuncType>

Returns the function type defined by this HUGR. Read more

fn as_petgraph(&self) -> PetgraphWrapper<'_, Self>
where Self: Sized,

Return a wrapper over the view that can be used in petgraph algorithms.

fn mermaid_string(&self) -> String

Return the mermaid representation of the underlying hierarchical graph. Read more

fn mermaid_string_with_config(&self, config: RenderConfig) -> String

Return the mermaid representation of the underlying hierarchical graph. Read more

fn dot_string(&self) -> String
where Self: Sized,

Return the graphviz representation of the underlying graph and hierarchy side by side. Read more

fn static_source(&self, node: Node) -> Option<Node>

If a node has a static input, return the source node.

fn static_targets( &self, node: Node, ) -> Option<impl Iterator<Item = (Node, IncomingPort)>>

If a node has a static output, return the targets.

fn signature(&self, node: Node) -> Option<Signature>

Get the “signature” (incoming and outgoing types) of a node, non-Value kind ports will be missing.

fn value_types( &self, node: Node, dir: Direction, ) -> impl Iterator<Item = (Port, Type)>

Iterator over all outgoing ports that have Value type, along with corresponding types.

fn in_value_types( &self, node: Node, ) -> impl Iterator<Item = (IncomingPort, Type)>

Iterator over all incoming ports that have Value type, along with corresponding types.

fn out_value_types( &self, node: Node, ) -> impl Iterator<Item = (OutgoingPort, Type)>

Iterator over all incoming ports that have Value type, along with corresponding types.

fn validate(&self, reg: &ExtensionRegistry) -> Result<(), ValidationError>

Check the validity of the underlying HUGR.

fn validate_no_extensions( &self, reg: &ExtensionRegistry, ) -> Result<(), ValidationError>

Check the validity of the underlying HUGR, but don’t check consistency of extension requirements between connected nodes or between parents and children.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self> ⓘ

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self> ⓘ
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more