Struct RCall 

pub struct RCall {
    fun: SEXP,
    args: Vec<(Option<CString>, SEXP)>,
}

Builder for constructing and evaluating R function calls.

RCall constructs a LANGSXP (R language object) from a function name or SEXP and a sequence of arguments (optionally named). It handles GC protection during construction and evaluation.

Example

use miniextendr_api::expression::RCall;
use miniextendr_api::ffi;

unsafe {
    // seq_len(10)
    let result = RCall::new("seq_len")
        .arg(ffi::Rf_ScalarInteger(10))
        .eval_base()?;

    // paste(x, collapse = ", ")
    let result = RCall::new("paste")
        .arg(some_sexp)
        .named_arg("collapse", ffi::Rf_mkString(c", ".as_ptr()))
        .eval_base()?;
}

Fields

fun: SEXP

Function symbol or SEXP.

args: Vec<(Option<CString>, SEXP)>

Arguments as (optional_name, value) pairs.

Implementations

impl RCall

pub unsafe fn new(fun_name: &str) -> Self

Start building a call to a named R function.

The function is looked up via Rf_install, which returns an interned symbol.

Safety

Must be called from the R main thread.

Panics

Panics if fun_name contains a null byte.

pub unsafe fn from_cstr(fun_name: &CStr) -> Self

Start building a call to a function given as a C string literal.

More efficient than new when a &CStr is available.

Safety

Must be called from the R main thread.

pub unsafe fn from_sexp(fun: SEXP) -> Self

Start building a call with a function SEXP (closure, builtin, etc.).

Safety

fun must be a valid SEXP representing a callable R object.

pub fn arg(self, value: SEXP) -> Self

Add a positional argument.

pub fn named_arg(self, name: &str, value: SEXP) -> Self

Add a named argument.

Panics

Panics if name contains a null byte.

pub unsafe fn build(&self) -> SEXP

Build the LANGSXP without evaluating it.

The returned SEXP is unprotected. The caller must protect it if further allocations will occur before use.

Safety

Must be called from the R main thread. All argument SEXPs must still be valid (protected or otherwise reachable by R’s GC).

pub unsafe fn eval(&self, env: SEXP) -> Result<SEXP, String>

Evaluate the call in the given environment.

Uses R_tryEvalSilent so that R errors are captured as Err(String) rather than causing a longjmp through Rust frames.

Safety

• Must be called from the R main thread.
• env must be a valid ENVSXP.
• All argument SEXPs must still be valid.

Returns

• Ok(SEXP) with the result (unprotected — caller should protect if needed)
• Err(String) with the R error message on failure

pub unsafe fn eval_base(&self) -> Result<SEXP, String>

Evaluate in R_BaseEnv.

Safety

Same as eval.