Merge branch 'main' into fix_binary_op_literals

R/extendr-wrappers.R

@@ -33,8 +33,6 @@ coalesce_exprs <- function(exprs) .Call(wrap__coalesce_exprs, exprs)
 
 sum_exprs <- function(exprs) .Call(wrap__sum_exprs, exprs)
 
-mem_address <- function(robj) .Call(wrap__mem_address, robj)
-
 concat_list <- function(exprs) .Call(wrap__concat_list, exprs)
 
 r_date_range <- function(start, stop, every, closed, name, tu, tz) .Call(wrap__r_date_range, start, stop, every, closed, name, tu, tz)
@@ -53,6 +51,10 @@ dtype_str_repr <- function(dtype) .Call(wrap__dtype_str_repr, dtype)
 
 internal_wrap_e <- function(robj, str_to_lit) .Call(wrap__internal_wrap_e, robj, str_to_lit)
 
+mem_address <- function(robj) .Call(wrap__mem_address, robj)
+
+clone_robj <- function(robj) .Call(wrap__clone_robj, robj)
+
 test_robj_to_usize <- function(robj) .Call(wrap__test_robj_to_usize, robj)
 
 test_robj_to_i64 <- function(robj) .Call(wrap__test_robj_to_i64, robj)

src/rust/src/rlib.rs

@@ -56,13 +56,6 @@ pub fn hor_concat_df(dfs: &VecDataFrame) -> List {
     r_result_list(df.map_err(|err| format!("{:?}", err)))
 }
 
-#[extendr]
-pub fn mem_address(robj: Robj) -> String {
-    let ptr_raw = unsafe { robj.external_ptr_addr::<usize>() };
-    let ptr_val = ptr_raw as usize;
-    format!("{:#012x}", ptr_val)
-}
-
 #[extendr]
 fn min_exprs(exprs: &ProtoExprArray) -> Expr {
     let exprs = exprs.to_vec("select");
@@ -235,40 +228,20 @@ fn internal_wrap_e(robj: Robj, str_to_lit: Robj) -> RResult<Expr> {
     }
 }
 
-// replaces wrap_e_legacy, derived from robj_to!
+// -- Meta Robj functions
+#[extendr]
+pub fn mem_address(robj: Robj) -> String {
+    let ptr_raw = unsafe { robj.external_ptr_addr::<usize>() };
+    let ptr_val = ptr_raw as usize;
+    format!("{:#012x}", ptr_val)
+}
 
-// pub fn series_from_arrow(name: &str, array: Robj) -> Result<Series, String> {
-//     use polars::prelude::IntoSeries;
-//     let arr = crate::arrow_interop::to_rust::arrow_array_to_rust(array)?;
-
-//     match arr.data_type() {
-//         pl::ArrowDataType::LargeList(_) => {
-//             let array = arr.as_any().downcast_ref::<pl::LargeListArray>().unwrap();
-
-//             let mut previous = 0;
-//             let mut fast_explode = true;
-//             for &o in array.offsets().as_slice()[1..].iter() {
-//                 if o == previous {
-//                     fast_explode = false;
-//                     break;
-//                 }
-//                 previous = o;
-//             }
-//             let mut out = unsafe { pl::ListChunked::from_chunks(name, vec![arr]) };
-//             if fast_explode {
-//                 out.set_fast_explode()
-//             }
-//             Ok(Series(out.into_series()))
-//         }
-//         _ => {
-//             let res_series: pl::PolarsResult<pl::Series> =
-//                 std::convert::TryFrom::try_from((name, arr));
-//             let series = res_series.map_err(|err| err.to_string())?;
-//             Ok(Series(series))
-//         }
-//     }
-// }
+#[extendr] //could be used to check copying/cloning behavior of R objects
+pub fn clone_robj(robj: Robj) -> Robj {
+    robj.clone()
+}
 
+// -- Special functions just for unit testing
 #[extendr]
 fn test_robj_to_usize(robj: Robj) -> RResult<String> {
     robj_to!(usize, robj).map(rdbg)
@@ -302,7 +275,7 @@ extendr_module! {
     fn max_exprs;
     fn coalesce_exprs;
     fn sum_exprs;
-    fn mem_address;
+
     fn concat_list;
     fn r_date_range;
     fn r_date_range_lazy;
@@ -316,7 +289,9 @@ extendr_module! {
     fn dtype_str_repr;
 
     fn internal_wrap_e;
-
+    fn mem_address;
+    fn clone_robj;
+
     fn test_robj_to_usize;
     fn test_robj_to_i64;
     fn test_robj_to_u32;

tests/testthat/test-extendr-meta.R

@@ -0,0 +1,18 @@
+test_that("clone_robj + mem_adress", {
+
+  # clone mutable
+  env  = new.env(parent = emptyenv())
+  env2 = clone_robj(env)
+  env$foo = 42
+  expect_identical(env,env2)
+  expect_identical(pl$mem_address(env), pl$mem_address(env2))
+
+  # clone immutable, not the same
+  l = list()
+  l2 = clone_robj(l)
+  l$foo = 42
+  expect_identical(l,list(foo = 42))
+  expect_identical(l2,list())
+  expect_false(pl$mem_address(l) == pl$mem_address(l2))
+
+})