Enum ExpressionErrorKind 

#[non_exhaustive]
pub enum ExpressionErrorKind {
    UndefinedVariable {
        name: String,
        suggestion: String,
    },
    UnknownFunction {
        name: String,
    },
    TypeError {
        message: String,
    },
    IntegerOverflow,
    DivisionByZero {
        op: &'static str,
    },
    FloatError {
        message: String,
    },
    IndexOutOfBounds {
        message: String,
    },
    MemoryLimitExceeded {
        used: usize,
        limit: usize,
    },
    OperationLimitExceeded {
        count: usize,
        limit: usize,
    },
    ExpressionTooDeep {
        depth: usize,
        limit: usize,
    },
    UnsupportedSyntax {
        feature: String,
    },
    ExplicitFail(String),
    ParseError(String),
    Other(String),
}

Structured error kinds for expression evaluation.

Callers can match on specific variants to handle errors programmatically without parsing error message strings.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UndefinedVariable

A referenced variable was not found in any symbol table.

Fields

name: String

suggestion: String

UnknownFunction

A referenced function was not found in the function library.

Fields

name: String

TypeError

Argument types did not match any overload signature.

Fields

message: String

IntegerOverflow

An integer operation overflowed the 64-bit signed range.

DivisionByZero

Division or modulo by zero.

Fields

op: &'static str

FloatError

A float operation produced infinity or NaN.

Fields

message: String

IndexOutOfBounds

An index was out of bounds for a list, string, or range expression.

Fields

message: String

MemoryLimitExceeded

Expression memory usage exceeded the configured limit.

Fields

used: usize

limit: usize

OperationLimitExceeded

Expression operation count exceeded the configured limit.

Fields

count: usize

limit: usize

ExpressionTooDeep

Expression AST nesting depth exceeded the configured limit.

Raised by the parser’s structural validator and by the evaluator to prevent stack exhaustion on pathological inputs such as ((((...1...)))) or a ~1000-term left-associative binop chain. The limit is MAX_EXPRESSION_DEPTH.

Fields

depth: usize

limit: usize

UnsupportedSyntax

A Python syntax feature that is not supported in the expression language.

Fields

feature: String

ExplicitFail(String)

The fail() function was called explicitly.

ParseError(String)

A parse error from the underlying Python parser.

Other(String)

Any other error that doesn’t fit a structured variant.

Trait Implementations

impl Clone for ExpressionErrorKind

fn clone(&self) -> ExpressionErrorKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExpressionErrorKind

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

Formats the value using the given formatter.

impl Display for ExpressionErrorKind

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

Formats the value using the given formatter.

impl Error for ExpressionErrorKind

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.