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::sys;

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

    // paste(x, collapse = ", ")
    let result = RCall::new("paste")
        .arg(some_sexp)
        .named_arg("collapse", sys::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.

pub unsafe fn namespaced(pkg: &str, fun_name: &str) -> Result<Self, String>

Start building a namespaced call: pkg::fun(args…).

Looks up pkg::fun_name in the base environment and uses the resolved function closure as the call target. This respects R’s namespace lookup rules (exported + non-exported via :: / :::).

This is the runtime counterpart of the lowered pkg::fn(args…) form in r!(pkg::fn(args…)).

Safety

Must be called from the R main thread.

Panics

Panics if pkg or fun_name contain a null byte.

Errors

Returns Err(String) if the namespace lookup fails (package not loaded or function not found).

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