Enum ExecutionError 

#[non_exhaustive]
pub enum ExecutionError {
    InvalidArgumentCount {
        expected: usize,
        actual: usize,
    },
    UnsupportedTargetType {
        target: Value,
    },
    NotSupportedAsMethod {
        method: String,
        target: Value,
    },
    UnsupportedKeyType(Value),
    UnexpectedType {
        got: String,
        want: String,
    },
    NoSuchKey(Arc<String>),
    NoSuchOverload,
    UndeclaredReference(Arc<String>),
    MissingArgumentOrTarget,
    ValuesNotComparable(Value, Value),
    UnsupportedUnaryOperator(&'static str, Value),
    UnsupportedBinaryOperator(&'static str, Value, Value),
    UnsupportedMapIndex(Value),
    UnsupportedListIndex(Value),
    UnsupportedIndex(Value, Value),
    UnsupportedFunctionCallIdentifierType(Expression),
    UnsupportedFieldsConstruction(SelectExpr),
    FunctionError {
        function: String,
        message: String,
    },
    DivisionByZero(Value),
    RemainderByZero(Value),
    Overflow(&'static str, Value, Value),
}

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.

InvalidArgumentCount

Fields

expected: usize

actual: usize

UnsupportedTargetType

Fields

target: Value

NotSupportedAsMethod

Fields

method: String

target: Value

UnsupportedKeyType(Value)

Indicates that the script attempted to use a value as a key in a map, but the type of the value was not supported as a key.

UnexpectedType

Fields

got: String

want: String

NoSuchKey(Arc<String>)

Indicates that the script attempted to reference a key on a type that was missing the requested key.

NoSuchOverload

Indicates that the script used an existing operator or function with values of one or more types for which no overload was declared.

UndeclaredReference(Arc<String>)

Indicates that the script attempted to reference an undeclared variable method, or function.

MissingArgumentOrTarget

Indicates that a function expected to be called as a method, or to be called with at least one parameter.

ValuesNotComparable(Value, Value)

Indicates that a comparison could not be performed.

UnsupportedUnaryOperator(&'static str, Value)

Indicates that an operator was used on a type that does not support it.

UnsupportedBinaryOperator(&'static str, Value, Value)

Indicates that an unsupported binary operator was applied on two values where it’s unsupported, for example list + map.

UnsupportedMapIndex(Value)

Indicates that an unsupported type was used to index a map

UnsupportedListIndex(Value)

Indicates that an unsupported type was used to index a list

UnsupportedIndex(Value, Value)

Indicates that an unsupported type was used to index a list

UnsupportedFunctionCallIdentifierType(Expression)

Indicates that a function call occurred without an [Expression::Ident] as the function identifier.

UnsupportedFieldsConstruction(SelectExpr)

Indicates that a [Member::Fields] construction was attempted which is not yet supported.

FunctionError

Indicates that a function had an error during execution.

Fields

function: String

message: String

DivisionByZero(Value)

RemainderByZero(Value)

Overflow(&'static str, Value, Value)

Implementations

impl ExecutionError

pub fn no_such_key(name: &str) -> Self

pub fn undeclared_reference(name: &str) -> Self

pub fn invalid_argument_count(expected: usize, actual: usize) -> Self

pub fn function_error<E: ToString>(function: &str, error: E) -> Self

pub fn unsupported_target_type(target: Value) -> Self

pub fn not_supported_as_method(method: &str, target: Value) -> Self

pub fn unsupported_key_type(value: Value) -> Self

pub fn missing_argument_or_target() -> Self

Trait Implementations

impl Clone for ExecutionError

fn clone(&self) -> ExecutionError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExecutionError

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

Formats the value using the given formatter.

impl Display for ExecutionError

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

Formats the value using the given formatter.

impl Error for ExecutionError

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.

impl From<ExecutionError> for ResolveResult

fn from(value: ExecutionError) -> Self

Converts to this type from the input type.

impl PartialEq for ExecutionError

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