Struct SEXP 

#[repr(transparent)]
pub struct SEXP(pub *mut SEXPREC);

R’s pointer type for S-expressions.

This is a newtype wrapper around *mut SEXPREC that implements Send and Sync. SEXP is just a handle (pointer) - the actual data it points to is managed by R’s garbage collector and should only be accessed on R’s main thread.

Safety

While SEXP is Send+Sync (allowing it to be passed between threads), the data it points to must only be accessed on R’s main thread. The miniextendr runtime enforces this through checked FFI wrappers and with_r_thread routing when worker dispatch is selected.

Equality Semantics

IMPORTANT: The derived PartialEq compares pointer equality, not semantic equality. For proper R semantics (comparing object contents), use R_compute_identical.

// Pointer equality (fast, often wrong for R semantics)
if sexp1 == sexp2 { ... }  // Only true if same pointer

// Semantic equality (correct R semantics)
if R_compute_identical(sexp1, sexp2, 16) != 0 { ... }

Hash trait removed: SEXP no longer implements Hash because proper hashing would require deep content inspection via R_compute_identical, which is too expensive for general use. If you need SEXP as a HashMap key, use pointer identity:

// Store by pointer identity (common pattern for R symbol lookups)
let mut map: HashMap<*mut SEXPREC, Value> = HashMap::new();
map.insert(sexp.as_ptr(), value);

Tuple Fields

0: *mut SEXPREC

Implementations

impl SEXP

pub const fn null() -> Self

Create a C null pointer SEXP (0x0).

This is not R’s NULL value (R_NilValue). R’s NULL is a real heap-allocated singleton; a C null pointer is just address zero. Passing SEXP::null() where R expects R_NilValue will corrupt R’s GC state and likely segfault.

Use SEXP::nil() for R’s NULL. Only use null() for low-level pointer initialization, ALTREP Sum/Min/Max “can’t compute” returns (R checks != NULL, not != R_NilValue), or comparison against uninitialized pointers.

See also: SEXP::nil(), SEXP::is_null_ptr(), SEXP::is_nil()

pub fn nil() -> Self

Return R’s NULL singleton (R_NilValue).

This is not a C null pointer — it points to R’s actual nil object on the heap. Use this for .Call() return values, SEXP arguments to R API functions, and any slot in R data structures.

See also: SEXP::null(), SEXP::is_nil(), SEXP::is_null_ptr()

pub const fn is_null_ptr(self) -> bool

Is this SEXP a C null pointer (address 0x0)?

This answers a pointer question, not an R question. An SEXP that R hands you (a .Call() argument, a list element, an attribute) is never a C null pointer: R’s NULL is the R_NilValue singleton, a real object at a non-zero address. A C null pointer only shows up where C code uses address zero for “nothing here”: an uninitialised static or field (SEXP::null()), an ALTREP data1/data2 slot that was never set, or an FFI function that returns NULL on failure.

To ask “is this R’s NULL?”, use SEXP::is_nil().

use miniextendr_api::SEXP;

let unset = SEXP::null();
assert!(unset.is_null_ptr());

There is no SEXP::is_null(): the name read like a test for R’s NULL, so it is gone on purpose.

use miniextendr_api::SEXP;

let unset = SEXP::null();
assert!(unset.is_null());

See also: SEXP::is_nil(), SEXP::is_null_or_nil(), SEXP::null()

pub fn is_nil(self) -> bool

Is this SEXP R’s NULL (R_NilValue)?

This is the check for an R value: an optional argument that defaults to NULL, an absent attribute, an empty list slot. It compares the address against the R_NilValue singleton and never dereferences self, so it is safe on a stale SEXP. A C null pointer is not R’s NULL; for that, use SEXP::is_null_ptr().

use miniextendr_api::SEXP;

// `x` is an argument whose R default is `NULL`: `f()` and `f(NULL)`
// both arrive as `R_NilValue`.
fn given(x: SEXP) -> bool {
    !x.is_nil()
}

See also: SEXP::nil(), SEXP::is_null_ptr(), SEXP::is_null_or_nil()

pub fn is_null_or_nil(self) -> bool

Is this SEXP either a C null pointer or R’s NULL?

For a slot that can hold either kind of “nothing”: unset (address zero) or set to R_NilValue, such as an external pointer’s protected value. For an R value alone, SEXP::is_nil() is the right check.

use miniextendr_api::SEXP;

// A slot that was never set counts as empty.
assert!(SEXP::null().is_null_or_nil());

See also: SEXP::is_nil(), SEXP::is_null_ptr()

pub const fn as_ptr(self) -> *mut SEXPREC

Get the raw pointer.

pub const fn from_ptr(ptr: *mut SEXPREC) -> Self

Create from a raw pointer.

pub fn charsxp(s: &str) -> SEXP

Create a CHARSXP from a Rust &str (UTF-8).

pub fn na_string() -> SEXP

R’s NA_character_ singleton.

pub fn blank_string() -> SEXP

R’s empty string "" singleton.

pub fn install_char(charsxp: SEXP) -> SEXP

Create an R symbol (SYMSXP) from a CHARSXP.

Equivalent to Rf_installChar(charsxp). The symbol is interned in R’s global symbol table and never garbage collected.

pub fn symbol(name: &str) -> SEXP

Create an R symbol (SYMSXP) from a Rust &str.

Combines SEXP::charsxp() + Rf_installChar into one call. The symbol is interned and never garbage collected.

pub fn scalar_integer(x: i32) -> SEXP

Create a length-1 integer vector.

pub fn scalar_real(x: f64) -> SEXP

Create a length-1 real vector.

pub fn scalar_logical(x: bool) -> SEXP

Create a length-1 logical vector.

Produces only TRUE or FALSE; a bool cannot represent R’s NA. For an NA logical, use scalar_logical_raw with NA_LOGICAL (i32::MIN).

pub fn scalar_logical_raw(x: i32) -> SEXP

Create a length-1 logical vector from raw i32 (0=FALSE, 1=TRUE, NA_LOGICAL=NA). Accepts 0 (FALSE), 1 (TRUE), or NA_LOGICAL (i32::MIN) for NA. Prefer scalar_logical for non-NA values.

pub fn scalar_raw(x: u8) -> SEXP

Create a length-1 raw vector.

pub fn scalar_complex(x: Rcomplex) -> SEXP

Create a length-1 complex vector.

pub fn scalar_string(charsxp: SEXP) -> SEXP

Create a length-1 character vector from a CHARSXP.

pub fn scalar_string_from_str(s: &str) -> SEXP

Create a length-1 character vector from a Rust &str.

pub unsafe fn scalar_integer_unchecked(x: i32) -> SEXP

Create a length-1 integer vector (unchecked — no thread routing).

Safety

Must be called from the R main thread.

pub unsafe fn scalar_real_unchecked(x: f64) -> SEXP

Create a length-1 real vector (unchecked — no thread routing).

Safety

Must be called from the R main thread.

pub unsafe fn scalar_logical_raw_unchecked(x: i32) -> SEXP

Create a length-1 logical vector from raw i32 (unchecked — no thread routing).

Accepts 0 (FALSE), 1 (TRUE), or NA_LOGICAL (i32::MIN) for NA.

Safety

Must be called from the R main thread.

pub unsafe fn scalar_raw_unchecked(x: u8) -> SEXP

Create a length-1 raw vector (unchecked — no thread routing).

Safety

Must be called from the R main thread.

pub unsafe fn scalar_complex_unchecked(x: Rcomplex) -> SEXP

Create a length-1 complex vector (unchecked — no thread routing).

Safety

Must be called from the R main thread.

pub unsafe fn scalar_string_unchecked(charsxp: SEXP) -> SEXP

Create a length-1 character vector from a CHARSXP (unchecked — no thread routing).

Safety

Must be called from the R main thread.

pub unsafe fn alloc(ty: SEXPTYPE, n: R_xlen_t) -> SEXP

Allocate a fresh R vector of the given type and length.

Direct wrapper over Rf_allocVector. For typed allocations, prefer helpers like SEXP::alloc_list, SEXP::alloc_strsxp, or wrap the result in OwnedProtect immediately — the returned SEXP is unprotected.

Safety

Must be called from the R main thread. The returned SEXP is unprotected; any subsequent allocation may collect it.

pub unsafe fn alloc_list(n: R_xlen_t) -> SEXP

Allocate an R list (VECSXP) of length n. Unprotected.

Equivalent to Rf_allocVector(VECSXP, n). Elements are initialised to R_NilValue.

Safety

Must be called from the R main thread. The returned SEXP is unprotected — wrap it in OwnedProtect before any other allocation that could trigger GC.

pub unsafe fn alloc_strsxp(n: R_xlen_t) -> SEXP

Allocate an R character vector (STRSXP) of length n. Unprotected.

Equivalent to Rf_allocVector(STRSXP, n). Elements are initialised to R_BlankString.

Safety

Must be called from the R main thread. The returned SEXP is unprotected — wrap it in OwnedProtect before any other allocation that could trigger GC.

pub fn names_symbol() -> SEXP

R’s names attribute symbol.

pub fn dim_symbol() -> SEXP

R’s dim attribute symbol.

pub fn dimnames_symbol() -> SEXP

R’s dimnames attribute symbol.

pub fn class_symbol() -> SEXP

R’s class attribute symbol.

pub fn levels_symbol() -> SEXP

R’s levels attribute symbol (factors).

pub fn tsp_symbol() -> SEXP

R’s tsp attribute symbol (time series).

pub fn base_namespace() -> SEXP

R’s base namespace environment.

pub fn missing_arg() -> SEXP

R’s missing argument sentinel.

pub unsafe fn altrep_data1_raw(self) -> SEXP

Get the raw SEXP in the ALTREP data1 slot.

Safety

• self must be a valid ALTREP SEXP
• Must be called from the R main thread

pub unsafe fn altrep_data1_raw_unchecked(self) -> SEXP

Get the raw SEXP in the ALTREP data1 slot (unchecked — no thread routing).

Safety

• self must be a valid ALTREP SEXP
• Must be called from the R main thread

pub unsafe fn set_altrep_data1(self, v: SEXP)

Set the ALTREP data1 slot.

Safety

• self must be a valid ALTREP SEXP
• Must be called from the R main thread

pub unsafe fn altrep_data2_raw(self) -> SEXP

Get the raw SEXP in the ALTREP data2 slot.

Safety

• self must be a valid ALTREP SEXP
• Must be called from the R main thread

pub unsafe fn altrep_data2_raw_unchecked(self) -> SEXP

Get the raw SEXP in the ALTREP data2 slot (unchecked — no thread routing).

Safety

• self must be a valid ALTREP SEXP
• Must be called from the R main thread

pub unsafe fn set_altrep_data2(self, v: SEXP)

Set the ALTREP data2 slot.

Safety

• self must be a valid ALTREP SEXP
• Must be called from the R main thread

pub unsafe fn set_altrep_data2_unchecked(self, v: SEXP)

Set the ALTREP data2 slot (unchecked — no thread routing).

Safety

• self must be a valid ALTREP SEXP
• Must be called from the R main thread

Trait Implementations

impl AltrepSexpExt for SEXP

unsafe fn altrep_data2_raw(&self) -> SEXP

Get the raw SEXP in the ALTREP data2 slot.

unsafe fn altrep_data2_raw_unchecked(&self) -> SEXP

Get the ALTREP data2 slot (unchecked — no thread routing).

unsafe fn set_altrep_data2(&self, data2: SEXP)

Set the ALTREP data2 slot.

unsafe fn set_altrep_data2_unchecked(&self, data2: SEXP)

Set the ALTREP data2 slot (unchecked — no thread routing).

impl Clone for SEXP

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 SEXP

impl Debug for SEXP

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

Formats the value using the given formatter.

impl Default for SEXP

fn default() -> Self

Returns the “default value” for a type.

impl Eq for SEXP

#[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 From<*mut SEXPREC> for SEXP

fn from(ptr: *mut SEXPREC) -> Self

Converts to this type from the input type.

impl From<Call> for SEXP

fn from(call: Call) -> SEXP

Converts to this type from the input type.

impl From<CallerCall> for SEXP

fn from(call: CallerCall) -> SEXP

Converts to this type from the input type.

impl From<SEXP> for *mut SEXPREC

fn from(sexp: SEXP) -> Self

Converts to this type from the input type.

impl From<Sendable<SEXP>> for SEXP

fn from(s: Sendable<SEXP>) -> Self

Converts to this type from the input type.

impl IntoR for SEXP

type Error = !

The error type for fallible conversions.

fn try_into_sexp(self) -> Result<SEXP, Self::Error>

Try to convert this value to an R SEXP.

unsafe fn try_into_sexp_unchecked(self) -> Result<SEXP, Self::Error>

Try to convert to SEXP without thread safety checks.

fn into_sexp(self) -> SEXP

Convert this value to an R SEXP, panicking on error.

unsafe fn into_sexp_unchecked(self) -> SEXP

where Self: Sized,

Convert to SEXP without thread safety checks, panicking on error.

impl PairListExt for SEXP

fn cons(self, cdr: SEXP) -> SEXP

A new pairlist node, CONS(self, cdr): this SEXP as its value, cdr as the rest. The node is unprotected.

fn lcons(self, cdr: SEXP) -> SEXP

A new call node, LCONS(self, cdr): this SEXP (the function) as its value, cdr (the arguments) as the rest. The node is unprotected.

fn car(&self) -> SEXP

The value of this node (CAR). On a call, the function.

fn cdr(&self) -> SEXP

The rest of the pairlist after this node (CDR): the next node, or NULL after the last. On a call, its arguments.

fn tag(&self) -> SEXP

The name of this node (TAG): a symbol, or NULL when it has none.

fn args(&self) -> PairListArgs<'_>

The arguments of a call, or the elements of a pairlist, as (name, value). The name is None for an unnamed one; a repeated name is kept.

fn set_tag(&self, tag: SEXP)

Set the name of this node (SET_TAG): a symbol, or NULL.

fn set_car(&self, value: SEXP) -> SEXP

Set the value of this node (SETCAR); returns value.

fn set_cdr(&self, tail: SEXP) -> SEXP

Set the rest of the pairlist after this node (SETCDR); returns tail.

unsafe fn cons_unchecked(self, cdr: SEXP) -> SEXP

Create a cons cell (no thread check).

unsafe fn car_unchecked(&self) -> SEXP

Get the CAR (no thread check).

unsafe fn cdr_unchecked(&self) -> SEXP

Get the CDR (no thread check).

unsafe fn set_tag_unchecked(&self, tag: SEXP)

Set the TAG (no thread check).

unsafe fn set_car_unchecked(&self, value: SEXP) -> SEXP

Set the CAR (no thread check).

unsafe fn set_cdr_unchecked(&self, tail: SEXP) -> SEXP

Set the CDR (no thread check).

impl PartialEq for SEXP

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

Equality operator ==.

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

Inequality operator !=.

impl Send for SEXP

impl SexpExt for SEXP

fn type_of(&self) -> SEXPTYPE

Get the type of this SEXP.

fn len(&self) -> usize

Get the length of this SEXP as usize.

fn xlength(&self) -> R_xlen_t

Get the length as R_xlen_t.

unsafe fn xlength_unchecked(&self) -> R_xlen_t

Get the length as R_xlen_t without thread checks.

unsafe fn len_unchecked(&self) -> usize

Get the length without thread checks.

unsafe fn as_slice<T: RNativeType>(&self) -> &'static [T]

Get a slice view of this SEXP’s data.

unsafe fn as_mut_slice<T: RNativeType>(&self) -> &'static mut [T]

Get a mutable slice view of this SEXP’s data.

unsafe fn as_slice_unchecked<T: RNativeType>(&self) -> &'static [T]

Get a slice view without thread checks.

fn is_integer(&self) -> bool

Check if this SEXP is an integer vector (INTSXP).

fn is_real(&self) -> bool

Check if this SEXP is a real/numeric vector (REALSXP).

fn is_logical(&self) -> bool

Check if this SEXP is a logical vector (LGLSXP).

fn is_character(&self) -> bool

Check if this SEXP is a character/string vector (STRSXP).

fn is_raw(&self) -> bool

Check if this SEXP is a raw vector (RAWSXP).

fn is_complex(&self) -> bool

Check if this SEXP is a complex vector (CPLXSXP).

fn is_list(&self) -> bool

Check if this SEXP is a list/generic vector (VECSXP).

fn is_external_ptr(&self) -> bool

Check if this SEXP is an external pointer (EXTPTRSXP).

fn is_environment(&self) -> bool

Check if this SEXP is an environment (ENVSXP).

fn is_symbol(&self) -> bool

Check if this SEXP is a symbol (SYMSXP).

fn is_language(&self) -> bool

Check if this SEXP is a language object (LANGSXP).

fn is_altrep(&self) -> bool

Check if this SEXP is an ALTREP object.

fn is_empty(&self) -> bool

Check if this SEXP contains any elements.

fn is_factor(&self) -> bool

Check if this SEXP is a factor.

fn is_pair_list(&self) -> bool

Check if this SEXP is a pairlist (LISTSXP or NILSXP).

fn is_matrix(&self) -> bool

Check if this SEXP is a matrix.

fn is_array(&self) -> bool

Check if this SEXP is an array.

fn is_function(&self) -> bool

Check if this SEXP is a function (closure, builtin, or special).

fn is_s4(&self) -> bool

Check if this SEXP is an S4 object.

fn is_data_frame(&self) -> bool

Check if this SEXP is a data.frame.

fn is_numeric(&self) -> bool

Check if this SEXP is a numeric type (integer, logical, or real, excluding factors).

fn is_number(&self) -> bool

Check if this SEXP is a number type (numeric or complex).

fn is_vector_atomic(&self) -> bool

Check if this SEXP is an atomic vector.

fn is_vector_list(&self) -> bool

Check if this SEXP is a vector list (VECSXP or EXPRSXP).

fn is_vector(&self) -> bool

Check if this SEXP is a vector (atomic vector or list).

fn is_object(&self) -> bool

Check if this SEXP is an R “object” (has a class attribute).

fn coerce(&self, target: SEXPTYPE) -> SEXP

Coerce this SEXP to the given type, returning a new SEXP.

fn as_logical(&self) -> Option<bool>

Extract a scalar logical value.

fn as_integer(&self) -> Option<i32>

Extract a scalar integer value.

fn as_real(&self) -> Option<f64>

Extract a scalar real value.

fn as_char(&self) -> SEXP

Extract a scalar CHARSXP from this SEXP.

fn get_attr(&self, name: SEXP) -> SEXP

Get an attribute by symbol.

fn set_attr(&self, name: SEXP, val: SEXP)

Set an attribute by symbol.

fn get_names(&self) -> SEXP

Get the names attribute.

fn set_names(&self, names: SEXP)

Set the names attribute.

fn get_class(&self) -> SEXP

Get the class attribute.

fn set_class(&self, class: SEXP)

Set the class attribute.

fn get_dim(&self) -> SEXP

Get the dim attribute.

fn set_dim(&self, dim: SEXP)

Set the dim attribute.

fn get_dimnames(&self) -> SEXP

Get the dimnames attribute.

fn set_dimnames(&self, dimnames: SEXP)

Set the dimnames attribute.

fn get_levels(&self) -> SEXP

Get the levels attribute (factors).

fn set_levels(&self, levels: SEXP)

Set the levels attribute (factors).

fn get_row_names(&self) -> SEXP

Get the row.names attribute.

fn set_row_names(&self, row_names: SEXP)

Set the row.names attribute.

fn copy_most_attrib(&self, from: SEXP)

Copy every attribute of from except names, dim and dimnames onto this object, as R’s Rf_copyMostAttrib(from, self) does.

fn inherits_class(&self, class: &CStr) -> bool

Check if this SEXP inherits from a class.

fn has_attributes(&self) -> bool

Check whether this SEXP carries any attributes.

fn string_elt(&self, i: isize) -> SEXP

Get the i-th CHARSXP element from a STRSXP.

fn string_elt_str(&self, i: isize) -> Option<&str>

Get the i-th string element as Option<&str>.

fn set_string_elt(&self, i: isize, charsxp: SEXP)

Set the i-th CHARSXP element of a STRSXP.

fn is_na_string(&self) -> bool

Check if this CHARSXP is NA_character_.

fn vector_elt(&self, i: isize) -> SEXP

Get the i-th element of a VECSXP (generic vector / list).

fn set_vector_elt(&self, i: isize, val: SEXP)

Set the i-th element of a VECSXP.

fn integer_elt(&self, i: isize) -> i32

Get the i-th integer element.

fn real_elt(&self, i: isize) -> f64

Get the i-th real element.

fn logical_elt(&self, i: isize) -> i32

Get the i-th logical element (raw i32: 0/1/NA_LOGICAL).

fn complex_elt(&self, i: isize) -> Rcomplex

Get the i-th complex element.

fn raw_elt(&self, i: isize) -> u8

Get the i-th raw element.

fn set_integer_elt(&self, i: isize, v: i32)

Set the i-th integer element.

fn set_real_elt(&self, i: isize, v: f64)

Set the i-th real element.

fn set_logical_elt(&self, i: isize, v: i32)

Set the i-th logical element (raw i32: 0/1/NA_LOGICAL).

fn set_complex_elt(&self, i: isize, v: Rcomplex)

Set the i-th complex element.

fn set_raw_elt(&self, i: isize, v: u8)

Set the i-th raw element.

fn printname(&self) -> SEXP

Get the print name (CHARSXP) of a symbol (SYMSXP).

fn r_char(&self) -> *const c_char

Get the C string pointer from a CHARSXP.

fn r_char_str(&self) -> Option<&str>

Get a &str from a CHARSXP. Returns None for NA_character_.

fn resize(&self, newlen: R_xlen_t) -> SEXP

Resize a vector to a new length, returning a (possibly new) SEXP.

fn duplicate(&self) -> SEXP

Deep-copy this SEXP. Equivalent to R’s Rf_duplicate(x).

fn shallow_duplicate(&self) -> SEXP

Shallow-copy this SEXP. Equivalent to R’s Rf_shallow_duplicate(x).

fn is_identical(&self, other: SEXP) -> bool

Check whether this SEXP is identical to other under the defaults of R’s identical(x, y).

unsafe fn string_elt_unchecked(&self, i: isize) -> SEXP

Get the i-th CHARSXP from a STRSXP. No thread check.

unsafe fn set_string_elt_unchecked(&self, i: isize, charsxp: SEXP)

Set the i-th CHARSXP of a STRSXP. No thread check.

unsafe fn vector_elt_unchecked(&self, i: isize) -> SEXP

Get the i-th element of a VECSXP. No thread check.

unsafe fn set_vector_elt_unchecked(&self, i: isize, val: SEXP)

Set the i-th element of a VECSXP. No thread check.

unsafe fn get_attr_unchecked(&self, name: SEXP) -> SEXP

Get an attribute by symbol. No thread check.

unsafe fn set_attr_unchecked(&self, name: SEXP, val: SEXP)

Set an attribute by symbol. No thread check.

unsafe fn copy_most_attrib_unchecked(&self, from: SEXP)

Copy every attribute of from except names, dim and dimnames onto this object, as copy_most_attrib. No thread check.

unsafe fn r_char_unchecked(&self) -> *const c_char

Get C string pointer from a CHARSXP. No thread check.

fn get_attr_opt(&self, name: SEXP) -> Option<SEXP>

Get an attribute by symbol, returning None for R_NilValue.

impl StructuralPartialEq for SEXP

impl Sync for SEXP

impl TrivialClone for SEXP

impl TryFromSexp for SEXP

Pass-through conversion for raw SEXP values with ALTREP auto-materialization.

This allows SEXP to be used directly in #[miniextendr] function signatures. When R passes an ALTREP vector (e.g., 1:10, seq_len(N)), ensure_materialized is called automatically to force materialization on the R main thread. After this, the SEXP’s data pointer is stable and safe to access from any thread.

ALTREP handling

Input	Result
Regular SEXP	Passed through unchanged
ALTREP SEXP	Materialized via ensure_materialized, then passed through

To receive ALTREP without materializing, use AltrepSexp as the parameter type instead. To receive the raw SEXP without any conversion (including no materialization), use extern "C-unwind".

Safety

SEXP handles are only valid on R’s main thread. Standalone #[miniextendr] functions taking a SEXP parameter run on the main thread automatically.

fn try_from_sexp(sexp: SEXP) -> Result<Self, Self::Error>

Converts a SEXP, auto-materializing ALTREP vectors.

If the input is ALTREP, ensure_materialized is called to force materialization on the R main thread. After materialization the data pointer is stable and the SEXP can be safely sent to other threads.

type Error = SexpError

The error type returned when conversion fails.

unsafe fn try_from_sexp_unchecked(sexp: SEXP) -> Result<Self, Self::Error>

Convert from SEXP without thread safety checks.

const NATIVE_BORROW: Option<NativeBorrow> = None

Native vector storage retained by this conversion, if any.

const CHARACTER_ONLY: bool = false

Whether this conversion accepts only character input: every value it converts, other than NULL, is a character vector or a factor.

#[doc(hidden)]

const __MX_EXPECTATION: Option<&'static str> = None

What an argument of this type must be, in R terms, when #[miniextendr] cannot tell from the type as written: the <expected> of a failed conversion’s '<p>' must be <expected>: ....

#[doc(hidden)]

unsafe fn __mx_try_from_rooted(root: Root<'_>) -> Result<Self, Self::Error>

Convert with a scope able to retain uncached ALTREP elements. Custom reference converters keep their existing behavior by default.

#[doc(hidden)]

fn __mx_has_na(&self) -> bool

Whether the converted argument holds a value #[miniextendr(no_na)] refuses after the conversion.

#[doc(hidden)]

fn __mx_input_has_na(&self, input: SEXP) -> bool

Whether #[miniextendr(no_na)] refuses this converted argument, read from input (the R value it converted from), when no R guard ran.

#[doc(hidden)]

fn __mx_try_from_sexp_with_check( sexp: SEXP, check: &ElementCheck<'_>, ) -> Result<Self, SexpError>

where Self::Error: Into<SexpError>,

Convert, running check, an element type’s TryFromSexpElement::check_sexp, on the R value that carries an element’s class (#1837).

#[doc(hidden)]

unsafe fn __mx_try_from_sexp_unchecked_with_check( sexp: SEXP, check: &ElementCheck<'_>, ) -> Result<Self, SexpError>

where Self::Error: Into<SexpError>,

__mx_try_from_sexp_with_check through try_from_sexp_unchecked. Not public API.

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