Struct RError 

pub struct RError {
    message: String,
    class: Vec<String>,
    data: ConditionData,
    call: ConditionCall,
    argument_message: Option<String>,
}

A ready-made classed error value for Result<T, RError> returns.

Carries a message, an optional class vector, structured fields and the call choice, and implements RConditionData. Any std::error::Error converts into it with ? / From (the message keeps the caused by: chain, like AsRError), after which the builder methods add the R-facing parts (RError::class, RError::data, RError::without_call):

use miniextendr_api::condition::RError;

#[miniextendr]
pub fn parse_port(s: &str) -> Result<i32, RError> {
    let port: i32 = s
        .parse()
        .map_err(|e| RError::from(e).class(["pkg_bad_port", "pkg_error"]).data("input", s))?;
    Ok(port)
}

e <- tryCatch(parse_port("x"), pkg_bad_port = function(e) e)
e$input          # "x"
class(e)[1:2]    # "pkg_bad_port" "pkg_error"

RError deliberately does not implement std::error::Error: that keeps the blanket From<E: Error> coherent. It does implement Display (the message), so it also works with #[miniextendr(unwrap_in_r)].

Fields

message: String

class: Vec<String>

data: ConditionData

call: ConditionCall

argument_message: Option<String>

Implementations

impl RError

pub fn new(message: impl Into<String>) -> Self

A classless error with message.

pub fn without_call(self) -> Self

Raise the condition without a call: conditionCall(e) is NULL and the printed condition has no In f(...) : prefix, like R’s stop(..., call. = FALSE). For an error or warning about the data, not the call. Applies to Result returns and the defer_* functions; see ConditionCall.

pub fn class(self, class: impl ConditionClass) -> Self

Append user classes (most specific first). Accepts one string or a vector, see ConditionClass.

pub fn data(self, name: impl Into<String>, value: impl Into<RValue>) -> Self

Attach a structured field readable as e$<name>. Any value with an RValue From impl works. The name must not be message, call or kind; see RESERVED_CONDITION_FIELDS.

pub fn argument_message(self, message: impl Into<String>) -> Self

The whole message of the argument error when this error refuses an argument, used as given instead of '<p>' must be <expected>: <message>; see RConditionData::argument_message. message stays the message everywhere else.

fn model_object(x: SEXP) -> Result<(), RError> {
    if x.inherits_class(c"data.frame") {
        return Err(RError::new("got a data frame")
            .argument_message("use model_from_df() for a data frame"));
    }
    Ok(())
}

pub fn message_str(&self) -> &str

The message.

pub fn argument_message_str(&self) -> Option<&str>

The whole argument-error message, if one was given (RError::argument_message).

pub fn classes(&self) -> &[String]

The user classes, most specific first.

pub fn fields(&self) -> &ConditionData

The structured fields as attached (unprefixed).

Trait Implementations

impl Clone for RError

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RError

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

Formats the value using the given formatter.

impl Display for RError

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

Formats the value using the given formatter.

impl<E: Error> From<E> for RError

fn from(err: E) -> Self

Message = the error’s Display plus its source() chain, one caused by: line per link (same rendering as AsRError).

impl RConditionData for RError

fn message(&self) -> String

The condition message (conditionMessage(e)).

fn class(&self) -> Vec<String>

User classes, most specific first; empty for none.

fn data(&self) -> Option<ConditionData>

Structured fields spliced into the condition object (e$<name>).

fn call(&self) -> ConditionCall

Whether the condition reports a call. ConditionCall::None makes conditionCall() NULL, like R’s call. = FALSE, for a condition about the data rather than the call; the default keeps the call the transport captured. Honoured by defer_* and by Result returns; an argument-conversion error always keeps the call (see conversion_err_parts). #[condition(call = none)] on a derived type or variant overrides this.

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

The whole message when this error refuses an argument, or None.

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