Enum MatchArgError 

pub enum MatchArgError {
    InvalidType {
        actual: SEXPTYPE,
        choices: &'static [&'static str],
        aliases: &'static [MatchArgAlias],
    },
    InvalidLength {
        actual: usize,
        choices: &'static [&'static str],
        aliases: &'static [MatchArgAlias],
    },
    IsNa {
        choices: &'static [&'static str],
        aliases: &'static [MatchArgAlias],
    },
    NoMatch {
        input: String,
        choices: &'static [&'static str],
        aliases: &'static [MatchArgAlias],
    },
}

Error type for MatchArg conversion failures.

Every variant carries the type’s choices and aliases, so an error can say what the value must be ('mode' should be one of "fast", "slow" (or "quick" for "fast")) whichever way it was wrong.

Variants

InvalidType

The SEXP was not a character or factor type.

Fields

actual: SEXPTYPE

The SEXPTYPE that was given.

choices: &'static [&'static str]

The valid choices.

aliases: &'static [MatchArgAlias]

The type’s aliases (MatchArg::ALIASES).

InvalidLength

The input had length != 1.

Fields

actual: usize

The length that was given.

choices: &'static [&'static str]

The valid choices.

aliases: &'static [MatchArgAlias]

The type’s aliases (MatchArg::ALIASES).

IsNa

The input was NA.

Fields

choices: &'static [&'static str]

The valid choices.

aliases: &'static [MatchArgAlias]

The type’s aliases (MatchArg::ALIASES).

NoMatch

No choice matched the input.

Fields

input: String

The input string that didn’t match.

choices: &'static [&'static str]

The valid choices.

aliases: &'static [MatchArgAlias]

The type’s aliases (MatchArg::ALIASES).

Implementations

impl MatchArgError

fn invalid_type<T: MatchArg>(actual: SEXPTYPE) -> Self

InvalidType for the choices of T.

fn invalid_length<T: MatchArg>(actual: usize) -> Self

InvalidLength for the choices of T.

fn is_na<T: MatchArg>() -> Self

IsNa for the choices of T.

fn no_match<T: MatchArg>(input: &str) -> Self

NoMatch of input for the choices of T.

pub fn choices(&self) -> &'static [&'static str]

The choices the value should have been one of.

pub fn aliases(&self) -> &'static [MatchArgAlias]

The aliases of the choices, listed and unlisted.

pub fn expectation(&self) -> String

What the value must be, in R terms: one of "fast", "slow", with the listed aliases after the choices (one of "fast", "slow" (or "quick" for "fast")). An Either whose arms both refused a value names a match_arg arm with it ('x' must be one of "oral", "bolus", or a single double: got logical, #1594).

pub fn arg_error(&self, param: &str) -> ArgError

The argument error the generated wrapper’s match_arg check (.miniextendr_match_arg) raises for this value of parameter param (its R name), word for word (#1741):

• InvalidType: 'mode' must be NULL or a character vector
• InvalidLength: 'mode' must be of length 1
• IsNa, NoMatch: 'mode' should be one of "fast", "safe", then the listed aliases ('mode' should be one of "fast", "safe" (or "quick" for "fast"), #2148)

The choices and the aliases are quoted as R’s dQuote(choices, FALSE) quotes them, without escapes. match_arg_param returns it; ArgError::raise raises it as that condition. The generated conversion of a match_arg type, with or without #[miniextendr(match_arg)], raises its message too (#1767).

pub(crate) fn arg_message(&self, param: &str, formal: &[&str]) -> String

The message of arg_error, with the choices listed in the order of formal, the choices of the parameter’s R formal: T::CHOICES, or those of a default = "..." parameter, which lists its default first (match_arg_param_with_default). The listed aliases follow in the order of T::CHOICES whatever the formal, as the wrappers writer renders them for the R check.

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

The reason of this error in R terms, after <expected>: when an Either names this arm in an argument error (#1591): got "zzz", got numeric, got length 2, NA is not allowed. With expected_known = false (nothing before the reason names the choices) it is the Display text, which says what was expected.

Trait Implementations

impl Clone for MatchArgError

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 MatchArgError

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

impl ConversionErrBuiltin for MatchArgError

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

impl ConversionExpectBuiltin for MatchArgError

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

impl Debug for MatchArgError

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

Formats the value using the given formatter.

impl Display for MatchArgError

The text is complete on its own, for a conversion outside an argument: expected one of "fast", "slow", got "zzz", expected a string or factor, got numeric.

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

Formats the value using the given formatter.

impl Error for MatchArgError

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 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.

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: 56 bytes

Size for each variant:

• InvalidType: 48 bytes
• InvalidLength: 48 bytes
• IsNa: 40 bytes
• NoMatch: 56 bytes