Enum SexpError 

pub enum SexpError {
    Type(SexpTypeError),
    Class(SexpClassError),
    Length(SexpLengthError),
    Na(SexpNaError),
    InvalidValue(String),
    MissingField(String),
    DuplicateName(String),
    MatchArg(MatchArgError),
    Condition(RError),
}

Unified conversion error when decoding an R SEXP.

Variants

Type(SexpTypeError)

SEXPTYPE did not match the expected one.

Class(SexpClassError)

The value is not the kind of R object this conversion reads, where that kind is a class (a data frame is a list with a class), not a SEXPTYPE.

Length(SexpLengthError)

Length did not match the expected one.

Na(SexpNaError)

Missing value encountered where disallowed.

InvalidValue(String)

Value is syntactically valid but semantically invalid (e.g. parse error).

MissingField(String)

A required field was missing from a named list.

DuplicateName(String)

A named list has duplicate non-empty names.

MatchArg(MatchArgError)

A match_arg choice did not match (from #[derive(MatchArg)]’s TryFromSexp), kept whole so the argument error names the choices.

Condition(RError)

A value a check refused with its own message, classes and fields, typically a TryFromSexpElement::check_sexp (#[try_from_sexp(validate = ...)]). Any RConditionData type, an RError or a #[derive(RCondition)] type, converts into it with ?.

As an argument error it keeps the parameter context: the message is '<p>' must be <expected>: <the RError's message>, the classes come before the crate’s conversion_error_class, the fields are spliced in next to e$param and e$rust_type, and the call is the wrapper’s (RError::without_call has no effect here, as for any argument error). Inside an Either it is reported, classes and fields included, whenever the other arm refused the kind of value.

Implementations

impl SexpError

pub(crate) fn r_expectation(&self) -> Option<String>

What the value should have been, in R terms, when the error itself knows and the argument’s Rust type does not tell the macro (#1594): a match_arg choice (one of "fast", "slow"), a class (a data frame), or an Either whose arms both refused the kind of value (one of "fast", "slow", or numeric). The generated wrapper then writes '<p>' must be <this>: <reason> instead of invalid '<p>' argument: <reason>. A type error alone gives none: the SEXPTYPE it expected is the storage the conversion reads, which for an opaque type need not be all it accepts.

pub(crate) fn r_reason(&self, expected_known: bool) -> String

The reason of this conversion error in R terms, the text after '<p>' must be <expected>: in an argument error (#1591). Display is written for the package author (SEXPTYPE names, invalid value: ); this says what was wrong with the value:

error	expected_known	reason
type	yes	got character
type	no	expected integer, got character
class	yes	got list
class	no	expected a data frame, got list
length	yes	got length 2
length	no	expected length 1, got length 2
NA	either	NA is not allowed
invalid value	either	the value’s own text, without invalid value:
missing field / duplicate name	either	missing field 'x' / duplicate name 'x'
match_arg	yes	got "zzz", got numeric, got length 2, NA is not allowed
match_arg	no	expected one of "a", "b", got "zzz"
a check’s refusal (SexpError::Condition)	either	its own message
Either	either	see below

expected_known says whether the text before the reason already states what the value should be ('x' must be a single integer); the reason then does not repeat it. A per-element reason inside a batched message is worded with expected_known = false.

Both branches of an Either failed. A type or class error, or a match_arg refusal of a value that is not a string or factor, means the value was not of that branch’s kind at all; any other error means it was, and failed later (length, NA, value), which is the more useful reason. So: when both branches refused the kind, one reason for the value’s type (got numeric, or expected integer or character, got numeric, expected one of "a", "b", or numeric, got logical); when exactly one did, the other branch’s reason; otherwise both branches’ reasons, once if they agree, else joined with ; .

pub(crate) fn reported_conditions(&self) -> Vec<&RError>

The SexpError::Condition refusals whose reasons r_reason reports, left arm first: the error itself when it is one, and inside an Either the refusals of the arm (or arms) whose reason is reported. Their classes and fields go on the argument error.

Trait Implementations

impl Clone for SexpError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConversionArgMessageBuiltin for SexpError

fn __mx_conversion_arg_message(&self, name: &str) -> Option<String>

impl ConversionErrBuiltin for SexpError

A SexpError also carries the classes and fields of the check refusals (SexpError::Condition) whose reasons its message reports, directly or from an Either arm.

fn __mx_conversion_parts(&self, expected_known: bool) -> ErrParts

impl ConversionExpectBuiltin for SexpError

fn __mx_conversion_expectation(&self) -> Option<String>

impl Debug for SexpError

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

Formats the value using the given formatter.

impl Display for SexpError

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

Formats the value using the given formatter.

impl Error for SexpError

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

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

#[doc(hidden)]

fn type_id(&self, _: Internal) -> TypeId

where Self: 'static,

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

Gets the TypeId of self.

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<E: RConditionData> From<E> for SexpError

Any classed error (an RError, a #[derive(RCondition)] type) converts into a SexpError::Condition with its message, classes, fields and call choice, so a newtype’s check_sexp can refuse with it and a conversion whose error converts into SexpError keeps its classes.

fn from(e: E) -> Self

Converts to this type from the input type.

impl From<MatchArgError> for SexpError

Kept whole, so a TryFromSexp whose error is SexpError (the one #[derive(MatchArg)] emits) still reports the choices.

fn from(e: MatchArgError) -> Self

Converts to this type from the input type.

impl From<SexpClassError> for SexpError

fn from(e: SexpClassError) -> Self

Converts to this type from the input type.

impl From<SexpLengthError> for SexpError

fn from(e: SexpLengthError) -> Self

Converts to this type from the input type.

impl From<SexpNaError> for SexpError

fn from(e: SexpNaError) -> Self

Converts to this type from the input type.

impl From<SexpTypeError> for SexpError

fn from(e: SexpTypeError) -> Self

Converts to this type from the input type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 104 bytes

Size for each variant:

• Type: 16 bytes
• Class: 32 bytes
• Length: 24 bytes
• Na: 12 bytes
• InvalidValue: 32 bytes
• MissingField: 32 bytes
• DuplicateName: 32 bytes
• MatchArg: 64 bytes
• Condition: 104 bytes