enum RTypeCheck {
Show 15 variants
ScalarNumeric,
ScalarLogicalOrInteger,
VectorLogicalOrInteger,
ScalarIntegerWide,
ScalarNonNeg,
Scalar(&'static str),
VectorNumeric,
VectorIntegerStrict,
VectorIntegerWide,
VectorNonNegIntegerWide,
Vector(&'static str),
ScalarNumericOrText,
VectorNumericOrText,
Nullable(Box<RTypeCheck>),
List,
}Expand description
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. The vector form is
RTypeCheck::VectorNonNegIntegerWide.
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. The unsigned element
types use RTypeCheck::VectorNonNegIntegerWide.
VectorNonNegIntegerWide
Unsigned integer vector (Vec<u16> / Vec<u32> / Vec<u64> /
Vec<usize>, their slices and Vec<Option<_>> forms): the
RTypeCheck::VectorIntegerWide predicate, then every non-NA element
>= 0 (2 assertions), as RTypeCheck::ScalarNonNeg checks its value
(#2290). Without it a negative element passed the R gate and failed in
Rust as “value out of range”, under the whole-number requirement it met.
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. Around a scalar check a plain
NA passes too (is.null(x) || (is.logical(x) && length(x) == 1L && is.na(x)) ||, plain_na_check, #2305); around a vector check it
does not.
List
List check: is.list(x) (1 assertion).
Used for HashMap, BTreeMap, NamedList, List, ListMut.
Implementations§
Source§impl RTypeCheck
impl RTypeCheck
Sourcefn assertions(&self, param: &str) -> Vec<RAssertion>
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).
Sourcefn is_vector(&self) -> bool
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.
Sourcefn expectation(&self) -> String
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).
Auto Trait Implementations§
impl Forget for RTypeCheck
impl Freeze for RTypeCheck
impl RefUnwindSafe for RTypeCheck
impl Send for RTypeCheck
impl Sync for RTypeCheck
impl Unpin for RTypeCheck
impl UnsafeUnpin for RTypeCheck
impl UnwindSafe for RTypeCheck
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Source§impl<T> SizeHint for Twhere
T: ?Sized,
impl<T> SizeHint for Twhere
T: ?Sized,
Source§default fn lower_bound(&self) -> usize
default fn lower_bound(&self) -> usize
core_io_internals)[u8; 12] could return any value between 0 and
12 inclusively as a correct implementation. Read moreSource§impl<T> SizedTypeProperties for T
impl<T> SizedTypeProperties for T
Source§#[doc(hidden)]const SIZE: usize
#[doc(hidden)]const SIZE: usize
sized_type_properties)Source§#[doc(hidden)]const ALIGN: usize
#[doc(hidden)]const ALIGN: usize
sized_type_properties)Source§#[doc(hidden)]const ALIGNMENT: Alignment
#[doc(hidden)]const ALIGNMENT: Alignment
ptr_alignment_type)Source§#[doc(hidden)]const IS_ZST: bool
#[doc(hidden)]const IS_ZST: bool
sized_type_properties)Source§#[doc(hidden)]const LAYOUT: Layout
#[doc(hidden)]const LAYOUT: Layout
sized_type_properties)Source§#[doc(hidden)]const MAX_SLICE_LEN: usize
#[doc(hidden)]const MAX_SLICE_LEN: usize
sized_type_properties)[Self]. Read moreLayout§
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 bytesScalarLogicalOrInteger: 0 bytesVectorLogicalOrInteger: 0 bytesScalarIntegerWide: 0 bytesScalarNonNeg: 0 bytesScalar: 16 bytesVectorNumeric: 0 bytesVectorIntegerStrict: 0 bytesVectorIntegerWide: 0 bytesVectorNonNegIntegerWide: 0 bytesVector: 16 bytesScalarNumericOrText: 0 bytesVectorNumericOrText: 0 bytesNullable: 8 bytesList: 0 bytes