Enum RTypeCheck 

enum RTypeCheck {
    ScalarNumeric,
    ScalarNonNeg,
    Scalar(&'static str),
    VectorNumeric,
    VectorIntegerStrict,
    VectorIntegerWide,
    Vector(&'static str),
    Nullable(Box<RTypeCheck>),
    List,
}

Classification of an R-side type check for a function parameter.

Each variant maps to a specific set of stopifnot() assertions. Numeric checks use a broad predicate (is.numeric || is.logical || is.raw) because R coerces logical to numeric freely and raw to integer is valid for byte-sized types. Borderline cases (e.g., raw to i64 in strict mode) pass the precondition and reach Rust’s strict checker, which produces better contextual error messages.

Variants

ScalarNumeric

Numeric scalar: type check + length-1 check (2 assertions). Used for i32, f64, f32, i8, i16, i64, isize.

ScalarNonNeg

Non-negative numeric scalar: type + length-1 + >= 0 (3 assertions). Used for u16, u32, u64, usize.

Scalar(&'static str)

Non-numeric scalar: is.<type>(x) + length-1 check (2 assertions). The string is the R type predicate name (e.g., "logical", "character").

VectorNumeric

Floating-point numeric vector: loose is.numeric || is.logical || is.raw (1 assertion). Used for Vec<f64> / Vec<f32> / &[f64] — doubles are the natural representation, no truncation risk.

VectorIntegerStrict

INTSXP-only integer vector: is.integer(x) (1 assertion). Used only for Vec<i32> / &[i32] (issue #616). These use the native RNativeType inbound path (impl_vec_try_from_sexp_native!(i32)), which requires INTSXP and rejects REALSXP outright. The loose is.numeric predicate previously let a double like c(1, 2) pass the R gate only to fail with a cryptic “expected INTSXP, got REALSXP”. is.integer(x) rejects every double (whole or fractional) at the boundary with a clean message, matching the actual Rust behaviour and closing the silent-truncation gap.

VectorIntegerWide

Wide integer vector accepting REALSXP whole-number values: the lossless whole-number predicate (1 assertion). Used for every non-i32 integer element type — Vec<i8> / Vec<i16> / Vec<u16> / Vec<u32> and the 64-bit family Vec<i64> / Vec<u64> / Vec<isize> / Vec<usize> (issue #616). These use the coercing inbound path (impl_vec_try_from_sexp_numeric! → from_numeric_vec_with) which accepts INTSXP/REALSXP/RAWSXP/LGLSXP and rejects fractional doubles element-wise (f64: TryCoerce<T> checks self.fract() != 0). We accept integer/logical/raw and whole-number doubles, and reject genuinely lossy fractional doubles (1.5) at the boundary.

Vector(&'static str)

Non-numeric vector: is.<type>(x) only (1 assertion). The string is the R type predicate name.

Nullable(Box<RTypeCheck>)

Nullable wrapper around an inner check: prepends is.null(x) || to each assertion and adjusts messages to mention NULL.

List

List check: is.list(x) (1 assertion). Used for HashMap, BTreeMap, NamedList, List, ListMut.

Implementations

impl RTypeCheck

fn assertions(&self, param: &str) -> Vec<RAssertion>

Produce the individual stopifnot() assertions for this type check.

Returns one or more RAssertion values, each representing a single "message" = condition entry in the stopifnot() call. The param argument is the R parameter name to use in messages and conditions.

fn coerced(self) -> Self

Tighten the check for a coerced parameter.

#[miniextendr(coerce)] on an integer-element vector reads via the native &[i32] slice (INTSXP-only), so a RTypeCheck::VectorIntegerWide that would otherwise accept whole-number REALSXP must become a strict is.integer gate (issue #616). Recurses through RTypeCheck::Nullable. All other checks are unaffected. Type-sensitive tightening (e.g. bool, whose logical gate must become an integer gate) lives in coerce_tightened, which needs the declared Rust 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: 24 bytes

Size for each variant:

• ScalarNumeric: 0 bytes
• ScalarNonNeg: 0 bytes
• Scalar: 16 bytes
• VectorNumeric: 0 bytes
• VectorIntegerStrict: 0 bytes
• VectorIntegerWide: 0 bytes
• Vector: 16 bytes
• Nullable: 8 bytes
• List: 0 bytes