Enum dust_lib::Error

#[non_exhaustive]
pub enum Error {
    TypeCheckFailure {
        tool_info: ToolInfo<'static>,
        argument: Value,
    },
    AssertEqualFailed {
        expected: Value,
        actual: Value,
    },
    AssertFailed,
    WrongColumnAmount {
        expected: usize,
        actual: usize,
    },
    ExpectedOperatorArgumentAmount {
        expected: usize,
        actual: usize,
    },
    ExpectedFunctionArgumentAmount {
        identifier: String,
        expected: usize,
        actual: usize,
    },
    ExpectedAtLeastFunctionArgumentAmount {
        identifier: String,
        minimum: usize,
        actual: usize,
    },
    ExpectedString {
        actual: Value,
    },
    ExpectedInt {
        actual: Value,
    },
    ExpectedFloat {
        actual: Value,
    },
    ExpectedNumber {
        actual: Value,
    },
    ExpectedNumberOrString {
        actual: Value,
    },
    ExpectedBoolean {
        actual: Value,
    },
    ExpectedList {
        actual: Value,
    },
    ExpectedFixedLenList {
        expected_len: usize,
        actual: Value,
    },
    ExpectedEmpty {
        actual: Value,
    },
    ExpectedMap {
        actual: Value,
    },
    ExpectedTable {
        actual: Value,
    },
    ExpectedFunction {
        actual: Value,
    },
    ExpectedCollection {
        actual: Value,
    },
    AppendedToLeafNode(Node),
    PrecedenceViolation,
    VariableIdentifierNotFound(String),
    FunctionIdentifierNotFound(String),
    TypeError {
        expected: &'static [ValueType],
        actual: Value,
    },
    MacroArgumentType {
        macro_info: ToolInfo<'static>,
        actual: Value,
    },
    WrongTypeCombination {
        operator: Operator,
        actual: Vec<ValueType>,
    },
    UnmatchedLBrace,
    UnmatchedRBrace,
    MissingOperatorOutsideOfBrace,
    UnmatchedPartialToken {
        first: PartialToken,
        second: Option<PartialToken>,
    },
    AdditionError {
        augend: Value,
        addend: Value,
    },
    SubtractionError {
        minuend: Value,
        subtrahend: Value,
    },
    NegationError {
        argument: Value,
    },
    MultiplicationError {
        multiplicand: Value,
        multiplier: Value,
    },
    DivisionError {
        dividend: Value,
        divisor: Value,
    },
    ModulationError {
        dividend: Value,
        divisor: Value,
    },
    InvalidRegex {
        regex: String,
        message: String,
    },
    ContextNotMutable,
    IllegalEscapeSequence(String),
    BuiltinFunctionsCannotBeEnabled,
    BuiltinFunctionsCannotBeDisabled,
    MacroFailure(String),
    CustomMessage(String),
}

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.

TypeCheckFailure

Fields

tool_info: ToolInfo<'static>

argument: Value

Dust’s internal type checking failed to identify a type mismatch. This should never happen, /// the error prompts the user to report the bug.

AssertEqualFailed

Fields

expected: Value

actual: Value

The ‘assert’ macro did not resolve successfully.

AssertFailed

The ‘assert’ macro did not resolve successfully.

WrongColumnAmount

Fields

expected: usize

actual: usize

A row was inserted to a table with the wrong amount of values.

ExpectedOperatorArgumentAmount

Fields

expected: usize

actual: usize

An operator was called with the wrong amount of arguments.

ExpectedFunctionArgumentAmount

Fields

identifier: String

expected: usize

actual: usize

A function was called with the wrong amount of arguments.

ExpectedAtLeastFunctionArgumentAmount

Fields

identifier: String

minimum: usize

actual: usize

A function was called with the wrong amount of arguments.

ExpectedString

Fields

actual: Value

ExpectedInt

Fields

actual: Value

ExpectedFloat

Fields

actual: Value

ExpectedNumber

Fields

actual: Value

An integer, floating point or value was expected.

ExpectedNumberOrString

Fields

actual: Value

An integer, floating point or string value was expected.

ExpectedBoolean

Fields

actual: Value

ExpectedList

Fields

actual: Value

ExpectedFixedLenList

Fields

expected_len: usize

actual: Value

ExpectedEmpty

Fields

actual: Value

ExpectedMap

Fields

actual: Value

ExpectedTable

Fields

actual: Value

ExpectedFunction

Fields

actual: Value

ExpectedCollection

Fields

actual: Value

A string, list, map or table value was expected.

AppendedToLeafNode(Node)

Tried to append a child to a leaf node. Leaf nodes cannot have children.

PrecedenceViolation

Tried to append a child to a node such that the precedence of the child is not higher. This error should never occur. If it does, please file a bug report.

VariableIdentifierNotFound(String)

A VariableIdentifier operation did not find its value in the context.

FunctionIdentifierNotFound(String)

A FunctionIdentifier operation did not find its value in the context.

TypeError

Fields

expected: &'static [ValueType]

The expected types.

actual: Value

The actual value.

A value has the wrong type. Only use this if there is no other error that describes the expected and provided types in more detail.

MacroArgumentType

Fields

macro_info: ToolInfo<'static>

The macro that was called.

actual: Value

The actual value.

A macro or function was called with the wrong type of input.

WrongTypeCombination

Fields

operator: Operator

The operator that whose evaluation caused the error.

actual: Vec<ValueType>

The types that were used in the operator causing it to fail.

An operator is used with a wrong combination of types.

UnmatchedLBrace

An opening brace without a matching closing brace was found.

UnmatchedRBrace

A closing brace without a matching opening brace was found.

MissingOperatorOutsideOfBrace

Left of an opening brace or right of a closing brace is a token that does not expect the brace next to it. For example, writing 4(5) would yield this error, as the 4 does not have any operands.

UnmatchedPartialToken

Fields

first: PartialToken

The unmatched partial token.

second: Option<PartialToken>

The token that follows the unmatched partial token and that cannot be matched to the partial token, or None, if first is the last partial token in the stream.

A PartialToken is unmatched, such that it cannot be combined into a full Token. This happens if for example a single = is found, surrounded by whitespace. It is not a token, but it is part of the string representation of some tokens.

AdditionError

Fields

augend: Value

The first argument of the addition.

addend: Value

The second argument of the addition.

An addition operation performed by Rust failed.

SubtractionError

Fields

minuend: Value

The first argument of the subtraction.

subtrahend: Value

The second argument of the subtraction.

A subtraction operation performed by Rust failed.

NegationError

Fields

argument: Value

The argument of the negation.

A negation operation performed by Rust failed.

MultiplicationError

Fields

multiplicand: Value

The first argument of the multiplication.

multiplier: Value

The second argument of the multiplication.

A multiplication operation performed by Rust failed.

DivisionError

Fields

dividend: Value

The first argument of the division.

divisor: Value

The second argument of the division.

A division operation performed by Rust failed.

ModulationError

Fields

dividend: Value

The first argument of the modulation.

divisor: Value

The second argument of the modulation.

A modulation operation performed by Rust failed.

InvalidRegex

Fields

regex: String

The invalid regular expression

message: String

Failure message from the regex engine

A regular expression could not be parsed

ContextNotMutable

A modification was attempted on a Context that does not allow modifications.

IllegalEscapeSequence(String)

An escape sequence within a string literal is illegal.

BuiltinFunctionsCannotBeEnabled

This context does not allow enabling builtin functions.

BuiltinFunctionsCannotBeDisabled

This context does not allow disabling builtin functions.

MacroFailure(String)

The function failed due to an external error.

CustomMessage(String)

A custom error explained by its message.

Implementations

impl Error

pub fn type_error(actual: Value, expected: &'static [ValueType]) -> Self

pub fn wrong_type_combination( operator: Operator, actual: Vec<ValueType> ) -> Self

pub fn expected_string(actual: Value) -> Self

pub fn expected_int(actual: Value) -> Self

pub fn expected_float(actual: Value) -> Self

pub fn expected_number(actual: Value) -> Self

pub fn expected_number_or_string(actual: Value) -> Self

pub fn expected_boolean(actual: Value) -> Self

pub fn expected_list(actual: Value) -> Self

pub fn expected_fixed_len_list(expected_len: usize, actual: Value) -> Self

pub fn expected_empty(actual: Value) -> Self

pub fn expected_map(actual: Value) -> Self

pub fn expected_table(actual: Value) -> Self

pub fn expected_function(actual: Value) -> Self

pub fn expected_collection(actual: Value) -> Self

pub fn invalid_regex(regex: String, message: String) -> Self

Constructs EvalexprError::InvalidRegex(regex)

Trait Implementations

impl Clone for Error

fn clone(&self) -> Error

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

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

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<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(value: Error) -> Self

Converts to this type from the input type.

impl From<SystemTimeError> for Error

fn from(value: SystemTimeError) -> Self

Converts to this type from the input type.

impl PartialEq<Error> for Error

fn eq(&self, other: &Error) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Error