miniextendr

Use when the user asks how to expose a Rust struct as an R class, which R class system to use (R6 vs S3 vs S4 vs S7 vs Env vs Vctrs), how method dispatch works, how constructors are generated, how trait methods map to R, or when working in miniextendr-macros/src/miniextendr_impl/*.rs or miniextendr-macros/src/r_class_formatter.rs.

Use when the user asks about converting between R and Rust types, how TryFromSexp or IntoR work, what NA handling looks like, how strict mode differs from normal coercion, why Vec<i32> from an empty R vector panics, or how bool, Option<T>, or large integer types behave across the R-Rust boundary.

Use when the user asks about ExternalPtr, how Rust structs are stored as R objects, TypedExternal, Box<Box<dyn Any>> storage, pointer provenance for cached_ptr, the release_any finalizer, sidecar field accessors, the TYPE_NAME_CSTR vs TYPE_ID_CSTR distinction, or how to pass an ExternalPtr across crate or package boundaries.

Use when a new user asks how to start a miniextendr-backed R package from zero, how to scaffold via minirextendr::use_miniextendr(), what their first Rust function should look like, what the dev loop is, or "can I add Rust to an existing R package". Also use when someone is confused about which package is which (miniextendr vs minirextendr).

Use when the user asks how

Use when debugging configure.ac failures, Makevars issues, Cargo.lock mismatches, vendor tarball problems, build mode confusion, or the cdylib-to-staticlib double-link pipeline. Also use when changing a Makevars value, diagnosing a latch-leak, understanding the bash-vs-sh configure requirement, or working with m4 quoting in configure.ac.

Use when working in an R package with a miniextendr Rust backend and you need orientation — how the build pipeline works (configure → Makevars → cargo → wrapper generation), which files are generated vs hand-written, what the dev loop is, how to add a function or a Cargo feature, or which of the other miniextendr skills to load for a specific task.

Use when building, checking, or releasing a miniextendr-backed R package — producing the CRAN tarball, vendoring Rust dependencies (inst/vendor.tar.xz), offline installs, R CMD check --as-cran, a leftover vendor tarball breaking dev builds, Cargo.lock complaints, release CI for binaries, or version bumps.

Use when the user asks about implementing ALTREP (Alternative Representation) vectors in miniextendr, including derive macros (#[derive(AltrepInteger)],

Use when the user asks about handling R's ... (dots/variadic) arguments in Rust, the Dots type, the typed_list! macro,

Use when moving data.frames between R and Rust in a miniextendr package —

Use when writing multi-threaded Rust inside a miniextendr package — rayon parallel iterators feeding R vectors, the SEXP-not-Send rule, "cannot be sent between threads safely" compile errors, panics on worker threads, R stack-limit errors from spawned threads, or the worker-thread feature.

Use when a lint rule (MXL###) fires during cargo build or cargo check, when you want to understand what a specific rule checks and why it exists, when adding a new lint rule, or when diagnosing a build.rs static analysis failure. Also use when MINIEXTENDR_LINT=0 is being considered.

Use when exposing a Rust struct as an R class in a miniextendr package — choosing between R6, S3, S4, S7, Env, or vctrs; writing

Use when passing values between R and Rust in a miniextendr package — choosing argument/return types for

Use when a miniextendr-backed R package misbehaves — "could not find function" after adding Rust code, library() exposes nothing, configure or autoconf errors, cargo/link failures, dyn.load symbol-not-found, segfaults, suspected garbage-collector bugs, MXL lint failures, or a build that suddenly ignores your Rust edits.

Use when the user asks about the miniextendr codebase structure, crate graph, build pipeline, registration system, the cdylib-to-staticlib double-link, distributed_slice tables, the install-mode latch, or "how does X get from Rust to R". Also use when the user is navigating the repo for the first time and needs orientation.

Use when the user asks about implementing custom R connections in Rust (like file(), url(), gzcon() equivalents), the RConnectionImpl trait, RCustomConnection builder, catch_connection_panic trampolines, the CLOSED-state gotcha with R_new_custom_connection, ABI version checking for the connections API, or reading and writing through R connections from Rust.

Use when the user asks about the FFI safety layer in miniextendr: #[r_ffi_checked] proc macro, checked vs _unchecked FFI variants, when _unchecked is safe, with_r_unwind_protect / with_r_unwind_protect_or_raise, GC protection (OwnedProtect, ProtectScope), the R longjmp leak in the tagged-condition path, MXL300 / MXL301 lint rules, the nonapi feature gate, or the continuation token.

Use when R/test setup misbehaves (e.g. `testthat` is "not installed" mid-test, `__rv_R_mismatch` temp library appears, `just devtools-test` skips tests silently, `rv sync` complains, or you need to bump the pinned R version). Also use when adding a new R dependency to the dev workflow, understanding why `library()` works in one shell but not another, or coaching contributors through their first `rig` / `rv` setup for this repo.

Use when the user asks about the miniextendr worker thread, run_on_worker, with_r_thread, Sendable<T>, the worker-thread cargo feature, why Rust code runs on a separate thread from R, how panics on the worker thread become R errors, SEXP Send constraints, the R main thread invariant, miniextendr_runtime_init, or the 16MB R thread stack limit.

Use when creating a new R package with a Rust backend via minirextendr, upgrading an existing package's scaffold, diagnosing a broken setup with minirextendr_doctor(), maintaining or syncing templates between rpkg and minirextendr/inst/templates/, adding configure-time feature detection, or using use_release_workflow() for CRAN CI scaffolding.

Use when the user asks about serializing Rust types to R without writing TryFromSexp or IntoR by hand, how serde Serialize/Deserialize maps to R lists and vectors, what RSerializeNative and RDeserializeNative do, how AsSerialize works as a return type, when to reach for serde vs hand-rolled conversions, or how the native serde path differs from serde_json.