Struct ModuleBuilder 

pub struct ModuleBuilder<T>(/* private fields */);

Builder for a HUGR module.

Implementations

impl ModuleBuilder<Hugr>

pub fn new() -> ModuleBuilder<Hugr>

Begin building a new module.

impl<T> ModuleBuilder<T>

where T: AsMut<Hugr> + AsRef<Hugr>,

pub fn with_hugr(hugr: T) -> ModuleBuilder<T>

Continue building a module from an existing hugr.

pub fn define_declaration( &mut self, f_id: &FuncID<false>, ) -> Result<DFGWrapper<&mut Hugr, BuildHandle<FuncID<true>>>, BuildError>

Replace a ops::FuncDecl with ops::FuncDefn and return a builder for the defining graph.

Errors

This function will return an error if there is an error in adding the crate::ops::OpType::FuncDefn node.

pub fn define_function_vis( &mut self, name: impl Into<String>, signature: impl Into<PolyFuncTypeBase<NoRV>>, visibility: Visibility, ) -> Result<DFGWrapper<&mut Hugr, BuildHandle<FuncID<true>>>, BuildError>

Add a ops::FuncDefn node of the specified visibility. Returns a builder to define the function body graph.

Errors

This function will return an error if there is an error in adding the ops::FuncDefn node.

pub fn declare( &mut self, name: impl Into<String>, signature: PolyFuncTypeBase<NoRV>, ) -> Result<FuncID<false>, BuildError>

Declare a Visibility::Public function with signature and return a handle to the declaration.

Errors

This function will return an error if there is an error in adding the crate::ops::OpType::FuncDecl node.

pub fn declare_vis( &mut self, name: impl Into<String>, signature: PolyFuncTypeBase<NoRV>, visibility: Visibility, ) -> Result<FuncID<false>, BuildError>

Declare a function with the specified signature and Visibility, and return a handle to the declaration.

Errors

This function will return an error if there is an error in adding the crate::ops::OpType::FuncDecl node.

pub fn define_function( &mut self, name: impl Into<String>, signature: impl Into<PolyFuncTypeBase<NoRV>>, ) -> Result<DFGWrapper<&mut Hugr, BuildHandle<FuncID<true>>>, BuildError>

Adds a ops::FuncDefn node and returns a builder to define the function body graph. The function will be private. (See Self::define_function_vis.)

Errors

This function will return an error if there is an error in adding the ops::FuncDefn node.

pub fn add_alias_def( &mut self, name: impl Into<SmolStr>, typ: TypeBase<NoRV>, ) -> Result<AliasID<true>, BuildError>

Add a crate::ops::OpType::AliasDefn node and return a handle to the Alias.

Errors

Error in adding crate::ops::OpType::AliasDefn child node.

pub fn add_alias_declare( &mut self, name: impl Into<SmolStr>, bound: TypeBound, ) -> Result<AliasID<false>, BuildError>

Add a crate::ops::OpType::AliasDecl node and return a handle to the Alias.

Errors

Error in adding crate::ops::OpType::AliasDecl child node.

pub fn link_hugr_by_node( &mut self, other: Hugr, children: HashMap<Node, NodeLinkingDirective>, ) -> Result<InsertedForest, NodeLinkingError>

Add some module-children of another Hugr to this module, with linking directives specified explicitly by Node.

children contains a map from the children of other to insert, to how they should be combined with the nodes in self. Note if this map is empty, nothing is added.

pub fn link_view_by_node<H>( &mut self, other: &H, children: HashMap<<H as HugrInternals>::Node, NodeLinkingDirective>, ) -> Result<InsertedForest<<H as HugrInternals>::Node>, NodeLinkingError<<H as HugrInternals>::Node>>

where H: HugrView,

Copy module-children from a HugrView into this module, with linking directives specified explicitly by Node.

children contains a map from the children of other to copy, to how they should be combined with the nodes in self. Note if this map is empty, nothing is added.

Trait Implementations

impl<T> Clone for ModuleBuilder<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Container for ModuleBuilder<T>

where T: AsMut<Hugr> + AsRef<Hugr>,

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>( &mut self, child: &H, ) -> InsertionResult<<H as HugrInternals>::Node>

where H: HugrView,

Insert a copy of a HUGR as a child of the container. (Only the portion below the entrypoint will be inserted, with any incoming edges broken; see Dataflow::add_link_view_by_node_with_wires)

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

Add metadata to the container node.

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

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> Debug for ModuleBuilder<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for ModuleBuilder<T>

where T: Default,

fn default() -> ModuleBuilder<T>

Returns the “default value” for a type.

impl HugrBuilder for ModuleBuilder<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 for ModuleBuilder<T>

where T: PartialEq,

fn eq(&self, other: &ModuleBuilder<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> StructuralPartialEq for ModuleBuilder<T>