Struct hugr_core::builder::DFGBuilder

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

Builder for a ops::DFG node.

Implementations

impl DFGBuilder<Hugr>

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

Begin building a new DFG rooted HUGR. Input extensions default to being an open variable

Errors

Error in adding DFG child nodes.

Trait Implementations

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

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

Returns a copy 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_op(&mut self, op: impl Into<OpType>) -> Node

Add an OpType as the final child of the container.

fn add_child_node(&mut self, node: NodeType) -> Node

Add a NodeType 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 define_function( &mut self, name: impl Into<String>, signature: PolyFuncType ) -> Result<FunctionBuilder<&mut Hugr>, BuildError>

Add a ops::FuncDefn node and returns a builder to define the function body graph.

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

Insert a HUGR as a child of the container.

fn add_hugr_view(&mut self, child: &impl HugrView) -> InsertionResult

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.

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, op: impl Into<OpType>, input_wires: impl IntoIterator<Item = Wire> ) -> Result<BuildHandle<DataflowOpID>, BuildError>

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

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

Add a dataflow NodeType 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_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 resulting root node.

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: FunctionType, input_extensions: Option<ExtensionSet>, 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. 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 cfg_builder( &mut self, inputs: impl IntoIterator<Item = (Type, Wire)>, input_extensions: impl Into<Option<ExtensionSet>>, output_types: TypeRow, extension_delta: ExtensionSet ) -> 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], exts: &ExtensionRegistry ) -> 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, extension_delta: ExtensionSet ) -> Result<ConditionalBuilder<&mut Hugr>, BuildError>

Return a builder for a crate::ops::Conditional node. sum_rows and sum_wire define the type of the Sum variants and the wire carrying the Sum respectively.

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>, exts: &ExtensionRegistry ) -> 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.

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, extension_registry: &ExtensionRegistry ) -> Result<Hugr, ValidationError>

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

fn finish_prelude_hugr(self) -> Result<Hugr, ValidationError>

where Self: Sized,

Finish building the HUGR (as HugrBuilder::finish_hugr), validating against the prelude extension only

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

fn eq(&self, other: &DFGBuilder<T>) -> bool

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

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<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>