Struct DFGBuilder 

pub struct DFGBuilder<T> { /* private fields */ }

Builder for a ops::DFG node.

Implementations

impl<T: AsMut<Hugr> + AsRef<Hugr>> DFGBuilder<T>

pub fn create_with_io( base: T, parent: Node, signature: Signature, ) -> Result<Self, BuildError>

Returns a new DFGBuilder with the given base and parent node.

Sets up the input and output nodes of the region. If parent already has input and output nodes, use DFGBuilder::create instead.

pub fn create(base: T, parent: Node) -> Result<Self, BuildError>

Returns a new DFGBuilder with the given base and parent node.

The parent node may be any DataflowParent node.

If parent doesn’t have input and output nodes, use DFGBuilder::create_with_io instead.

pub fn add_input(&mut self, input_type: Type) -> Result<Wire, DFGAddPortError>

Add a new input to the dataflow being constructed.

Updates the parent’s optype to include the new input type.

Returns

• The new wire from the input node.

Errors

• DFGAddPortError::ParentOpNotSupported if the container optype is not a FuncDefn, DFG, or dataflow block so we cannot add an input. In this case, the Hugr will not be updated.

pub fn add_output(&mut self, output_type: Type) -> Result<(), DFGAddPortError>

Add a new output to the function being constructed.

Updates the parent’s optype to include the new input type, if possible. If the container optype is not a FuncDefn, DFG, or dataflow block, the optype will not be updated.

Errors

• DFGAddPortError::ParentOpNotSupported if the container optype is not a FuncDefn, DFG, or dataflow block so we cannot add an input. In this case, the Hugr will not be updated.

impl DFGBuilder<Hugr>

pub fn new(signature: Signature) -> Result<DFGBuilder<Hugr>, BuildError>

Begin building a new DFG-rooted HUGR given its inputs, outputs, and extension delta.

Errors

Error in adding DFG child nodes.

Trait Implementations

impl<T: Clone> Clone for DFGBuilder<T>

fn clone(&self) -> DFGBuilder<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: AsMut<Hugr> + AsRef<Hugr>> Container for DFGBuilder<T>

fn container_node(&self) -> Node

The container node.

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

The underlying Hugr being built

fn hugr(&self) -> &Hugr

Immutable reference to HUGR being built

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

Add an OpType as the final child of the container.

fn add_other_wire(&mut self, src: Node, dst: Node) -> Wire

Adds a non-dataflow edge between two nodes. The kind is given by the operation’s other_inputs or other_outputs

fn add_constant(&mut self, constant: impl Into<Const>) -> ConstID

Add a constant value to the container and return a handle to it.

fn add_hugr(&mut self, child: Hugr) -> InsertionResult

Insert a HUGR’s entrypoint region as a child of the container.

fn add_hugr_region(&mut self, child: Hugr, region: Node) -> InsertionResult

Insert a HUGR region as a child of the container.

fn add_hugr_view<H: HugrView>( &mut self, child: &H, ) -> InsertionResult<H::Node, Node>

Insert a copy of a HUGR as a child of the container.

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

Add metadata to the container node.

fn set_child_metadata( &mut self, child: Node, key: impl AsRef<str>, meta: impl Into<NodeMetadata>, )

Add metadata to a child node.

fn use_extension(&mut self, ext: impl Into<Arc<Extension>>)

Add an extension to the set of extensions used by the hugr.

fn use_extensions<Reg>(&mut self, registry: impl IntoIterator<Item = Reg>)

where ExtensionRegistry: Extend<Reg>,

Extend the set of extensions used by the hugr with the extensions in the registry.

impl<T: AsMut<Hugr> + AsRef<Hugr>> Dataflow for DFGBuilder<T>

fn num_inputs(&self) -> usize

Return the number of inputs to the dataflow sibling graph.

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

Return indices of input and output nodes.

fn input(&self) -> BuildHandle<DataflowOpID>

Handle to input node.

fn output(&self) -> DataflowOpID

Handle to output node.

fn input_wires(&self) -> Outputs

Return iterator over all input Value wires.

fn add_dataflow_op( &mut self, nodetype: impl Into<OpType>, input_wires: impl IntoIterator<Item = Wire>, ) -> Result<BuildHandle<DataflowOpID>, BuildError>

Add a dataflow OpType to the sibling graph, wiring up the input_wires to the incoming ports of the resulting node.

fn add_hugr_with_wires( &mut self, hugr: Hugr, input_wires: impl IntoIterator<Item = Wire>, ) -> Result<BuildHandle<DataflowOpID>, BuildError>

Insert a hugr-defined op to the sibling graph, wiring up the input_wires to the incoming ports of the resulting root node.

fn add_hugr_region_with_wires( &mut self, hugr: Hugr, region: Node, input_wires: impl IntoIterator<Item = Wire>, ) -> Result<BuildHandle<DataflowOpID>, BuildError>

Insert a hugr-defined op to the sibling graph, wiring up the input_wires to the incoming ports of the resulting root node.

fn add_hugr_view_with_wires( &mut self, hugr: &impl HugrView, input_wires: impl IntoIterator<Item = Wire>, ) -> Result<BuildHandle<DataflowOpID>, BuildError>

Copy a hugr-defined op into the sibling graph, wiring up the input_wires to the incoming ports of the node that was the entrypoint. (Note, any part of hugr outside the entrypoint is not copied; this may lead to new input ports being disconnected.)

fn set_outputs( &mut self, output_wires: impl IntoIterator<Item = Wire>, ) -> Result<(), BuildError>

Wire up the output_wires to the input ports of the Output node.

fn input_wires_arr<const N: usize>(&self) -> [Wire; N]

Return an array of the input wires.

fn dfg_builder( &mut self, signature: Signature, input_wires: impl IntoIterator<Item = Wire>, ) -> Result<DFGBuilder<&mut Hugr>, BuildError>

Return a builder for a crate::ops::DFG node, i.e. a nested dataflow subgraph, given a signature describing its input and output types and extension delta, and the input wires (which must match the input types)

fn dfg_builder_endo( &mut self, inputs: impl IntoIterator<Item = (Type, Wire)>, ) -> Result<DFGBuilder<&mut Hugr>, BuildError>

Return a builder for a crate::ops::DFG node, i.e. a nested dataflow subgraph, that is endomorphic (the output types are the same as the input types). The inputs must be an iterable over pairs of the type of the input and the corresponding wire.

fn cfg_builder( &mut self, inputs: impl IntoIterator<Item = (Type, Wire)>, output_types: TypeRow, ) -> Result<CFGBuilder<&mut Hugr>, BuildError>

Return a builder for a crate::ops::CFG node, i.e. a nested controlflow subgraph. The inputs must be an iterable over pairs of the type of the input and the corresponding wire. The output_types are the types of the outputs.

fn load_const(&mut self, cid: &ConstID) -> Wire

Load a static constant and return the local dataflow wire for that constant. Adds a OpType::LoadConstant node.

fn add_load_const(&mut self, constant: impl Into<Const>) -> Wire

Load a static constant and return the local dataflow wire for that constant. Adds a ops::Const and a ops::LoadConstant node.

fn add_load_value(&mut self, constant: impl Into<Value>) -> Wire

Load a ops::Value and return the local dataflow wire for that constant. Adds a ops::Const and a ops::LoadConstant node.

fn load_func<const DEFINED: bool>( &mut self, fid: &FuncID<DEFINED>, type_args: &[TypeArg], ) -> Result<Wire, BuildError>

Load a static function and return the local dataflow wire for that function. Adds a OpType::LoadFunction node.

fn tail_loop_builder( &mut self, just_inputs: impl IntoIterator<Item = (Type, Wire)>, inputs_outputs: impl IntoIterator<Item = (Type, Wire)>, just_out_types: TypeRow, ) -> Result<TailLoopBuilder<&mut Hugr>, BuildError>

Return a builder for a crate::ops::TailLoop node. The inputs must be an iterable over pairs of the type of the input and the corresponding wire. The output_types are the types of the outputs.

fn conditional_builder( &mut self, (sum_rows, sum_wire): (impl IntoIterator<Item = TypeRow>, Wire), other_inputs: impl IntoIterator<Item = (Type, Wire)>, output_types: TypeRow, ) -> Result<ConditionalBuilder<&mut Hugr>, BuildError>

Return a builder for a crate::ops::Conditional node. sum_input is a tuple of the type of the Sum variants and the corresponding wire.

fn set_order(&mut self, before: &impl NodeHandle, after: &impl NodeHandle)

Add an order edge from before to after. Assumes any additional edges to both nodes will be Order kind.

fn get_wire_type(&self, wire: Wire) -> Result<Type, BuildError>

Get the type of a Value Wire. If not valid port or of Value kind, returns None.

fn make_tuple( &mut self, values: impl IntoIterator<Item = Wire>, ) -> Result<Wire, BuildError>

Add a MakeTuple node and wire in the values Wires, returning the Wire corresponding to the tuple.

fn make_sum( &mut self, tag: usize, variants: impl IntoIterator<Item = TypeRow>, values: impl IntoIterator<Item = Wire>, ) -> Result<Wire, BuildError>

Add a Tag node and wire in the value Wire, to make a value with Sum type, with tag and possible types described by variants. Returns the Wire corresponding to the Sum value.

fn make_continue( &mut self, tail_loop: TailLoop, values: impl IntoIterator<Item = Wire>, ) -> Result<Wire, BuildError>

Use the wires in values to return a wire corresponding to the “Continue” variant of a ops::TailLoop with loop_signature.

fn make_break( &mut self, loop_op: TailLoop, values: impl IntoIterator<Item = Wire>, ) -> Result<Wire, BuildError>

Use the wires in values to return a wire corresponding to the “Break” variant of a ops::TailLoop with loop_signature.

fn call<const DEFINED: bool>( &mut self, function: &FuncID<DEFINED>, type_args: &[TypeArg], input_wires: impl IntoIterator<Item = Wire>, ) -> Result<BuildHandle<DataflowOpID>, BuildError>

Add a ops::Call node, calling function, with inputs specified by input_wires. Returns a handle to the corresponding Call node.

fn as_circuit( &mut self, wires: impl IntoIterator<Item = Wire>, ) -> CircuitBuilder<'_, Self>

For the vector of wires, produce a CircuitBuilder where ops can be added using indices in to the vector.

fn add_barrier( &mut self, wires: impl IntoIterator<Item = Wire>, ) -> Result<BuildHandle<DataflowOpID>, BuildError>

Add a Barrier to a set of wires and return them in the same order.

impl<T: Debug> Debug for DFGBuilder<T>

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

Formats the value using the given formatter.

impl HugrBuilder for DFGBuilder<Hugr>

fn finish_hugr(self) -> Result<Hugr, ValidationError<Node>>

Finish building the HUGR, perform any validation checks and return it.

fn module_root_builder(&mut self) -> ModuleBuilder<&mut Hugr>

Allows adding definitions to the module root of which this builder is building a part

impl<T: PartialEq> PartialEq for DFGBuilder<T>

fn eq(&self, other: &DFGBuilder<T>) -> 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<T: AsMut<Hugr> + AsRef<Hugr>> SubContainer for DFGBuilder<T>

type ContainerHandle = BuildHandle<DfgID>

A handle to the finished container node, typically returned when the child graph has been finished.

fn finish_sub_container(self) -> Result<Self::ContainerHandle, BuildError>

Consume the container builder and return the handle, may perform some checks before finishing.

impl<T> StructuralPartialEq for DFGBuilder<T>