Enum RTypeCheck 

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

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

Each variant maps to a specific set of R-side checks. 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 the multi-source scalars f32, i8, i16, i64, isize, and for a coerced native f64. Native i32 / f64 without coerce use RTypeCheck::Scalar with "integer" / "double".

ScalarLogicalOrInteger

Coerced bool: logical or integer, with length one.

VectorLogicalOrInteger

Coerced bool vector: logical or integer.

ScalarIntegerWide

Coerced native i32 scalar: integer, logical, raw, or a whole-number double, with length one. The vector form is RTypeCheck::VectorIntegerWide.

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<f32> (multi-source converter) and for a coerced native Vec<f64>; Vec<f64> / &[f64] without coerce use RTypeCheck::Vector with "double" because the native path reads REALSXP only.

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.

ScalarNumericOrText

AsNumeric scalar: numeric, logical, character, or factor, with length one (2 assertions). The marker parses character and factor labels the way as.numeric() does, so the gate admits exactly the types it reads.

VectorNumericOrText

AsNumericVec: numeric, logical, character, or factor (1 assertion).

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 checks for this type check.

Returns one or more RAssertion values, each one requirement on param (the R parameter name used in the conditions and messages).

fn is_vector(&self) -> bool

Whether the check admits several values: the vector checks and RTypeCheck::List, through RTypeCheck::Nullable. Matched exhaustively, so a new check has to say which it is.

fn expectation(&self) -> String

What an argument of this type must be, in R terms: the <expected> of a Rust conversion failure’s message, '<p>' must be <expected>: <reason> (#1591).

The R-side checks test one requirement at a time (type, then length); a conversion failure names the whole expectation once. Scalars read a single <noun> (a single integer, a single string, TRUE or FALSE), vectors name the R type (numeric, character, a list). AsNumeric / AsNumericVec say a single number / numeric, the value they produce, rather than the inputs they read. AsCharacter / AsCharacterVec likewise say coercible to a single string / coercible to character: their R-side check has already required an atomic argument, so what is left to fail is the as.character() step (a failing method, a non-character or wrong-length result).

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
• ScalarLogicalOrInteger: 0 bytes
• VectorLogicalOrInteger: 0 bytes
• ScalarIntegerWide: 0 bytes
• ScalarNonNeg: 0 bytes
• Scalar: 16 bytes
• VectorNumeric: 0 bytes
• VectorIntegerStrict: 0 bytes
• VectorIntegerWide: 0 bytes
• Vector: 16 bytes
• ScalarNumericOrText: 0 bytes
• VectorNumericOrText: 0 bytes
• Nullable: 8 bytes
• List: 0 bytes