Struct 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: impl Into<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>, sum_rows: impl IntoIterator<Item = TypeRow>, other_outputs: impl Into<TypeRow>, ) -> Result<Self, BuildError>

Initialize a DataflowBlock rooted HUGR builder. Extension delta will be inferred.

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

Initialize a DataflowBlock rooted HUGR builder. extension_delta is explicitly specified; alternatively, new may be used to infer it.

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.

pub fn finish_with_outputs( self, out_variant: Wire, rest: impl IntoIterator<Item = Wire>, ) -> Result<BuildHandle<TailLoopID>, 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. Extension delta will be inferred.

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

Initialize new builder for a ops::TailLoop rooted HUGR. extension_delta is explicitly specified; alternatively, new may be used to infer it.

impl DFGWrapper<Hugr, BuildHandle<CaseID>>

pub fn new(signature: Signature) -> 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_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 define_function( &mut self, name: impl Into<String>, signature: impl Into<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, 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_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: 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. The Extension delta will be inferred.

fn cfg_builder_exts( &mut self, inputs: impl IntoIterator<Item = (Type, Wire)>, output_types: TypeRow, extension_delta: impl Into<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. extension_delta is explicitly specified. Alternatively cfg_builder may be used to infer it.

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. The extension delta will be inferred.

fn tail_loop_builder_exts( &mut self, just_inputs: impl IntoIterator<Item = (Type, Wire)>, inputs_outputs: impl IntoIterator<Item = (Type, Wire)>, just_out_types: TypeRow, extension_delta: impl Into<ExtensionSet>, ) -> 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. extension_delta explicitly specified. Alternatively tail_loop_builder may be used to infer it.

fn conditional_builder( &mut self, sum_input: (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 conditional_builder_exts( &mut self, (sum_rows, sum_wire): (impl IntoIterator<Item = TypeRow>, Wire), other_inputs: impl IntoIterator<Item = (Type, Wire)>, output_types: TypeRow, extension_delta: impl Into<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

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