Struct hugr_core::builder::DFGWrapper

pub struct DFGWrapper<B, T>(/* private fields */);

Wrapper around DFGBuilder used to build other dataflow regions.

Implementations

impl DFGWrapper<Hugr, BuildHandle<FuncID<true>>>

pub fn new( name: impl Into<String>, signature: PolyFuncType ) -> Result<Self, BuildError>

Initialize a builder for a FuncDefn rooted HUGR

Errors

Error in adding DFG child nodes.

impl<B: AsMut<Hugr> + AsRef<Hugr>> DFGWrapper<B, BasicBlockID>

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

Set the outputs of the block, with branch_wire carrying the value of the branch controlling Sum value. outputs are the remaining outputs.

pub fn finish_with_outputs( self, branch_wire: Wire, outputs: impl IntoIterator<Item = Wire> ) -> Result<<Self as SubContainer>::ContainerHandle, BuildError>

where Self: Sized,

Set outputs and finish.

impl DFGWrapper<Hugr, BasicBlockID>

pub fn new( inputs: impl Into<TypeRow>, input_extensions: impl Into<Option<ExtensionSet>>, sum_rows: impl IntoIterator<Item = TypeRow>, other_outputs: impl Into<TypeRow>, extension_delta: ExtensionSet ) -> Result<Self, BuildError>

Initialize a DataflowBlock rooted HUGR builder

pub fn finish_hugr_with_outputs( self, branch_wire: Wire, outputs: impl IntoIterator<Item = Wire>, extension_registry: &ExtensionRegistry ) -> Result<Hugr, BuildError>

Set outputs and finish_hugr.

impl<B: AsMut<Hugr> + AsRef<Hugr>> DFGWrapper<B, BuildHandle<TailLoopID>>

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

Set the outputs of the ops::TailLoop, with out_variant as the value of the termination Sum, and rest being the remaining outputs

pub fn loop_signature(&self) -> Result<&TailLoop, BuildError>

Get a reference to the ops::TailLoop that defines the signature of the ops::TailLoop

pub fn internal_output_row(&self) -> Result<TypeRow, BuildError>

The output types of the child graph, including the Sum as the first.

impl<H: AsMut<Hugr> + AsRef<Hugr>> DFGWrapper<H, BuildHandle<TailLoopID>>

pub fn finish_with_outputs( self, out_variant: Wire, rest: impl IntoIterator<Item = Wire> ) -> Result<<Self as SubContainer>::ContainerHandle, BuildError>

where Self: Sized,

Set outputs and finish, see TailLoopBuilder::set_outputs

impl DFGWrapper<Hugr, BuildHandle<TailLoopID>>

pub fn new( just_inputs: impl Into<TypeRow>, inputs_outputs: impl Into<TypeRow>, just_outputs: impl Into<TypeRow> ) -> Result<Self, BuildError>

Initialize new builder for a ops::TailLoop rooted HUGR

impl DFGWrapper<Hugr, BuildHandle<CaseID>>

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

Initialize a Case rooted HUGR

Trait Implementations

impl<B: Clone, T: Clone> Clone for DFGWrapper<B, T>

fn clone(&self) -> DFGWrapper<B, T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<B: AsMut<Hugr> + AsRef<Hugr>, T> Container for DFGWrapper<B, 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<B: AsMut<Hugr> + AsRef<Hugr>, T> Dataflow for DFGWrapper<B, 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<B: Debug, T: Debug> Debug for DFGWrapper<B, T>

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

Formats the value using the given formatter.

impl<T> HugrBuilder for DFGWrapper<Hugr, T>

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<B: PartialEq, T: PartialEq> PartialEq for DFGWrapper<B, T>

fn eq(&self, other: &DFGWrapper<B, 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<B: AsMut<Hugr> + AsRef<Hugr>, T: From<BuildHandle<DfgID>>> SubContainer for DFGWrapper<B, T>

type ContainerHandle = T

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<B, T> StructuralPartialEq for DFGWrapper<B, T>