ALTRAW (#276)

CHANGELOG.md

@@ -3,6 +3,14 @@
 <!-- next-header -->
 ## [Unreleased] (ReleaseDate)
 
+### New features
+
+* Add support for raw, including ALTRAW.  
+  Please be aware that, while this support was added for consistency, I bet it's
+  really rare that a raw vector is actually needed; if you want to deal with a
+  binary data on Rust's side, your primary option should be to store it in an
+  external pointer (of a struct you define) rather than an R's raw vector.
+
 ### Minor Improvements
 
 * Wrapper environment of a Rust struct or enum now cannot be modified by users.

R-package/R/000-wrappers.R

@@ -210,6 +210,21 @@ NULL
 }
 
 
+`altraw` <- function() {
+  .Call(savvy_altraw__impl)
+}
+
+
+`print_altraw` <- function(`x`) {
+  invisible(.Call(savvy_print_altraw__impl, `x`))
+}
+
+
+`tweak_altraw` <- function(`x`) {
+  invisible(.Call(savvy_tweak_altraw__impl, `x`))
+}
+
+
 `altstring` <- function() {
   .Call(savvy_altstring__impl)
 }

R-package/src/init.c

@@ -174,6 +174,21 @@ SEXP savvy_tweak_altlogical__impl(SEXP x) {
     return handle_result(res);
 }
 
+SEXP savvy_altraw__impl(void) {
+    SEXP res = savvy_altraw__ffi();
+    return handle_result(res);
+}
+
+SEXP savvy_print_altraw__impl(SEXP x) {
+    SEXP res = savvy_print_altraw__ffi(x);
+    return handle_result(res);
+}
+
+SEXP savvy_tweak_altraw__impl(SEXP x) {
+    SEXP res = savvy_tweak_altraw__ffi(x);
+    return handle_result(res);
+}
+
 SEXP savvy_altstring__impl(void) {
     SEXP res = savvy_altstring__ffi();
     return handle_result(res);
@@ -714,6 +729,9 @@ static const R_CallMethodDef CallEntries[] = {
     {"savvy_altlogical__impl", (DL_FUNC) &savvy_altlogical__impl, 0},
     {"savvy_print_altlogical__impl", (DL_FUNC) &savvy_print_altlogical__impl, 1},
     {"savvy_tweak_altlogical__impl", (DL_FUNC) &savvy_tweak_altlogical__impl, 1},
+    {"savvy_altraw__impl", (DL_FUNC) &savvy_altraw__impl, 0},
+    {"savvy_print_altraw__impl", (DL_FUNC) &savvy_print_altraw__impl, 1},
+    {"savvy_tweak_altraw__impl", (DL_FUNC) &savvy_tweak_altraw__impl, 1},
     {"savvy_altstring__impl", (DL_FUNC) &savvy_altstring__impl, 0},
     {"savvy_print_altstring__impl", (DL_FUNC) &savvy_print_altstring__impl, 1},
     {"savvy_tweak_altstring__impl", (DL_FUNC) &savvy_tweak_altstring__impl, 1},

R-package/src/rust/api.h

@@ -26,6 +26,9 @@ SEXP savvy_tweak_altreal__ffi(SEXP x);
 SEXP savvy_altlogical__ffi(void);
 SEXP savvy_print_altlogical__ffi(SEXP x);
 SEXP savvy_tweak_altlogical__ffi(SEXP x);
+SEXP savvy_altraw__ffi(void);
+SEXP savvy_print_altraw__ffi(SEXP x);
+SEXP savvy_tweak_altraw__ffi(SEXP x);
 SEXP savvy_altstring__ffi(void);
 SEXP savvy_print_altstring__ffi(SEXP x);
 SEXP savvy_tweak_altstring__ffi(SEXP x);

R-package/src/rust/src/altrep.rs

@@ -1,10 +1,10 @@
 use savvy::altrep::{
     get_altrep_body_ref_unchecked, register_altinteger_class, register_altlist_class,
-    register_altlogical_class, register_altreal_class, register_altstring_class, AltInteger,
-    AltList, AltLogical, AltReal, AltString,
+    register_altlogical_class, register_altraw_class, register_altreal_class,
+    register_altstring_class, AltInteger, AltList, AltLogical, AltRaw, AltReal, AltString,
 };
 use savvy::{
-    r_println, savvy, savvy_init, IntegerSexp, ListSexp, LogicalSexp, NullSexp, RealSexp,
+    r_println, savvy, savvy_init, IntegerSexp, ListSexp, LogicalSexp, NullSexp, RawSexp, RealSexp,
     StringSexp,
 };
 
@@ -173,6 +173,61 @@ fn tweak_altlogical(mut x: LogicalSexp) -> savvy::Result<()> {
     Err("Not a known ALTREP".into())
 }
 
+// raw
+
+#[derive(Debug, Clone)]
+struct MyAltRaw(Vec<u8>);
+
+impl MyAltRaw {
+    fn new(x: Vec<u8>) -> Self {
+        Self(x)
+    }
+}
+
+impl savvy::IntoExtPtrSexp for MyAltRaw {}
+
+impl AltRaw for MyAltRaw {
+    const CLASS_NAME: &'static str = "MyAltRaw";
+    const PACKAGE_NAME: &'static str = "TestPackage";
+
+    fn length(&mut self) -> usize {
+        self.0.len()
+    }
+
+    fn elt(&mut self, i: usize) -> u8 {
+        self.0[i]
+    }
+}
+
+#[savvy]
+fn altraw() -> savvy::Result<savvy::Sexp> {
+    let v = MyAltRaw::new(vec![1u8, 2, 3]);
+    v.into_altrep()
+}
+
+#[savvy]
+fn print_altraw(x: RawSexp) -> savvy::Result<()> {
+    if let Ok(x) = MyAltRaw::try_from_altrep_ref(&x) {
+        r_println!("{x:?}");
+        return Ok(());
+    };
+
+    Err("Not a known ALTREP".into())
+}
+
+#[savvy]
+fn tweak_altraw(mut x: RawSexp) -> savvy::Result<()> {
+    if let Ok(x) = MyAltRaw::try_from_altrep_mut(&mut x, true) {
+        for i in x.0.iter_mut() {
+            *i += 1;
+        }
+        x.0.push(2);
+        return Ok(());
+    };
+
+    Err("Not a known ALTREP".into())
+}
+
 // string
 
 #[derive(Debug, Clone)]
@@ -311,6 +366,7 @@ fn init_altrep_class(dll_info: *mut savvy::ffi::DllInfo) -> savvy::Result<()> {
     register_altinteger_class::<MyAltInt>(dll_info)?;
     register_altreal_class::<MyAltReal>(dll_info)?;
     register_altlogical_class::<MyAltLogical>(dll_info)?;
+    register_altraw_class::<MyAltRaw>(dll_info)?;
     register_altstring_class::<MyAltString>(dll_info)?;
     register_altlist_class::<MyAltList>(dll_info)?;
     Ok(())

R-package/tests/testthat/test-altrep.R

@@ -65,6 +65,28 @@ test_that("altlogical works", {
   expect_equal(x, c(NA, TRUE, FALSE, FALSE))
 })
 
+test_that("altraw works", {
+  x <- altraw()
+
+  expect_equal(x[1], as.raw(1L)) # ELT method
+  expect_equal(length(x), 3L) # length method
+  expect_equal(as.character(x), c("01", "02", "03")) # coerce method
+  expect_equal(x, as.raw(1:3))
+
+  # after the first materialization, the values reflect to R's side if invalidate_cache = TRUE
+  tweak_altraw(x)
+  expect_output(print_altraw(x), "MyAltRaw([2, 3, 4, 2])", fixed = TRUE)
+
+  expect_equal(x[1], as.raw(2L)) # ELT method
+  expect_equal(length(x), 4L) # length method
+  expect_equal(as.character(x), c("02", "03", "04", "02")) # coerce method
+  expect_equal(x, as.raw(c(2L, 3L, 4L, 2L)))
+
+  # duplicate method? dataptr method? I'm not sure
+  x[1] <- as.raw(100L)
+  expect_equal(x, as.raw(c(100L, 3L, 4L, 2L)))
+})
+
 test_that("altstring works", {
   x <- altstring()
 

savvy-ffi/src/altrep.rs

@@ -130,7 +130,7 @@ extern "C" {
     );
 }
 
-// Real
+// real
 
 extern "C" {
     pub fn R_make_altreal_class(
@@ -212,6 +212,30 @@ extern "C" {
     );
 }
 
+// raw
+extern "C" {
+    pub fn R_make_altraw_class(
+        cname: *const c_char,
+        pname: *const c_char,
+        info: *mut crate::DllInfo,
+    ) -> R_altrep_class_t;
+    pub fn R_set_altraw_Elt_method(
+        cls: R_altrep_class_t,
+        fun: Option<unsafe extern "C" fn(arg1: SEXP, arg2: R_xlen_t) -> u8>,
+    );
+    pub fn R_set_altraw_Get_region_method(
+        cls: R_altrep_class_t,
+        fun: Option<
+            unsafe extern "C" fn(
+                arg1: SEXP,
+                arg2: R_xlen_t,
+                arg3: R_xlen_t,
+                arg4: *mut u8,
+            ) -> R_xlen_t,
+        >,
+    );
+}
+
 // string
 
 extern "C" {