Current state

rustler/src/lib.rs

@@ -36,16 +36,14 @@ pub mod types;
 
 mod term;
 mod wrapped_types;
-pub use crate::wrapped_types::{
-    ListIterator, Map
-};
 
 pub use crate::term::Term;
 pub use crate::types::{
-    Atom, Binary, Decoder, Encoder, ErlOption, LocalPid, MapIterator, NewBinary,
-    OwnedBinary, Reference,
+    Atom, Binary, Decoder, Encoder, ErlOption, LocalPid, NewBinary, OwnedBinary
 };
 
+pub use crate::wrapped_types::{ListIterator, Reference, MapIterator, Map, Tuple};
+
 #[cfg(feature = "big_integer")]
 pub use crate::types::BigInt;
 

rustler/src/types/elixir_struct.rs

@@ -8,8 +8,7 @@
 //! `#[module = "Elixir.TheStructModule"]`.
 
 use super::atom::{self, Atom};
-use super::map::Map;
-use crate::{Env, Error, NifResult, Term};
+use crate::{Env, Error, Map, NifResult, Term};
 
 pub fn get_ex_struct_name(map: Term) -> NifResult<Atom> {
     // In an Elixir struct the value in the __struct__ field is always an atom.

rustler/src/types/mod.rs

@@ -1,8 +1,6 @@
+use crate::wrapped_types::MapIterator;
 use crate::{Env, Error, NifResult, Term};
 
-#[macro_use]
-mod wrapper;
-
 #[macro_use]
 pub mod atom;
 pub use crate::types::atom::Atom;
@@ -15,28 +13,15 @@ pub mod big_int;
 #[cfg(feature = "big_integer")]
 pub use num_bigint::BigInt;
 
-#[doc(hidden)]
-pub mod list;
-pub use crate::types::list::ListIterator;
-
-#[doc(hidden)]
-pub mod map;
-pub use self::map::MapIterator;
-
 #[doc(hidden)]
 pub mod primitive;
 #[doc(hidden)]
 pub mod string;
-pub mod tuple;
 
 #[doc(hidden)]
 pub mod local_pid;
 pub use self::local_pid::LocalPid;
 
-#[doc(hidden)]
-pub mod reference;
-pub use self::reference::Reference;
-
 pub mod i128;
 pub mod path;
 

rustler/src/wrapped_types/map.rs

@@ -1,12 +1,14 @@
 //! Utilities used to access and create Erlang maps.
 
-use super::atom;
 use crate::sys::{enif_get_map_value, enif_make_map_put, enif_make_new_map};
+use crate::types::atom;
 use crate::wrapper::map;
 use crate::{Decoder, Encoder, Env, Error, NifResult, Term, TermType};
 use std::mem::MaybeUninit;
 use std::ops::RangeInclusive;
 
+use super::wrapper;
+
 wrapper!(
     /// A wrapper around an Erlang map term.
     struct Map(TermType::Map)

rustler/src/wrapped_types/mod.rs

@@ -1,7 +1,13 @@
 mod list;
 mod map;
-mod tuple;
-mod wrapper;
+mod reference;
+pub mod tuple;
+pub mod wrapper;
+
+pub use list::ListIterator;
+pub use map::{Map, MapIterator};
+pub use reference::Reference;
+pub use tuple::Tuple;
 
 pub(crate) use wrapper::wrapper;
-pub(crate) use list::ListIterator;
+pub(crate) use wrapper::Wrapper;

rustler/src/types/reference.rs → rustler/src/wrapped_types/reference.rs

@@ -2,6 +2,8 @@ use crate::{Env, Term, TermType};
 
 use crate::sys::enif_make_ref;
 
+use super::wrapper;
+
 wrapper!{
     struct Reference(TermType::Ref)
 }

rustler/src/wrapped_types/tuple.rs

@@ -1,9 +1,10 @@
-use crate::{
-    sys::{enif_get_tuple, ERL_NIF_TERM},
-    Decoder, Encoder, Env, Error, NifResult, Term, TermType,
-};
+use crate::{Decoder, Encoder, Env, Error, NifResult, Term, TermType};
+use crate::sys::{enif_get_tuple, enif_make_tuple_from_array, ERL_NIF_TERM};
 
-use std::{ffi::c_int, mem::MaybeUninit, ops::Index};
+use std::ffi::c_int;
+use std::mem::MaybeUninit;
+
+use super::wrapper;
 wrapper!(
     struct Tuple(TermType::Tuple)
 );
@@ -33,7 +34,7 @@ impl<'a> Tuple<'a> {
     pub fn get(&self, index: usize) -> Option<Term<'a>> {
         self.get_elements()
             .get(index)
-            .map(|ptr| unsafe { Term::new(self.get_env(), ptr) })
+            .map(|ptr| unsafe { Term::new(self.get_env(), *ptr) })
     }
 
     /// Convert an Erlang tuple to a Rust vector. (To convert to a Rust tuple, use `term.decode()`
@@ -56,8 +57,13 @@ impl<'a> Tuple<'a> {
 /// Convert a vector of terms to an Erlang tuple. (To convert from a Rust tuple to an Erlang tuple,
 /// use `Encoder` instead.)
 pub fn make_tuple<'a>(env: Env<'a>, terms: &[Term]) -> Term<'a> {
-    let c_terms: Vec<NIF_TERM> = terms.iter().map(|term| term.as_c_arg()).collect();
-    unsafe { Term::new(env, tuple::make_tuple(env.as_c_arg(), &c_terms)) }
+    let c_terms: Vec<ERL_NIF_TERM> = terms.iter().map(|term| term.as_c_arg()).collect();
+    unsafe {
+        let term =
+            enif_make_tuple_from_array(env.as_c_arg(), c_terms.as_ptr(), c_terms.len() as u32);
+        Term::new(env, term)
+    }
+    // unsafe { Term::new(env, tuple::make_tuple(env.as_c_arg(), &c_terms)) }
 }
 
 /// Helper macro to emit tuple-like syntax. Wraps its arguments in parentheses, and adds a comma if
@@ -83,10 +89,8 @@ macro_rules! impl_nifencoder_nifdecoder_for_tuple {
             Encoder for tuple!( $( $tyvar ),* )
         {
             fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
-                let arr = [ $( Encoder::encode(&self.$index, env).as_c_arg() ),* ];
-                unsafe {
-                    Term::new(env, tuple::make_tuple(env.as_c_arg(), &arr))
-                }
+                let arr = [ $( Encoder::encode(&self.$index, env) ),* ];
+                make_tuple(env, &arr)
             }
         }
 
@@ -95,7 +99,7 @@ macro_rules! impl_nifencoder_nifdecoder_for_tuple {
         {
             fn decode(term: Term<'a>) -> NifResult<tuple!( $( $tyvar ),* )>
             {
-                match unsafe { tuple::get_tuple(term.get_env().as_c_arg(), term.as_c_arg()) } {
+                match unsafe { get_tuple(term) } {
                     Ok(elements) if elements.len() == count!( $( $index ),* ) =>
                         Ok(tuple!( $(
                             (<$tyvar as Decoder>::decode(

rustler/src/wrapped_types/wrapper.rs

@@ -46,7 +46,7 @@ macro_rules! wrapper {
         #[derive(PartialEq, Eq, Clone, Copy)]
         pub struct $name<'a>(Term<'a>);
 
-        use $crate::types::wrapper::Wrapper;
+        use $crate::wrapped_types::Wrapper;
 
         impl<'a> $name<'a> {
             /// Returns a representation of self in the given Env.
@@ -83,14 +83,14 @@ macro_rules! wrapper {
             type Error = $crate::Error;
 
             fn try_from(term: Term<'a>) -> Result<Self, Self::Error> {
-                use $crate::types::wrapper::Wrapper;
+                use $crate::wrapped_types::Wrapper;
                 Self::wrap(term).or(Err($crate::Error::BadArg))
             }
         }
 
         impl<'a> $crate::Decoder<'a> for $name<'a> {
             fn decode(term: Term<'a>) -> $crate::NifResult<Self> {
-                use $crate::types::wrapper::Wrapper;
+                use $crate::wrapped_types::Wrapper;
                 Self::wrap(term).or(Err($crate::Error::BadArg))
             }
         }

rustler/src/wrapper/tuple.rs

@@ -1,6 +1,5 @@
 use crate::sys::enif_make_tuple_from_array;
-use crate::wrapper::{c_int, NIF_ENV, NIF_ERROR, NIF_TERM};
-use std::mem::MaybeUninit;
+use crate::wrapper::{NIF_ENV, NIF_TERM};
 
 pub unsafe fn make_tuple(env: NIF_ENV, terms: &[NIF_TERM]) -> NIF_TERM {
     enif_make_tuple_from_array(env, terms.as_ptr(), terms.len() as u32)