Struct miden_objects::assembly::Library

pub struct Library { /* private fields */ }

Represents a library where all modules were compiled into a MastForest.

A library exports a set of one or more procedures. Currently, all exported procedures belong to the same top-level namespace.

Implementations

impl Library

Constructors

pub fn new( mast_forest: MastForest, exports: BTreeMap<QualifiedProcedureName, RpoDigest>, ) -> Library

Constructs a new Library from the provided MAST forest and a set of exports.

impl Library

Accessors

pub fn digest(&self) -> &RpoDigest

Returns the RpoDigest representing the content hash of this library

pub fn exports(&self) -> impl Iterator<Item = &QualifiedProcedureName>

Returns the fully qualified name of all procedures exported by the library.

pub fn mast_forest(&self) -> &MastForest

Returns the inner MastForest.

impl Library

Conversions

pub fn module_infos(&self) -> impl Iterator<Item = ModuleInfo>

Returns an iterator over the module infos of the library.

impl Library

pub const LIBRARY_EXTENSION: &'static str = "masl"

File extension for the Assembly Library.

pub fn write_to_file(&self, path: impl AsRef<Path>) -> Result<(), Error>

Write the library to a target file

NOTE: It is up to the caller to use the correct file extension, but there is no specific requirement that the extension be set, or the same as Self::LIBRARY_EXTENSION.

pub fn from_dir( path: impl AsRef<Path>, namespace: LibraryNamespace, assembler: Assembler, ) -> Result<Library, Report>

Create a Library from a standard Miden Assembly project layout.

The standard layout dictates that a given path is the root of a namespace, and the directory hierarchy corresponds to the namespace hierarchy. A .masm file found in a given subdirectory of the root, will be parsed with its LibraryPath set based on where it resides in the directory structure.

This function recursively parses the entire directory structure under path, ignoring any files which do not have the .masm extension.

For example, let’s say I call this function like so:

Library::from_dir(
    "~/masm/std",
    LibraryNamespace::new("std").unwrap()
    Arc::new(crate::DefaultSourceManager::default()),
);

Here’s how we would handle various files under this path:

• ~/masm/std/sys.masm -> Parsed as “std::sys”
• ~/masm/std/crypto/hash.masm -> Parsed as “std::crypto::hash”
• ~/masm/std/math/u32.masm -> Parsed as “std::math::u32”
• ~/masm/std/math/u64.masm -> Parsed as “std::math::u64”
• ~/masm/std/math/README.md -> Ignored

pub fn deserialize_from_file( path: impl AsRef<Path>, ) -> Result<Library, DeserializationError>

Trait Implementations

impl AsRef<Library> for KernelLibrary

fn as_ref(&self) -> &Library

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<Library> for Library

fn as_ref(&self) -> &Library

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Library

fn clone(&self) -> Library

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Library

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

Formats the value using the given formatter.

impl Deserializable for Library

fn read_from<R>(source: &mut R) -> Result<Library, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

impl From<Library> for MastForest

fn from(value: Library) -> MastForest

Converts to this type from the input type.

impl PartialEq for Library

fn eq(&self, other: &Library) -> 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 Serializable for Library

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl TryFrom<Library> for KernelLibrary

type Error = LibraryError

The type returned in the event of a conversion error.

fn try_from( library: Library, ) -> Result<KernelLibrary, <KernelLibrary as TryFrom<Library>>::Error>

Performs the conversion.

impl Eq for Library

impl StructuralPartialEq for Library