Struct SerdeErrorShape 

pub struct SerdeErrorShape {
    tag: Option<&'static str>,
    prefix: Option<&'static str>,
    skip: &'static [&'static str],
    rename: &'static [(&'static str, &'static str)],
    types: [&'static [&'static str]; 4],
}

The options of #[miniextendr(serde_error(..))] as a value: declared once, shared by every function that returns one error type.

use miniextendr_api::condition::SerdeErrorShape;

pub const ENGINE: SerdeErrorShape = SerdeErrorShape::new()
    .prefix("engine")
    .skip(&["message"])
    .as_character(&["rule", "column"])
    .as_integer(&["n"]);

Declare it for the error type with serde_error_shape!, and every #[miniextendr] function or method of the crate that returns that type uses it, without naming it:

miniextendr_api::serde_error_shape!(EngineError = ENGINE);

#[miniextendr]
pub fn check(x: f64) -> Result<f64, EngineError> { /* ... */ }

A function can override it for itself: with options of its own, or with another shape named by path, which applies after the declared one:

#[miniextendr(serde_error(as_double("n")))]
pub fn rate(x: f64) -> Result<f64, EngineError> { /* ... */ }

#[miniextendr(serde_error(shape = STRICT, as_double("n")))]
pub fn strict_rate(x: f64) -> Result<f64, EngineError> { /* ... */ }

The path resolves where the function is defined (STRICT, crate::errors::STRICT, or Self::SHAPE on a method for an associated const of its type), so a misspelt one is a compile error. The options act on the serde-classed Err arm, which needs the serde feature.

Options

One method per serde_error option. Fields are named as the error serializes them, before any rename:

• tag: the internally tagged discriminator field consumed as the variant; "kind" when unset.
• prefix: the family class; <crate>_error, from the function’s crate, when unset.
• skip: fields to drop.
• rename: (from, to) pairs; field from reaches R as e$to.
• as_character, as_integer, as_double, as_logical: the field’s usual serialization as one vector of that R type, as the miniextendr_api::serde::as_character & co. field helpers give it from the error type’s own #[serde(serialize_with = ..)]: character(0) for an empty sequence, NA for a None element. A value that doesn’t fit (a string under as_integer) raises an R error naming the field and the option.

A field that a variant doesn’t carry is a no-op for that variant, so one shape covers an enum whose variants differ.

Precedence

Shapes apply in order: the one declared for the error type, then serde_error(shape = ..), then the function’s own options; for a field set by more than one, the later wins. A later skip drops a field an earlier shape types or renames, and a later as_* or rename keeps a field an earlier shape skips. A type and a new name compose: the function’s rename(n = "count") keeps the shape’s as_integer(&["n"]). A later tag or prefix replaces an earlier one.

Contradictions don’t compile

Each method checks its fields against the options already set and panics during const evaluation, so a const holding a contradictory shape is a compile error (E0080) naming the field:

• a field in two as_* lists;
• a field skipped and also typed or renamed;
• a field listed twice, renamed twice, or two renames onto one name;
• a rename target that is one of the condition’s own slots (message, call, kind);
• an empty list or name, and an option set twice.

use miniextendr_api::condition::SerdeErrorShape;

const ENGINE: SerdeErrorShape = SerdeErrorShape::new()
    .as_integer(&["n"])
    .as_double(&["n"]);

Fields

tag: Option<&'static str>

prefix: Option<&'static str>

skip: &'static [&'static str]

rename: &'static [(&'static str, &'static str)]

types: [&'static [&'static str]; 4]

The as_* lists, in SHAPE_TYPE_OPTIONS order.

Implementations

impl SerdeErrorShape

pub const fn new() -> Self

A shape that sets nothing.

pub const fn tag(self, tag: &'static str) -> Self

The internally tagged discriminator field (#[serde(tag = "...")]), consumed as the variant.

pub const fn prefix(self, prefix: &'static str) -> Self

The family class: conditions get c("<prefix>_<variant>", "<prefix>").

pub const fn skip(self, fields: &'static [&'static str]) -> Self

Drop these payload fields.

pub const fn rename( self, pairs: &'static [(&'static str, &'static str)], ) -> Self

Splice field from as to, for each (from, to) pair.

pub const fn as_logical(self, fields: &'static [&'static str]) -> Self

Give these fields an R logical vector.

pub const fn as_integer(self, fields: &'static [&'static str]) -> Self

Give these fields an R integer vector; a value outside R’s integer range is an error, not a double.

pub const fn as_double(self, fields: &'static [&'static str]) -> Self

Give these fields an R double vector; integers widen.

pub const fn as_character(self, fields: &'static [&'static str]) -> Self

Give these fields an R character vector.

const fn with_type(self, index: usize, fields: &'static [&'static str]) -> Self

const fn type_option(&self, name: &str) -> Option<&'static str>

The as_* option that lists name.

const fn renames(&self, name: &str) -> bool

Whether a rename pair renames name.

Trait Implementations

impl Clone for SerdeErrorShape

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SerdeErrorShape

impl Debug for SerdeErrorShape

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

Formats the value using the given formatter.

impl Default for SerdeErrorShape

fn default() -> Self

Returns the “default value” for a type.

impl Eq for SerdeErrorShape

#[doc(hidden)]

fn assert_fields_are_eq(&self)

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

#[doc(hidden)]

fn assert_receiver_is_total_eq(&self)

👎Deprecated since 1.95.0:

implementation detail of #[derive(Eq)]

impl PartialEq for SerdeErrorShape

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SerdeErrorShape

impl TrivialClone for SerdeErrorShape

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