Struct FormatString 

pub struct FormatString { /* private fields */ }

Implementations

impl FormatString

pub fn new(input: &str) -> Result<Self, ExpressionError>

Parse a format string using the “latest” profile (ExprProfile::latest): the current revision with every known extension enabled.

This constructor is intentionally unstable across crate versions. The set of accepted syntax, functions, and types grows as new extensions and revisions land. Use it for ad-hoc parsing or prototyping.

For stability across crate versions, build a profile with an explicit revision and extension set and use with_profile.

pub fn with_profile( input: &str, profile: &ExprProfile, ) -> Result<Self, ExpressionError>

Parse a format string under a caller-supplied profile.

Each {{...}} interpolation is parsed as an expression under the same profile, so the syntax features accepted inside interpolations are determined by the profile in exactly the same way as ParsedExpression::with_profile.

pub fn raw(&self) -> &str

pub fn resolve_with( &self, symtab: &SymbolTable, opts: &FormatStringOptions<'_>, ) -> Result<ExprValue, ExpressionError>

Resolve to an ExprValue.

Configures evaluation via FormatStringOptions. If the format string is a single expression with no surrounding literal text, returns the raw typed ExprValue (which may be int, list, path, etc.); otherwise it concatenates all segments and returns ExprValue::String.

Pass &FormatStringOptions::default() for the simplest call. Build options with .with_library(...), .with_path_format(...), and .with_target_type(...). Path mapping rules, if needed, are baked into the library via FunctionLibrary::for_profile with an ExprProfile whose host context is HostContext::WithRules.

pub fn resolve_string_with( &self, symtab: &SymbolTable, opts: &FormatStringOptions<'_>, ) -> Result<String, ExpressionError>

Resolve to String, concatenating every segment.

Single-expression format strings lose their typed value — use resolve_with when you need the native ExprValue. The target_type field on opts is ignored here.

path_format on the options controls how path() values are constructed:

• PathFormat::Posix in template context (create_job, let bindings)
• PathFormat::host() in session/host context (action execution)

pub fn validate_expressions( &self, symtab: &SymbolTable, lib: &FunctionLibrary, ) -> Result<(), FormatStringValidationError>

Validate all expressions in this format string against a symbol table. The symbol table should contain ExprValue::unresolved(T) for symbols whose values are not yet known. This is the spec’s approach to static type checking — just evaluate normally with unresolved types.

pub fn validate_comprehension_vars( &self, let_names: &HashSet<String>, ) -> Result<(), ExpressionError>

Validate list comprehension loop variables in expressions. Checks: must be lowercase, must not shadow let bindings.

pub fn has_complex_expressions(&self) -> bool

True if any {{...}} segment is more than a bare dotted-name lookup (e.g., contains arithmetic, function calls, or list comprehensions — anything that requires the EXPR extension).

pub fn expression_names(&self) -> Vec<&str>

Names of all bare dotted-name interpolations ({{Param.Name}}-style). Complex expressions (arithmetic, function calls, etc.) are not included — callers that want all referenced symbols should use accessed_symbols.

pub fn is_literal(&self) -> bool

pub fn copy_used_symtab_values( &self, source: &SymbolTable, dest: &mut SymbolTable, )

Copy symbol table entries referenced by this format string’s expressions from source into dest. Only copies the actual symtab values that are referenced, not properties/methods called on them.

For example, if an expression references Param.Name.upper(), the symbol Param.Name is a Value in the symtab (.upper() is a method call). This method walks the dotted path into source, stops when it finds a Value (not a Table), and copies that value into dest at the same path.

pub fn accessed_symbols(&self) -> HashSet<String>

Returns the set of symbol names accessed by this format string.

Trait Implementations

impl Clone for FormatString

fn clone(&self) -> FormatString

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FormatString

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for FormatString

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for FormatString

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

Formats the value using the given formatter.

impl PartialEq for FormatString

fn eq(&self, other: &Self) -> 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 Serialize for FormatString

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl Eq for FormatString