What are the steps necessary to pass R objects to a Rust program?

Question

Both R and Rust can interface with C code, so I think it is very possible. I am a bit unclear about how to proceed, however.

I have read these sections looking for answers:

But while I am well-versed in R I am not a systems programmer and confused by what the build-chain looks like for such an endeavor.

Using Rinternals.h would be ideal, but I would settle for the simpler .C interface as well.

Potentially useful - [R from C — Simplest Possible Helloworld](http://stackoverflow.com/questions/2463437/r-from-c-simplest-possible-helloworld) — Shepmaster, Mar 06 '15 at 14:47
Do you want to call R from Rust, or Rust from R? If you the latter, look at `.Call()` rather than `.C()` which nobody should use anymore. Rcpp may help you with an intermediate layer. — Dirk Eddelbuettel, Mar 06 '15 at 15:56
I would like to call Rust code from within R and use Rust libraries on objects in my R session. — Zelazny7, Mar 06 '15 at 16:10
The you should be able to (easily) go from R to C++ via Rcpp. At that point the answer by @swizard becomes usable as is. If you are interested, we could cook up a little demo up as an example in the [Rcpp Gallery](http://gallery.rcpp.org) -- as there is eg one of [embedding Python via Boost](http://gallery.rcpp.org/articles/rcpp-python/). — Dirk Eddelbuettel, Mar 06 '15 at 20:34

score 10 · Answer 1 · edited Sep 03 '16 at 15:43

I have been struggling on this for a while as well, but once you know how I'ts actually not that difficult.

First create a Rust library following these instructions: rust-inside-other-languages. Here is an example Rust library:

//src/lib.rs

#[no_mangle]
pub fn kelvin_to_fahrenheit(n: f64) -> f64 {
    n * 9.0/5.0 - 459.67
}

If you follow the instructions in rust-inside-other-languages, then you should be able to generate a *.so (or *.dll or .dylib, depending on your system). Let's presume this compiled file is called libtempr.so.

Now create a C++ file which will pass the functions you need to R:

//embed.cpp

extern "C" {
    double kelvin_to_fahrenheit(double);
}

// [[Rcpp::export]]
double cpp_kelvin_to_fahrenheit(double k) {
  double f = kelvin_to_fahrenheit(k);
  return(f);
}

Now before starting R, make sure the environment variable LD_LIBRARY_PATH contains the directory where the shared object generated previously (libtempr.so) is stored. In the shell do:

$ export LD_LIBRARY_PATH=/home/sam/path/to/shared/object:$LD_LIBRARY_PATH
$ rstudio # I highly recommend using Rstudio for your R coding

Finally in Rstudo, write this file:

library(Rcpp)

Sys.setenv("PKG_LIBS"="-L/home/sam/path/to/shared/object -ltempr")

sourceCpp("/home/sam/path/to/embed.cpp", verbose = T, rebuild = T)

cpp_kelvin_to_fahrenheit(300)

Be careful that in Sys.setenv the -L option points to the directory containing your Rust shared object.
Also be careful that -l option is the name of your shared object without the lib prefix and without the .so (or whatever it is on your system) postfix.
Using Sys.setenv in R to set the LD_LIBRARY_PATH variable DOES NOT WORK. Export the variable before starting R.
The verbose option is there so that you can see what Rcpp does to compile your C++ file. Notice how the options in PKG_LIBS above are used for compiling your C++ file.
The rebuild options is there to force a rebuild of the C++ file every time you run this line of R code.

If you did everything well, then run the R file above in the interactive console and it should output 80.33 when you reach the last line.

If anything is not clear, ask in the comments, and I'll try to improve my answer.

Hope it helped :)

Final note, the base functions dyn.load and .C can be used as an alternative approach. But this requires writing a lot more boilerplate wrapper code than this approach.

score 2 · Accepted Answer · answered Mar 06 '15 at 17:13

If R can interface with C code, so it is no problem at all to compile shared library from Rust code which exposes C-style functions.

Then you can easily use your library as it was written in C or C++. Of course, you will not able to use Rust object and libraries directly from R, you will have to make appropriate C interface for converting their functions.

Here is how can I do that for SBCL, and I suppose it would be very similar for R:

On Rust side

Some code:

% cat experiment.rs

extern crate libc;

use libc::{c_int, c_char};
use std::{ffi, str};

#[no_mangle]
pub extern fn rust_code_string_to_int(s: *const c_char, r: *mut c_int) -> c_int { 
    let string = String::from_utf8_lossy(unsafe { ffi::CStr::from_ptr(s).to_bytes() });
    match <isize as str::FromStr>::from_str(&*string) {
        Ok(value) => { unsafe { *r = value as c_int }; 0 },
        Err(_) => -1,
    }
}

Then I'm making shared lib:

% rustc --crate-type dylib experiment.rs
% nm -a libexperiment.dylib | grep rust_code_string_to_int
0000000000001630 t __ZN23rust_code_string_to_int10__rust_abiE
00000000000015e0 T _rust_code_string_to_int

Next, on SBCL side

Now I'm just loading my shared lib and then I have access to my rust_code_string_to_int function:

RUST> (sb-alien:load-shared-object "libexperiment.dylib")
#P"libexperiment.dylib"
RUST> (sb-alien:with-alien ((result sb-alien:int 0))  
          (values (sb-alien:alien-funcall (sb-alien:extern-alien "rust_code_string_to_int" 
                                                                 (sb-alien:function sb-alien:int 
                                                                                    (sb-alien:c-string :external-format :utf-8)
                                                                                    (sb-alien:* sb-alien:int)))
                                          (sb-alien:make-alien-string "42")
                                          (sb-alien:addr result))
                  result))
0
42

What are the steps necessary to pass R objects to a Rust program?

2 Answers2

On Rust side

Next, on SBCL side

Linked