Switch arguments from OCamlRooted to &OCamlRooted

Author: tizoc

src/lib.rs

@@ -356,12 +356,12 @@
 //! ocaml_export! {
 //!     // The first parameter is a name to which the GC frame handle will be bound to.
 //!     // The remaining parameters and return value must have a declared type of `OCaml<T>`.
-//!     fn rust_twice(cr, num: OCamlRooted<OCamlInt>) -> OCaml<OCamlInt> {
+//!     fn rust_twice(cr, num: &OCamlRooted<OCamlInt>) -> OCaml<OCamlInt> {
 //!         let num: i64 = num.to_rust(cr);
 //!         unsafe { OCaml::of_i64_unchecked(num * 2) }
 //!     }
 //!
-//!     fn rust_increment_bytes(cr, bytes: OCamlRooted<OCamlBytes>, first_n: OCamlRooted<OCamlInt>) -> OCaml<OCamlBytes> {
+//!     fn rust_increment_bytes(cr, bytes: &OCamlRooted<OCamlBytes>, first_n: &OCamlRooted<OCamlInt>) -> OCaml<OCamlBytes> {
 //!         let first_n: i64 = first_n.to_rust(cr);
 //!         let first_n = first_n as usize;
 //!         let mut vec: Vec<u8> = bytes.to_rust(cr);

src/macros.rs

@@ -162,12 +162,12 @@ macro_rules! ocaml {
 /// ```
 /// # use ocaml_interop::*;
 /// ocaml_export! {
-///     fn rust_twice(cr, num: OCamlRooted<OCamlInt>) -> OCaml<OCamlInt> {
+///     fn rust_twice(cr, num: &OCamlRooted<OCamlInt>) -> OCaml<OCamlInt> {
 ///         let num: i64 = num.to_rust(cr);
 ///         unsafe { OCaml::of_i64_unchecked(num * 2) }
 ///     }
 ///
-///     fn rust_twice_boxed_i32(cr, num: OCamlRooted<OCamlInt32>) -> OCaml<OCamlInt32> {
+///     fn rust_twice_boxed_i32(cr, num: &OCamlRooted<OCamlInt32>) -> OCaml<OCamlInt32> {
 ///         let num: i32 = num.to_rust(cr);
 ///         let result = num * 2;
 ///         ocaml_alloc!(result.to_ocaml(cr))
@@ -177,13 +177,13 @@ macro_rules! ocaml {
 ///         num * num2
 ///     }
 ///
-///     fn rust_twice_boxed_float(cr, num: OCamlRooted<OCamlFloat>) -> OCaml<OCamlFloat> {
+///     fn rust_twice_boxed_float(cr, num: &OCamlRooted<OCamlFloat>) -> OCaml<OCamlFloat> {
 ///         let num: f64 = num.to_rust(cr);
 ///         let result = num * 2.0;
 ///         ocaml_alloc!(result.to_ocaml(cr))
 ///     }
 ///
-///     fn rust_increment_ints_list(cr, ints: OCamlRooted<OCamlList<OCamlInt>>) -> OCaml<OCamlList<OCamlInt>> {
+///     fn rust_increment_ints_list(cr, ints: &OCamlRooted<OCamlList<OCamlInt>>) -> OCaml<OCamlList<OCamlInt>> {
 ///         let mut vec: Vec<i64> = ints.to_rust(cr);
 ///
 ///         for i in 0..vec.len() {
@@ -193,7 +193,7 @@ macro_rules! ocaml {
 ///         ocaml_alloc!(vec.to_ocaml(cr))
 ///     }
 ///
-///     fn rust_make_tuple(cr, fst: OCamlRooted<String>, snd: OCamlRooted<OCamlInt>) -> OCaml<(String, OCamlInt)> {
+///     fn rust_make_tuple(cr, fst: &OCamlRooted<String>, snd: &OCamlRooted<OCamlInt>) -> OCaml<(String, OCamlInt)> {
 ///         let fst: String = fst.to_rust(cr);
 ///         let snd: i64 = snd.to_rust(cr);
 ///         let tuple = (fst, snd);
@@ -1292,10 +1292,10 @@ macro_rules! expand_rooted_args_init {
 
     // Other values are wrapped in `OCamlRooted<T>` as given the same lifetime as the OCaml runtime handle borrow.
     (($root:ident), $arg:ident : $typ:ty) =>
-        (let $arg : $typ = unsafe { $root.keep_raw($arg) };);
+        (let $arg : $typ = unsafe { &$root.keep_raw($arg) };);
 
     (($root:ident $($roots:ident)*), $arg:ident : $typ:ty, $($args:tt)*) => {
-        let $arg : $typ = unsafe { $root.keep_raw($arg) };
+        let $arg : $typ = unsafe { &$root.keep_raw($arg) };
         $crate::expand_rooted_args_init!(($($roots)*), $($args)*)
     };
 }

testing/ocaml-caller/rust/src/lib.rs

@@ -21,18 +21,18 @@ enum PolymorphicMovement {
 }
 
 ocaml_export! {
-    fn rust_twice(cr, num: OCamlRooted<OCamlInt>) -> OCaml<OCamlInt> {
+    fn rust_twice(cr, num: &OCamlRooted<OCamlInt>) -> OCaml<OCamlInt> {
         let num: i64 = num.to_rust(cr);
         unsafe { OCaml::of_i64_unchecked(num * 2) }
     }
 
-    fn rust_twice_boxed_i64(cr, num: OCamlRooted<OCamlInt64>) -> OCaml<OCamlInt64> {
+    fn rust_twice_boxed_i64(cr, num: &OCamlRooted<OCamlInt64>) -> OCaml<OCamlInt64> {
         let num: i64 = num.to_rust(cr);
         let result = num * 2;
         result.to_ocaml(cr)
     }
 
-    fn rust_twice_boxed_i32(cr, num: OCamlRooted<OCamlInt32>) -> OCaml<OCamlInt32> {
+    fn rust_twice_boxed_i32(cr, num: &OCamlRooted<OCamlInt32>) -> OCaml<OCamlInt32> {
         let num: i32 = num.to_rust(cr);
         let result = num * 2;
         result.to_ocaml(cr)
@@ -42,7 +42,7 @@ ocaml_export! {
         num * num2
     }
 
-    fn rust_twice_boxed_float(cr, num: OCamlRooted<OCamlFloat>) -> OCaml<OCamlFloat> {
+    fn rust_twice_boxed_float(cr, num: &OCamlRooted<OCamlFloat>) -> OCaml<OCamlFloat> {
         let num: f64 = num.to_rust(cr);
         let result = num * 2.0;
         result.to_ocaml(cr)
@@ -52,7 +52,7 @@ ocaml_export! {
         num * 2.0
     }
 
-    fn rust_increment_bytes(cr, bytes: OCamlRooted<OCamlBytes>, first_n: OCamlRooted<OCamlInt>) -> OCaml<OCamlBytes> {
+    fn rust_increment_bytes(cr, bytes: &OCamlRooted<OCamlBytes>, first_n: &OCamlRooted<OCamlInt>) -> OCaml<OCamlBytes> {
         let first_n: i64 = first_n.to_rust(cr);
         let first_n = first_n as usize;
         let mut vec: Vec<u8> = bytes.to_rust(cr);
@@ -64,7 +64,7 @@ ocaml_export! {
         vec.to_ocaml(cr)
     }
 
-    fn rust_increment_ints_list(cr, ints: OCamlRooted<OCamlList<OCamlInt>>) -> OCaml<OCamlList<OCamlInt>> {
+    fn rust_increment_ints_list(cr, ints: &OCamlRooted<OCamlList<OCamlInt>>) -> OCaml<OCamlList<OCamlInt>> {
         let mut vec: Vec<i64> = ints.to_rust(cr);
 
         for i in 0..vec.len() {
@@ -74,45 +74,45 @@ ocaml_export! {
         vec.to_ocaml(cr)
     }
 
-    fn rust_make_tuple(cr, fst: OCamlRooted<String>, snd: OCamlRooted<OCamlInt>) -> OCaml<(String, OCamlInt)> {
+    fn rust_make_tuple(cr, fst: &OCamlRooted<String>, snd: &OCamlRooted<OCamlInt>) -> OCaml<(String, OCamlInt)> {
         let fst: String = fst.to_rust(cr);
         let snd: i64 = snd.to_rust(cr);
         let tuple = (fst, snd);
         tuple.to_ocaml(cr)
     }
 
-    fn rust_make_some(cr, value: OCamlRooted<String>) -> OCaml<Option<String>> {
+    fn rust_make_some(cr, value: &OCamlRooted<String>) -> OCaml<Option<String>> {
         let value: String = value.to_rust(cr);
         let some_value = Some(value);
         some_value.to_ocaml(cr)
     }
 
-    fn rust_make_ok(cr, value: OCamlRooted<OCamlInt>) -> OCaml<Result<OCamlInt, String>> {
+    fn rust_make_ok(cr, value: &OCamlRooted<OCamlInt>) -> OCaml<Result<OCamlInt, String>> {
         let value: i64 = value.to_rust(cr);
         let ok_value: Result<i64, String> = Ok(value);
         to_ocaml!(cr, ok_value)
     }
 
-    fn rust_make_error(cr, value: OCamlRooted<String>) -> OCaml<Result<OCamlInt, String>> {
+    fn rust_make_error(cr, value: &OCamlRooted<String>) -> OCaml<Result<OCamlInt, String>> {
         let value: String = value.to_rust(cr);
         let error_value: Result<i64, String> = Err(value);
         to_ocaml!(cr, error_value)
     }
 
-    fn rust_sleep_releasing(cr, millis: OCamlRooted<OCamlInt>) {
+    fn rust_sleep_releasing(cr, millis: &OCamlRooted<OCamlInt>) {
         let millis: i64 = millis.to_rust(cr);
         cr.releasing_runtime(|| thread::sleep(time::Duration::from_millis(millis as u64)));
         OCaml::unit()
     }
 
-    fn rust_sleep(cr, millis: OCamlRooted<OCamlInt>) {
+    fn rust_sleep(cr, millis: &OCamlRooted<OCamlInt>) {
         let millis: i64 = millis.to_rust(cr);
         thread::sleep(time::Duration::from_millis(millis as u64));
         OCaml::unit()
     }
 
-    fn rust_string_of_movement(cr, movement: OCamlRooted<PolymorphicMovement>) -> OCaml<String> {
-        let movement = cr.get(&movement);
+    fn rust_string_of_movement(cr, movement: &OCamlRooted<PolymorphicMovement>) -> OCaml<String> {
+        let movement = cr.get(movement);
         let pm = ocaml_unpack_variant! {
             movement => {
                 Step(count: OCamlInt) => { Movement::Step {count} },
@@ -129,8 +129,8 @@ ocaml_export! {
         to_ocaml!(cr, s)
     }
 
-    fn rust_string_of_polymorphic_movement(cr, polymorphic_movement: OCamlRooted<PolymorphicMovement>) -> OCaml<String> {
-        let polymorphic_movement = cr.get(&polymorphic_movement);
+    fn rust_string_of_polymorphic_movement(cr, polymorphic_movement: &OCamlRooted<PolymorphicMovement>) -> OCaml<String> {
+        let polymorphic_movement = cr.get(polymorphic_movement);
         let pm = ocaml_unpack_polymorphic_variant! {
             polymorphic_movement => {
                 Step(count: OCamlInt) => { PolymorphicMovement::Step {count} },