miniextendr_api/

altrep_bridge.rs

//! Unsafe ALTREP trampolines and installers bridging safe traits to R's C ABI.
//!
//! This module is the seam between R's C method tables and the safe traits in
//! [`crate::altrep_traits`]. It provides:
//! - Generic `extern "C-unwind"` trampolines (`t_length`, `t_dataptr`,
//!   `t_elt_*`, …) that call into safe trait methods on `T: Altrep`.
//! - Installer functions (`install_*`) that register the trampolines with R
//!   based on the `HAS_*` const gates declared by the safe traits.
//!
//! Non-allocating callbacks select `T::GUARD` at monomorphization time.
//! Callbacks returning SEXP, Dataptr and string/list setters always use
//! R_UnwindProtect: their generated bridges can allocate even when the
//! underlying data provider is pure Rust.
//!
//! ## Why a separate bridge module
//!
//! R installs methods via raw `extern "C-unwind"` function pointers. To make
//! `impl Altrep for MyType` ergonomic, we generate one trampoline per method
//! once, generic over `T: Altrep`, that:
//! 1. Recovers `T`'s monomorphization at the call site (no vtables).
//! 2. Wraps the user callback in the per-type guard.
//! 3. Hands the result back to R.
//!
//! Users (and the `#[derive(Altrep*)]` macros) never call into this module
//! directly — `RegisterAltrep::get_or_init_class` does.
//!
//! ## Design
//!
//! Trampolines are only installed when `HAS_*` is true. When false, the method
//! is NOT installed with R, so R uses its own default behavior.

use crate::altrep_traits::{
    AltComplex, AltInteger, AltList, AltLogical, AltRaw, AltReal, AltString, AltVec, Altrep,
    AltrepGuard,
};
use crate::sys::altrep::R_altrep_class_t;
use crate::{R_xlen_t, Rboolean, Rbyte, Rcomplex, SEXP, SEXPTYPE};
use core::ffi::c_void;

/// Dispatch an ALTREP callback through the guard mode selected by `T::GUARD`.
///
/// Since `T::GUARD` is a const, the compiler eliminates the unreachable branches
/// at monomorphization time — zero runtime overhead for the chosen mode.
///
/// - `Unsafe`: No protection — the closure runs directly.
/// - `RustUnwind`: Wraps in [`catch_unwind`](std::panic::catch_unwind), converting
///   panics to `Rf_error` so they don't unwind through C frames.
/// - `RUnwind`: Wraps in [`R_UnwindProtect`](crate::sys::R_UnwindProtect), catching
///   both Rust panics and R longjmps safely.
#[inline(always)]
fn guarded_altrep_call<T: Altrep, F, R>(f: F) -> R
where
    F: FnOnce() -> R,
{
    match T::GUARD {
        AltrepGuard::Unsafe => f(),
        AltrepGuard::RustUnwind => crate::ffi_guard::guarded_ffi_call(
            f,
            crate::ffi_guard::GuardMode::CatchUnwind,
            crate::panic_telemetry::PanicSource::Altrep,
        ),
        AltrepGuard::RUnwind => guarded_altrep_r_call(f),
    }
}

/// Protect callbacks whose framework bridge may allocate in R, independently
/// of the data provider's guard choice for native reads.
#[inline(always)]
fn guarded_altrep_r_call<R>(f: impl FnOnce() -> R) -> R {
    crate::ffi_guard::guarded_ffi_call(
        f,
        crate::ffi_guard::GuardMode::RUnwind,
        crate::panic_telemetry::PanicSource::Altrep,
    )
}

/// Root an SEXP result before the guard allocates to signal deferred conditions.
#[inline(always)]
fn guarded_altrep_sexp_call(f: impl FnOnce() -> SEXP) -> SEXP {
    let (result, _root) = guarded_altrep_r_call(|| {
        let result = f();
        // A C NULL result requests R's fallback in e.g. Duplicate/Extract_subset.
        // SAFETY: every other result is a valid SEXP, on R's main thread.
        let root = (!result.is_null_ptr()).then(|| unsafe { crate::OwnedProtect::new(result) });
        (result, root)
    });
    result
}

// region: ALTREP BASE TRAMPOLINES

/// Trampoline for Length method.
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_length<T: Altrep>(x: SEXP) -> R_xlen_t {
    guarded_altrep_call::<T, _, _>(|| T::length(x))
}

/// Trampoline for Duplicate method.
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_duplicate<T: Altrep>(x: SEXP, deep: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::duplicate(x, matches!(deep, Rboolean::TRUE)))
}

/// Trampoline for DuplicateEX method (extended duplication).
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_duplicate_ex<T: Altrep>(x: SEXP, deep: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::duplicate_ex(x, matches!(deep, Rboolean::TRUE)))
}

/// Trampoline for Inspect method.
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_inspect<T: Altrep>(
    x: SEXP,
    pre: i32,
    deep: i32,
    pvec: i32,
    inspect_subtree: Option<unsafe extern "C-unwind" fn(SEXP, i32, i32, i32)>,
) -> Rboolean {
    guarded_altrep_call::<T, _, _>(|| {
        if T::inspect(x, pre, deep, pvec, inspect_subtree) {
            Rboolean::TRUE
        } else {
            Rboolean::FALSE
        }
    })
}

/// Trampoline for Serialized_state method.
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_serialized_state<T: Altrep>(x: SEXP) -> SEXP {
    guarded_altrep_sexp_call(|| T::serialized_state(x))
}

/// Trampoline for Unserialize method.
/// # Safety
/// `class` and `state` must be valid SEXPs from R.
pub unsafe extern "C-unwind" fn t_unserialize<T: Altrep>(class: SEXP, state: SEXP) -> SEXP {
    guarded_altrep_sexp_call(|| T::unserialize(class, state))
}

/// Trampoline for UnserializeEX method (extended unserialization with attributes).
/// # Safety
/// `class`, `state`, and `attr` must be valid SEXPs from R.
pub unsafe extern "C-unwind" fn t_unserialize_ex<T: Altrep>(
    class: SEXP,
    state: SEXP,
    attr: SEXP,
    objf: ::std::os::raw::c_int,
    levs: ::std::os::raw::c_int,
) -> SEXP {
    guarded_altrep_sexp_call(|| T::unserialize_ex(class, state, attr, objf, levs))
}

/// Trampoline for Coerce method.
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_coerce<T: Altrep>(x: SEXP, to_type: SEXPTYPE) -> SEXP {
    guarded_altrep_sexp_call(|| T::coerce(x, to_type))
}
// endregion

// region: ALTVEC TRAMPOLINES

/// Trampoline for Dataptr method.
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_dataptr<T: AltVec>(x: SEXP, w: Rboolean) -> *mut c_void {
    guarded_altrep_r_call(|| T::dataptr(x, matches!(w, Rboolean::TRUE)))
}

/// Trampoline for Dataptr_or_null method.
/// # Safety
/// `x` must be a valid SEXP for the ALTREP class backed by `T`.
pub unsafe extern "C-unwind" fn t_dataptr_or_null<T: AltVec>(x: SEXP) -> *const c_void {
    guarded_altrep_call::<T, _, _>(|| T::dataptr_or_null(x))
}

/// Trampoline for Extract_subset method.
/// # Safety
/// `x`, `indx`, and `call` must be valid SEXPs.
pub unsafe extern "C-unwind" fn t_extract_subset<T: AltVec>(
    x: SEXP,
    indx: SEXP,
    call: SEXP,
) -> SEXP {
    guarded_altrep_sexp_call(|| T::extract_subset(x, indx, call))
}
// endregion

// region: ALTINTEGER TRAMPOLINES

/// Trampoline for integer Elt method.
/// # Safety
/// `x` must be a valid ALTREP INTSXP and `i` within bounds.
pub unsafe extern "C-unwind" fn t_int_elt<T: AltInteger>(x: SEXP, i: R_xlen_t) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::elt(x, i))
}

/// Trampoline for integer Get_region method.
/// # Safety
/// `x` must be a valid ALTREP INTSXP and `out` a valid buffer of at least `n` elements.
pub unsafe extern "C-unwind" fn t_int_get_region<T: AltInteger>(
    x: SEXP,
    i: R_xlen_t,
    n: R_xlen_t,
    out: *mut i32,
) -> R_xlen_t {
    if n <= 0 {
        return 0;
    }
    let buf = unsafe { crate::altrep_impl::altrep_region_buf(out, n as usize) };
    guarded_altrep_call::<T, _, _>(|| T::get_region(x, i, n, buf))
}

/// Trampoline for integer Is_sorted method.
/// # Safety
/// `x` must be a valid ALTREP INTSXP.
pub unsafe extern "C-unwind" fn t_int_is_sorted<T: AltInteger>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::is_sorted(x))
}

/// Trampoline for integer No_NA method.
/// # Safety
/// `x` must be a valid ALTREP INTSXP.
pub unsafe extern "C-unwind" fn t_int_no_na<T: AltInteger>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::no_na(x))
}

/// Trampoline for integer Sum method.
/// # Safety
/// `x` must be a valid ALTREP INTSXP.
pub unsafe extern "C-unwind" fn t_int_sum<T: AltInteger>(x: SEXP, narm: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::sum(x, matches!(narm, Rboolean::TRUE)))
}

/// Trampoline for integer Min method.
/// # Safety
/// `x` must be a valid ALTREP INTSXP.
pub unsafe extern "C-unwind" fn t_int_min<T: AltInteger>(x: SEXP, narm: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::min(x, matches!(narm, Rboolean::TRUE)))
}

/// Trampoline for integer Max method.
/// # Safety
/// `x` must be a valid ALTREP INTSXP.
pub unsafe extern "C-unwind" fn t_int_max<T: AltInteger>(x: SEXP, narm: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::max(x, matches!(narm, Rboolean::TRUE)))
}
// endregion

// region: ALTREAL TRAMPOLINES

/// Trampoline for real Elt method.
/// # Safety
/// `x` must be a valid ALTREP REALSXP and `i` within bounds.
pub unsafe extern "C-unwind" fn t_real_elt<T: AltReal>(x: SEXP, i: R_xlen_t) -> f64 {
    guarded_altrep_call::<T, _, _>(|| T::elt(x, i))
}

/// Trampoline for real Get_region method.
/// # Safety
/// `x` must be a valid ALTREP REALSXP and `out` a valid buffer of at least `n` elements.
pub unsafe extern "C-unwind" fn t_real_get_region<T: AltReal>(
    x: SEXP,
    i: R_xlen_t,
    n: R_xlen_t,
    out: *mut f64,
) -> R_xlen_t {
    if n <= 0 {
        return 0;
    }
    let buf = unsafe { crate::altrep_impl::altrep_region_buf(out, n as usize) };
    guarded_altrep_call::<T, _, _>(|| T::get_region(x, i, n, buf))
}

/// Trampoline for real Is_sorted method.
/// # Safety
/// `x` must be a valid ALTREP REALSXP.
pub unsafe extern "C-unwind" fn t_real_is_sorted<T: AltReal>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::is_sorted(x))
}

/// Trampoline for real No_NA method.
/// # Safety
/// `x` must be a valid ALTREP REALSXP.
pub unsafe extern "C-unwind" fn t_real_no_na<T: AltReal>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::no_na(x))
}

/// Trampoline for real Sum method.
/// # Safety
/// `x` must be a valid ALTREP REALSXP.
pub unsafe extern "C-unwind" fn t_real_sum<T: AltReal>(x: SEXP, narm: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::sum(x, matches!(narm, Rboolean::TRUE)))
}

/// Trampoline for real Min method.
/// # Safety
/// `x` must be a valid ALTREP REALSXP.
pub unsafe extern "C-unwind" fn t_real_min<T: AltReal>(x: SEXP, narm: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::min(x, matches!(narm, Rboolean::TRUE)))
}

/// Trampoline for real Max method.
/// # Safety
/// `x` must be a valid ALTREP REALSXP.
pub unsafe extern "C-unwind" fn t_real_max<T: AltReal>(x: SEXP, narm: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::max(x, matches!(narm, Rboolean::TRUE)))
}
// endregion

// region: ALTLOGICAL TRAMPOLINES

/// Trampoline for logical Elt method.
/// # Safety
/// `x` must be a valid ALTREP LGLSXP and `i` within bounds.
pub unsafe extern "C-unwind" fn t_lgl_elt<T: AltLogical>(x: SEXP, i: R_xlen_t) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::elt(x, i))
}

/// Trampoline for logical Get_region method.
/// # Safety
/// `x` must be a valid ALTREP LGLSXP and `out` a valid buffer of at least `n` elements.
pub unsafe extern "C-unwind" fn t_lgl_get_region<T: AltLogical>(
    x: SEXP,
    i: R_xlen_t,
    n: R_xlen_t,
    out: *mut i32,
) -> R_xlen_t {
    if n <= 0 {
        return 0;
    }
    let buf = unsafe { crate::altrep_impl::altrep_region_buf(out, n as usize) };
    guarded_altrep_call::<T, _, _>(|| T::get_region(x, i, n, buf))
}

/// Trampoline for logical Is_sorted method.
/// # Safety
/// `x` must be a valid ALTREP LGLSXP.
pub unsafe extern "C-unwind" fn t_lgl_is_sorted<T: AltLogical>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::is_sorted(x))
}

/// Trampoline for logical No_NA method.
/// # Safety
/// `x` must be a valid ALTREP LGLSXP.
pub unsafe extern "C-unwind" fn t_lgl_no_na<T: AltLogical>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::no_na(x))
}

/// Trampoline for logical Sum method.
/// # Safety
/// `x` must be a valid ALTREP LGLSXP.
pub unsafe extern "C-unwind" fn t_lgl_sum<T: AltLogical>(x: SEXP, narm: Rboolean) -> SEXP {
    guarded_altrep_sexp_call(|| T::sum(x, matches!(narm, Rboolean::TRUE)))
}

// Note: R's ALTREP API does not expose min/max for logical vectors
// endregion

// region: ALTRAW TRAMPOLINES

/// Trampoline for raw Elt method.
/// # Safety
/// `x` must be a valid ALTREP RAWSXP and `i` within bounds.
pub unsafe extern "C-unwind" fn t_raw_elt<T: AltRaw>(x: SEXP, i: R_xlen_t) -> Rbyte {
    guarded_altrep_call::<T, _, _>(|| T::elt(x, i))
}

/// Trampoline for raw Get_region method.
/// # Safety
/// `x` must be a valid ALTREP RAWSXP and `out` a valid buffer of at least `n` elements.
pub unsafe extern "C-unwind" fn t_raw_get_region<T: AltRaw>(
    x: SEXP,
    i: R_xlen_t,
    n: R_xlen_t,
    out: *mut Rbyte,
) -> R_xlen_t {
    if n <= 0 {
        return 0;
    }
    let buf = unsafe { crate::altrep_impl::altrep_region_buf(out, n as usize) };
    guarded_altrep_call::<T, _, _>(|| T::get_region(x, i, n, buf))
}
// endregion

// region: ALTCOMPLEX TRAMPOLINES

/// Trampoline for complex Elt method.
/// # Safety
/// `x` must be a valid ALTREP CPLXSXP and `i` within bounds.
pub unsafe extern "C-unwind" fn t_cplx_elt<T: AltComplex>(x: SEXP, i: R_xlen_t) -> Rcomplex {
    guarded_altrep_call::<T, _, _>(|| T::elt(x, i))
}

/// Trampoline for complex Get_region method.
/// # Safety
/// `x` must be a valid ALTREP CPLXSXP and `out` a valid buffer of at least `n` elements.
pub unsafe extern "C-unwind" fn t_cplx_get_region<T: AltComplex>(
    x: SEXP,
    i: R_xlen_t,
    n: R_xlen_t,
    out: *mut Rcomplex,
) -> R_xlen_t {
    if n <= 0 {
        return 0;
    }
    let buf = unsafe { crate::altrep_impl::altrep_region_buf(out, n as usize) };
    guarded_altrep_call::<T, _, _>(|| T::get_region(x, i, n, buf))
}
// endregion

// region: ALTSTRING TRAMPOLINES

/// Trampoline for string Elt method (REQUIRED for ALTSTRING).
/// # Safety
/// `x` must be a valid ALTREP STRSXP and `i` within bounds.
pub unsafe extern "C-unwind" fn t_str_elt<T: AltString>(x: SEXP, i: R_xlen_t) -> SEXP {
    guarded_altrep_sexp_call(|| T::elt(x, i))
}

/// Trampoline for string Set_elt method.
/// # Safety
/// `x` must be a valid ALTREP STRSXP and `v` a valid CHARSXP.
pub unsafe extern "C-unwind" fn t_str_set_elt<T: AltString>(x: SEXP, i: R_xlen_t, v: SEXP) {
    guarded_altrep_r_call(|| T::set_elt(x, i, v))
}

/// Trampoline for string Is_sorted method.
/// # Safety
/// `x` must be a valid ALTREP STRSXP.
pub unsafe extern "C-unwind" fn t_str_is_sorted<T: AltString>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::is_sorted(x))
}

/// Trampoline for string No_NA method.
/// # Safety
/// `x` must be a valid ALTREP STRSXP.
pub unsafe extern "C-unwind" fn t_str_no_na<T: AltString>(x: SEXP) -> i32 {
    guarded_altrep_call::<T, _, _>(|| T::no_na(x))
}
// endregion

// region: ALTLIST TRAMPOLINES

/// Trampoline for list Elt method (REQUIRED for ALTLIST).
/// # Safety
/// `x` must be a valid ALTREP VECSXP and `i` within bounds.
pub unsafe extern "C-unwind" fn t_list_elt<T: AltList>(x: SEXP, i: R_xlen_t) -> SEXP {
    guarded_altrep_sexp_call(|| T::elt(x, i))
}

/// Trampoline for list Set_elt method.
/// # Safety
/// `x` must be a valid ALTREP VECSXP and `v` a valid SEXP.
pub unsafe extern "C-unwind" fn t_list_set_elt<T: AltList>(x: SEXP, i: R_xlen_t, v: SEXP) {
    guarded_altrep_r_call(|| T::set_elt(x, i, v))
}
// endregion

// region: INSTALLERS - Only install methods where HAS_* = true

/// Install base ALTREP methods (always installs length, conditionally installs optional).
/// # Safety
/// Must be called during R initialization with a valid ALTREP class handle.
pub unsafe fn install_base<T: Altrep>(cls: R_altrep_class_t) {
    // Length is ALWAYS installed (required)
    unsafe { cls.set_length_method(Some(t_length::<T>)) };

    // Optional methods - only install if HAS_* = true
    if T::HAS_SERIALIZED_STATE {
        unsafe { cls.set_serialized_state_method(Some(t_serialized_state::<T>)) };
    }
    if T::HAS_UNSERIALIZE {
        unsafe { cls.set_unserialize_method(Some(t_unserialize::<T>)) };
    }
    if T::HAS_UNSERIALIZE_EX {
        unsafe { cls.set_unserialize_ex_method(Some(t_unserialize_ex::<T>)) };
    }
    if T::HAS_DUPLICATE {
        unsafe { cls.set_duplicate_method(Some(t_duplicate::<T>)) };
    }
    if T::HAS_DUPLICATE_EX {
        unsafe { cls.set_duplicate_ex_method(Some(t_duplicate_ex::<T>)) };
    }
    if T::HAS_COERCE {
        unsafe { cls.set_coerce_method(Some(t_coerce::<T>)) };
    }
    if T::HAS_INSPECT {
        unsafe { cls.set_inspect_method(Some(t_inspect::<T>)) };
    }
}

/// Install vector-level methods.
/// # Safety
/// Must be called during R initialization with a valid ALTREP class handle.
pub unsafe fn install_vec<T: AltVec>(cls: R_altrep_class_t) {
    if T::HAS_DATAPTR {
        unsafe { cls.set_dataptr_method(Some(t_dataptr::<T>)) };
    }
    if T::HAS_DATAPTR_OR_NULL {
        unsafe { cls.set_dataptr_or_null_method(Some(t_dataptr_or_null::<T>)) };
    }
    if T::HAS_EXTRACT_SUBSET {
        unsafe { cls.set_extract_subset_method(Some(t_extract_subset::<T>)) };
    }
}

/// Generate a family-specific installer function from a declarative spec.
///
/// Each entry maps a `HAS_*` const to a method on `R_altrep_class_t` and a trampoline.
/// Optional `always` entries are installed unconditionally (e.g. required Elt).
macro_rules! def_installer {
    (
        $(#[$meta:meta])*
        $fn_name:ident < T: $trait:ident > {
            $( $has:ident => $method:ident, $tramp:ident; )*
        }
    ) => {
        $(#[$meta])*
        pub unsafe fn $fn_name<T: $trait>(cls: R_altrep_class_t) {
            $(
                if T::$has { unsafe { cls.$method(Some($tramp::<T>)) } }
            )*
        }
    };
    (
        $(#[$meta:meta])*
        $fn_name:ident < T: $trait:ident > {
            $( $has:ident => $method:ident, $tramp:ident; )*
        }
        always { $( $always_method:ident, $always_tramp:ident; )* }
    ) => {
        $(#[$meta])*
        pub unsafe fn $fn_name<T: $trait>(cls: R_altrep_class_t) {
            $(
                unsafe { cls.$always_method(Some($always_tramp::<T>)) }
            )*
            $(
                if T::$has { unsafe { cls.$method(Some($tramp::<T>)) } }
            )*
        }
    };
}

def_installer! {
    /// Install integer-specific methods.
    /// # Safety
    /// Must be called during R initialization with a valid ALTREP class handle.
    install_int<T: AltInteger> {
        HAS_ELT => set_integer_elt_method, t_int_elt;
        HAS_GET_REGION => set_integer_get_region_method, t_int_get_region;
        HAS_IS_SORTED => set_integer_is_sorted_method, t_int_is_sorted;
        HAS_NO_NA => set_integer_no_na_method, t_int_no_na;
        HAS_SUM => set_integer_sum_method, t_int_sum;
        HAS_MIN => set_integer_min_method, t_int_min;
        HAS_MAX => set_integer_max_method, t_int_max;
    }
}

def_installer! {
    /// Install real-specific methods.
    /// # Safety
    /// Must be called during R initialization with a valid ALTREP class handle.
    install_real<T: AltReal> {
        HAS_ELT => set_real_elt_method, t_real_elt;
        HAS_GET_REGION => set_real_get_region_method, t_real_get_region;
        HAS_IS_SORTED => set_real_is_sorted_method, t_real_is_sorted;
        HAS_NO_NA => set_real_no_na_method, t_real_no_na;
        HAS_SUM => set_real_sum_method, t_real_sum;
        HAS_MIN => set_real_min_method, t_real_min;
        HAS_MAX => set_real_max_method, t_real_max;
    }
}

def_installer! {
    /// Install logical-specific methods.
    /// # Safety
    /// Must be called during R initialization with a valid ALTREP class handle.
    install_lgl<T: AltLogical> {
        HAS_ELT => set_logical_elt_method, t_lgl_elt;
        HAS_GET_REGION => set_logical_get_region_method, t_lgl_get_region;
        HAS_IS_SORTED => set_logical_is_sorted_method, t_lgl_is_sorted;
        HAS_NO_NA => set_logical_no_na_method, t_lgl_no_na;
        HAS_SUM => set_logical_sum_method, t_lgl_sum;
    }
}

def_installer! {
    /// Install raw-specific methods.
    /// # Safety
    /// Must be called during R initialization with a valid ALTREP class handle.
    install_raw<T: AltRaw> {
        HAS_ELT => set_raw_elt_method, t_raw_elt;
        HAS_GET_REGION => set_raw_get_region_method, t_raw_get_region;
    }
}

def_installer! {
    /// Install complex-specific methods.
    /// # Safety
    /// Must be called during R initialization with a valid ALTREP class handle.
    install_cplx<T: AltComplex> {
        HAS_ELT => set_complex_elt_method, t_cplx_elt;
        HAS_GET_REGION => set_complex_get_region_method, t_cplx_get_region;
    }
}

def_installer! {
    /// Install string-specific methods.
    /// # Safety
    /// Must be called during R initialization with a valid ALTREP class handle.
    /// Note: Elt is always installed for ALTSTRING (required).
    install_str<T: AltString> {
        HAS_SET_ELT => set_string_set_elt_method, t_str_set_elt;
        HAS_IS_SORTED => set_string_is_sorted_method, t_str_is_sorted;
        HAS_NO_NA => set_string_no_na_method, t_str_no_na;
    }
    always { set_string_elt_method, t_str_elt; }
}

def_installer! {
    /// Install list-specific methods.
    /// # Safety
    /// Must be called during R initialization with a valid ALTREP class handle.
    /// Note: Elt is always installed for ALTLIST (required).
    install_list<T: AltList> {
        HAS_SET_ELT => set_list_set_elt_method, t_list_set_elt;
    }
    always { set_list_elt_method, t_list_elt; }
}
// endregion