Current state

Author: filmor

rustler/src/lib.rs

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

rustler/src/serde/ser.rs

@@ -460,7 +460,11 @@ impl<'a> MapSerializer<'a> {
 
     #[inline]
     fn to_map(&self) -> Result<Term<'a>, Error> {
-        Term::map_from_arrays(self.ser.env, &self.keys, &self.values).or(Err(Error::InvalidMap))
+        self.ser
+            .env
+            .map_from_arrays(&self.keys, &self.values)
+            .map(|map| map.into())
+            .or(Err(Error::InvalidMap))
     }
 
     #[inline]

rustler/src/types/atom.rs

@@ -1,5 +1,6 @@
 use crate::wrapper::atom;
 use crate::wrapper::NIF_TERM;
+use crate::Wrapper;
 use crate::{Decoder, Encoder, Env, Error, NifResult, Term};
 
 // Atoms are a special case of a term. They can be stored and used on all envs regardless of where
@@ -81,6 +82,18 @@ impl Atom {
     }
 }
 
+impl<'a> Wrapper<'a> for Atom {
+    const WRAPPED_TYPE: crate::TermType = crate::TermType::Atom;
+
+    fn unwrap(&self) -> Term<'a> {
+        unimplemented!()
+    }
+
+    unsafe fn wrap_unchecked(term: Term<'a>) -> Self {
+        Atom::from_nif_term(term.as_c_arg())
+    }
+}
+
 use std::fmt;
 impl fmt::Debug for Atom {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {

rustler/src/wrapped_types/map.rs

@@ -18,6 +18,26 @@ impl<'a> Env<'a> {
     pub fn new_map(self) -> Map<'a> {
         unsafe { Map::wrap_unchecked(Term::new(self, enif_make_new_map(self.as_c_arg()))) }
     }
+
+    pub fn map_from_pairs(self, pairs: &[(impl Encoder, impl Encoder)]) -> NifResult<Map<'a>> {
+        Term::map_from_pairs(self, pairs).map(|res| res.try_into().unwrap())
+    }
+
+    pub fn map_from_arrays(
+        self,
+        keys: &[impl Encoder],
+        values: &[impl Encoder],
+    ) -> NifResult<Map<'a>> {
+        Term::map_from_arrays(self, keys, values).map(|res| res.try_into().unwrap())
+    }
+
+    pub fn map_from_term_arrays(
+        self,
+        keys: &[Term<'a>],
+        values: &[Term<'a>],
+    ) -> NifResult<Map<'a>> {
+        Term::map_from_term_arrays(self, keys, values).map(|res| res.try_into().unwrap())
+    }
 }
 
 impl<'a> Map<'a> {

rustler/src/wrapped_types/mod.rs

@@ -10,4 +10,4 @@ pub use reference::Reference;
 pub use tuple::Tuple;
 
 pub(crate) use wrapper::wrapper;
-pub(crate) use wrapper::Wrapper;
+pub use wrapper::Wrapper;

rustler/src/wrapped_types/wrapper.rs

@@ -9,7 +9,7 @@ impl From<WrapperError> for crate::Error {
     }
 }
 
-pub(crate) trait Wrapper<'a>: Sized {
+pub trait Wrapper<'a>: Sized {
     const WRAPPED_TYPE: TermType;
 
     unsafe fn wrap_ptr_unchecked(env: Env<'a>, ptr: ERL_NIF_TERM) -> Self {

rustler_codegen/src/map.rs

@@ -89,7 +89,6 @@ fn gen_decoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
                 where
                     T: rustler::Decoder<'a>,
                 {
-                    use rustler::Encoder;
                     match ::rustler::Decoder::decode(term.map_get(&field)?) {
                         Err(_) => Err(::rustler::Error::RaiseTerm(Box::new(format!(
                                         "Could not decode field :{:?} on %{{}}",
@@ -123,7 +122,8 @@ fn gen_encoder(ctx: &Context, fields: &[&Field], atoms_module_name: &Ident) -> T
         ctx,
         quote! {
             use #atoms_module_name::*;
-            ::rustler::Term::map_from_term_arrays(env, &[#(#keys),*], &[#(#values),*]).unwrap()
+            use ::rustler::Wrapper;
+            env.map_from_term_arrays(&[#(#keys),*], &[#(#values),*]).unwrap().unwrap()
         },
     )
 }

rustler_tests/native/rustler_test/src/test_map.rs

@@ -1,4 +1,4 @@
-use rustler::{Encoder, Env, Error, ListIterator, MapIterator, NifResult, Term, Tuple};
+use rustler::{Encoder, Env, Error, ListIterator, Map, MapIterator, NifResult, Term, Tuple};
 
 #[rustler::nif]
 pub fn sum_map_values(iter: MapIterator) -> NifResult<i64> {
@@ -43,15 +43,15 @@ pub fn map_from_arrays<'a>(
     env: Env<'a>,
     keys: Vec<Term<'a>>,
     values: Vec<Term<'a>>,
-) -> NifResult<Term<'a>> {
-    Term::map_from_arrays(env, &keys, &values)
+) -> NifResult<Map<'a>> {
+    env.map_from_arrays(&keys, &values)
 }
 
 #[rustler::nif]
-pub fn map_from_pairs<'a>(env: Env<'a>, pairs: ListIterator<'a>) -> NifResult<Term<'a>> {
+pub fn map_from_pairs<'a>(env: Env<'a>, pairs: ListIterator<'a>) -> NifResult<Map<'a>> {
     let res: Result<Vec<(Term, Term)>, Error> = pairs.map(|x| x.decode()).collect();
 
-    res.and_then(|v| Term::map_from_pairs(env, &v))
+    res.and_then(|v| env.map_from_pairs(&v))
 }
 
 #[rustler::nif]