Struct Map

pub struct Map(pub Option<&'static Expr>);

A struct representing a mapping configuration for expressions.

This structure contains a single field, an optional reference to a static Expr instance. The Option type encapsulates the possibility of this reference being None, indicating that the mapping may or may not point to a valid expression at any given time. This flexibility allows for dynamic adjustments within the synthesis process, where certain mappings might be deferred or omitted based on the current context or requirements.

Tuple Fields

0: Option<&'static Expr>

Implementations

impl Map

pub fn from_config(config: &Config) -> Self

Creates a Map instance using the provided configuration.

It retrieves an expression associated with the key "f" from the given Config object, which may be None if the key is not found, and wraps this expression in a Map. This function assists in initializing a Map based on pre-defined configurations, facilitating customizable synthesis processes.

pub fn name() -> &'static str

Provides a method to retrieve the name associated with the Map.

It returns a static string slice representing the operation’s name within the context of the Synthphonia module, specifically identifying the list.map functionality. This method is likely used to ensure consistency and readability when referring to the mapping operation internally or in debug outputs.

Trait Implementations

impl Clone for Map

fn clone(&self) -> Map

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Map

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

Formats the value using the given formatter.

impl Default for Map

fn default() -> Self

Creates a default instance of the type by invoking the from_config method with a default configuration. This method serves as a convenient way to generate an instance with standard settings, ensuring that if no specific configuration is provided, the type is still initialized in a consistent manner using default parameters.

impl Display for Map

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

Formats the Map structure for output.

The function checks if the Map contains an Expr and, if so, formats the output to include the expression with a “list.map” prefix decorated by the expression’s debug representation. If no expression is present, the output simply includes “list.map”. This functionality is useful for logging or debugging when visual representation of the mapping operation is required.

impl Enumerator1 for Map

fn enumerate( &self, this: &'static Op1Enum, exec: &'static Executor, opnt: [usize; 1], ) -> Result<(), ()>

Provides a method for the Map structure to perform enumeration with given parameters, but currently returns a placeholder result.

This method, enumerate, takes as parameters a reference to an instance of Op1Enum, a static reference to an Executor, and an array of one usize operand. However, in its current implementation, it performs no actual enumeration or transformation logic and immediately returns a successful Result wrapped in Ok(()) with an empty tuple as the error state. This suggests that further enhancements or a use-case-specific implementation might be forthcoming for this structure within the application’s context.

impl From<Map> for Op1Enum

fn from(v: Map) -> Op1Enum

Converts to this type from the input type.

impl Hash for Map

fn hash<H: Hasher>(&self, state: &mut H)

Provides a method to calculate the hash of the Map structure.

The method takes a mutable reference to a generic hasher H and computes the hash by first accessing the internal Option<&'static Expr> value. If the Option is Some, it maps the contained expression reference to a raw pointer and incorporates it into the hash calculation. This ensures that the hashing process uniquely accounts for the memory address of the expression’s reference, enhancing the precision of hash-based collections or algorithms using Map instances.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Op1 for Map

fn cost(&self) -> usize

Calculates and returns the cost of the operation as a constant value.

In this implementation, the method consistently returns 1, indicating a fixed cost for any instance of the struct, regardless of the contents of the Option<&'static Expr> field. This could be useful for basic cost computation scenarios where each Map instance contributes a uniform cost in the overall synthesis process.

fn try_eval(&self, a1: Value) -> (bool, Value)

Provides a method to evaluate an expression contained within a Map structure using a given Value.

If the input Value is of the type ListStr, it iterates over the list, creating a context for each string element that includes the length of the string and the string itself. The expression is then evaluated within this context, converting the result to a string. The output Value is adjusted to be a collection of these string results, and the method returns a tuple indicating success with a true boolean and the resultant Value. If the input Value is not a ListStr, the method returns false and a Null Value.

impl PartialEq for Map

fn eq(&self, other: &Map) -> 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 TryInto<Map> for Op1Enum

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Map, <Self as TryInto<Map>>::Error>

Performs the conversion.

impl Copy for Map

impl Eq for Map

impl StructuralPartialEq for Map