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 the worker thread pattern.

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(), SexpExt::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(), SexpExt::is_nil(), SEXP::is_null()

pub const fn is_null(self) -> bool

Check if this SEXP is a C null pointer (0x0).

To check if an SEXP is R’s NULL (R_NilValue), use SexpExt::is_nil() instead.

See also: SexpExt::is_nil(), SexpExt::is_null_or_nil()

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.

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 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.

Trait Implementations

impl AltrepSexpExt for SEXP

unsafe fn altrep_data1<T: TypedExternal>(&self) -> Option<ExternalPtr<T>>

Extract the ALTREP data1 slot as a typed ExternalPtr<T>.

unsafe fn altrep_data1_mut_ref<T: TypedExternal>( &self, ) -> Option<&'static mut T>

Get a mutable reference to data in the ALTREP data1 slot.

unsafe fn altrep_data2(&self) -> SEXP

Get the ALTREP data2 slot.

unsafe fn set_altrep_data2(&self, data2: SEXP)

Set the ALTREP data2 slot.

impl Clone for SEXP

fn clone(&self) -> SEXP

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

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 IntoR for SEXP

type Error = Infallible

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

Create a cons cell with this SEXP as CAR and cdr as CDR.

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

Create a language cons cell with this SEXP as CAR and cdr as CDR.

fn car(&self) -> SEXP

Get the CAR (head/value) of this pairlist node.

fn cdr(&self) -> SEXP

Get the CDR (tail/rest) of this pairlist node.

fn tag(&self) -> SEXP

Get the TAG (name symbol) of this pairlist node.

fn set_tag(&self, tag: SEXP)

Set the TAG (name symbol) of this pairlist node.

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

Set the CAR (value) of this pairlist node.

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

Set the CDR (tail) of this pairlist node.

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: &SEXP) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SexpExt for SEXP

fn type_of(&self) -> SEXPTYPE

Get the type of this SEXP.

fn is_null_or_nil(&self) -> bool

Check if this SEXP is null or R_NilValue.

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 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_nil(&self) -> bool

Check if this SEXP is R’s NULL (NILSXP).

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 inherits_class(&self, class: &CStr) -> bool

Check if this SEXP inherits from a class.

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).

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 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 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".

See docs/ALTREP_SEXP.md for the full guide.

Safety

SEXP handles are only valid on R’s main thread. Use with #[miniextendr(unsafe(main_thread))] functions.

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.

impl Copy for SEXP

impl Eq for SEXP

impl Send for SEXP

impl StructuralPartialEq for SEXP

impl Sync for SEXP