diff --git a/derive/src/serde_bin.rs b/derive/src/serde_bin.rs
index 860d56c..57baf9b 100644
--- a/derive/src/serde_bin.rs
+++ b/derive/src/serde_bin.rs
@@ -4,8 +4,8 @@ use proc_macro::TokenStream;
 
 pub fn derive_ser_bin_proxy(proxy_type: &str, type_: &str) -> TokenStream {
     format!(
-        "impl SerBin for {} {{
-            fn ser_bin(&self, s: &mut Vec<u8>) {{
+        "impl ::nanoserde::SerBin for {} {{
+            fn ser_bin(&self, s: &mut ::std::vec::Vec<u8>) {{
                 let proxy: {} = self.into();
                 proxy.ser_bin(s);
             }}
@@ -18,10 +18,10 @@ pub fn derive_ser_bin_proxy(proxy_type: &str, type_: &str) -> TokenStream {
 
 pub fn derive_de_bin_proxy(proxy_type: &str, type_: &str) -> TokenStream {
     format!(
-        "impl DeBin for {} {{
-            fn de_bin(o:&mut usize, d:&[u8]) -> std::result::Result<Self, nanoserde::DeBinErr> {{
-                let proxy: {} = DeBin::de_bin(o, d)?;
-                std::result::Result::Ok(Into::into(&proxy))
+        "impl ::nanoserde::DeBin for {} {{
+            fn de_bin(o:&mut usize, d:&[u8]) -> ::std::result::Result<Self, ::nanoserde::DeBinErr> {{
+                let proxy: {} = ::nanoserde::DeBin::de_bin(o, d)?;
+                ::std::result::Result::Ok(Into::into(&proxy))
             }}
         }}",
         type_, proxy_type
@@ -51,8 +51,8 @@ pub fn derive_ser_bin_struct(struct_: &Struct) -> TokenStream {
         }
     }
     format!(
-        "impl SerBin for {} {{
-            fn ser_bin(&self, s: &mut Vec<u8>) {{
+        "impl ::nanoserde::SerBin for {} {{
+            fn ser_bin(&self, s: &mut ::std::vec::Vec<u8>) {{
                 {}
             }}
         }}",
@@ -74,8 +74,8 @@ pub fn derive_ser_bin_struct_unnamed(struct_: &Struct) -> TokenStream {
         }
     }
     format!(
-        "impl SerBin for {} {{
-            fn ser_bin(&self, s: &mut Vec<u8>) {{
+        "impl ::nanoserde::SerBin for {} {{
+            fn ser_bin(&self, s: &mut ::std::vec::Vec<u8>) {{
                 {}
             }}
         }}",
@@ -91,22 +91,22 @@ pub fn derive_de_bin_struct(struct_: &Struct) -> TokenStream {
     for field in &struct_.fields {
         if let Some(proxy) = crate::shared::attrs_proxy(&field.attributes) {
             l!(body, "{}: {{", field.field_name.as_ref().unwrap());
-            l!(body, "let proxy: {} = DeBin::de_bin(o, d)?;", proxy);
+            l!(body, "let proxy: {} = ::nanoserde::DeBin::de_bin(o, d)?;", proxy);
             l!(body, "Into::into(&proxy)");
             l!(body, "},")
         } else {
             l!(
                 body,
-                "{}: DeBin::de_bin(o, d)?,",
+                "{}: ::nanoserde::DeBin::de_bin(o, d)?,",
                 field.field_name.as_ref().unwrap()
             );
         }
     }
 
     format!(
-        "impl DeBin for {} {{
-            fn de_bin(o:&mut usize, d:&[u8]) -> std::result::Result<Self, nanoserde::DeBinErr> {{
-                std::result::Result::Ok(Self {{
+        "impl ::nanoserde::DeBin for {} {{
+            fn de_bin(o:&mut usize, d:&[u8]) -> ::std::result::Result<Self, ::nanoserde::DeBinErr> {{
+                ::std::result::Result::Ok(Self {{
                     {}
                 }})
             }}
@@ -123,18 +123,18 @@ pub fn derive_de_bin_struct_unnamed(struct_: &Struct) -> TokenStream {
     for (n, field) in struct_.fields.iter().enumerate() {
         if let Some(proxy) = crate::shared::attrs_proxy(&field.attributes) {
             l!(body, "{}: {{", n);
-            l!(body, "let proxy: {} = DeBin::de_bin(o, d)?;", proxy);
+            l!(body, "let proxy: {} = ::nanoserde::DeBin::de_bin(o, d)?;", proxy);
             l!(body, "Into::into(&proxy)");
             l!(body, "},")
         } else {
-            l!(body, "{}: DeBin::de_bin(o, d)?,", n);
+            l!(body, "{}: ::nanoserde::DeBin::de_bin(o, d)?,", n);
         }
     }
 
     format!(
         "impl DeBin for {} {{
-            fn de_bin(o:&mut usize, d:&[u8]) -> std::result::Result<Self, nanoserde::DeBinErr> {{
-                std::result::Result::Ok(Self {{
+            fn de_bin(o:&mut usize, d:&[u8]) -> ::std::result::Result<Self, ::nanoserde::DeBinErr> {{
+                ::std::result::Result::Ok(Self {{
                     {}
                 }})
             }}
@@ -184,8 +184,8 @@ pub fn derive_ser_bin_enum(enum_: &Enum) -> TokenStream {
     }
 
     format!(
-        "impl SerBin for {} {{
-            fn ser_bin(&self, s: &mut Vec<u8>) {{
+        "impl ::nanoserde::SerBin for {} {{
+            fn ser_bin(&self, s: &mut ::std::vec::Vec<u8>) {{
                 match self {{
                   {}
                 }}
@@ -213,7 +213,7 @@ pub fn derive_de_bin_enum(enum_: &Enum) -> TokenStream {
             for field in &variant.fields {
                 l!(
                     r,
-                    "{}: DeBin::de_bin(o, d)?,",
+                    "{}: ::nanoserde::DeBin::de_bin(o, d)?,",
                     field.field_name.as_ref().unwrap()
                 );
             }
@@ -223,19 +223,19 @@ pub fn derive_de_bin_enum(enum_: &Enum) -> TokenStream {
         else if variant.named == false {
             l!(r, "{} => Self::{} (", lit, variant.name);
             for _ in &variant.fields {
-                l!(r, "DeBin::de_bin(o, d)?,");
+                l!(r, "::nanoserde::DeBin::de_bin(o, d)?,");
             }
             l!(r, "),");
         }
     }
 
     format!(
-        "impl  DeBin for {} {{
-            fn de_bin(o:&mut usize, d:&[u8]) -> std::result::Result<Self, nanoserde::DeBinErr> {{
-                let id: u16 = DeBin::de_bin(o,d)?;
+        "impl ::nanoserde::DeBin for {} {{
+            fn de_bin(o:&mut usize, d:&[u8]) -> ::std::result::Result<Self, ::nanoserde::DeBinErr> {{
+                let id: u16 = ::nanoserde::DeBin::de_bin(o,d)?;
                 Ok(match id {{
                     {}
-                    _ => return std::result::Result::Err(nanoserde::DeBinErr{{o:*o, l:0, s:d.len()}})
+                    _ => return ::std::result::Result::Err(::nanoserde::DeBinErr{{o:*o, l:0, s:d.len()}})
                 }})
             }}
         }}", enum_.name, r)
diff --git a/derive/src/serde_json.rs b/derive/src/serde_json.rs
index ae97834..4221c39 100644
--- a/derive/src/serde_json.rs
+++ b/derive/src/serde_json.rs
@@ -6,8 +6,8 @@ use crate::shared;
 
 pub fn derive_ser_json_proxy(proxy_type: &str, type_: &str) -> TokenStream {
     format!(
-        "impl SerJson for {} {{
-            fn ser_json(&self, d: usize, s: &mut nanoserde::SerJsonState) {{
+        "impl ::nanoserde::SerJson for {} {{
+            fn ser_json(&self, d: usize, s: &mut ::nanoserde::SerJsonState) {{
                 let proxy: {} = self.into();
                 proxy.ser_json(d, s);
             }}
@@ -61,8 +61,8 @@ pub fn derive_ser_json_struct(struct_: &Struct) -> TokenStream {
 
     format!(
         "
-        impl SerJson for {} {{
-            fn ser_json(&self, d: usize, s: &mut nanoserde::SerJsonState) {{
+        impl ::nanoserde::SerJson for {} {{
+            fn ser_json(&self, d: usize, s: &mut ::nanoserde::SerJsonState) {{
                 s.st_pre();
                 {}
                 s.st_post(d);
@@ -95,14 +95,14 @@ pub fn derive_de_json_named(name: &str, defaults: bool, fields: &[Field]) -> Tok
                     val = format!("\"{}\".to_string()", val)
                 }
                 if field.ty.is_option {
-                    val = format!("Some({})", val);
+                    val = format!("Option::Some({})", val);
                 }
                 Some(val)
             } else {
                 if !field.ty.is_option {
-                    Some(String::from("Default::default()"))
+                    Some(String::from("::std::default::Default::default()"))
                 } else {
-                    Some(String::from("None"))
+                    Some(String::from("Option::None"))
                 }
             }
         } else if let Some(mut v) = field_attr_default_with {
@@ -125,28 +125,28 @@ pub fn derive_de_json_named(name: &str, defaults: bool, fields: &[Field]) -> Tok
         if skip == false {
             if field.ty.is_option {
                 unwraps.push(format!(
-                    "{{if let Some(t) = {} {{ {} }} else {{ {} }} }}",
+                    "{{if let Option::Some(t) = {} {{ {} }} else {{ {} }} }}",
                     localvar,
                     proxified_t,
-                    default_val.unwrap_or_else(|| String::from("None"))
+                    default_val.unwrap_or_else(|| String::from("Option::None"))
                 ));
             } else if container_attr_default || default_val.is_some() {
                 unwraps.push(format!(
-                    "{{if let Some(t) = {} {{ {} }} else {{ {} }} }}",
+                    "{{if let Option::Some(t) = {} {{ {} }} else {{ {} }} }}",
                     localvar,
                     proxified_t,
-                    default_val.unwrap_or_else(|| String::from("Default::default()"))
+                    default_val.unwrap_or_else(|| String::from("::std::default::Default::default()"))
                 ));
             } else {
                 unwraps.push(format!(
-                    "{{if let Some(t) = {} {{ {} }} else {{return Err(s.err_nf(\"{}\"))}} }}",
+                    "{{if let Option::Some(t) = {} {{ {} }} else {{return ::std::result::Result::Err(s.err_nf(\"{}\"))}} }}",
                     localvar, proxified_t, struct_fieldname
                 ));
             }
             matches.push((json_fieldname.clone(), localvar.clone()));
             local_vars.push(localvar);
         } else {
-            unwraps.push(format!("None"));
+            unwraps.push(format!("Option::None"));
         }
 
         struct_field_names.push(struct_fieldname);
@@ -155,17 +155,17 @@ pub fn derive_de_json_named(name: &str, defaults: bool, fields: &[Field]) -> Tok
 
     let mut r = String::new();
     for local_var in &local_vars {
-        l!(r, "let mut {} = None;", local_var);
+        l!(r, "let mut {} = Option::None;", local_var);
     }
     l!(r, "s.curly_open(i) ?;");
-    l!(r, "while let Some(_) = s.next_str() {");
+    l!(r, "while let Option::Some(_) = s.next_str() {");
 
     if json_field_names.len() != 0 {
         l!(r, "match AsRef::<str>::as_ref(&s.strbuf) {");
         for (json_field_name, local_var) in matches.iter() {
             l!(
                 r,
-                "\"{}\" => {{s.next_colon(i) ?;{} = Some(DeJson::de_json(s, i) ?)}},",
+                "\"{}\" => {{s.next_colon(i) ?;{} = Option::Some(::nanoserde::DeJson::de_json(s, i) ?)}},",
                 json_field_name,
                 local_var
             );
@@ -192,10 +192,10 @@ pub fn derive_de_json_named(name: &str, defaults: bool, fields: &[Field]) -> Tok
 
 pub fn derive_de_json_proxy(proxy_type: &str, type_: &str) -> TokenStream {
     format!(
-        "impl DeJson for {} {{
-            fn de_json(_s: &mut nanoserde::DeJsonState, i: &mut std::str::Chars) -> std::result::Result<Self, nanoserde::DeJsonErr> {{
+        "impl ::nanoserde::DeJson for {} {{
+            fn de_json(_s: &mut ::nanoserde::DeJsonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self, ::nanoserde::DeJsonErr> {{
                 let proxy: {} = DeJson::deserialize_json(i)?;
-                std::result::Result::Ok(Into::into(&proxy))
+                ::std::result::Result::Ok(Into::into(&proxy))
             }}
         }}",
         type_, proxy_type
@@ -213,10 +213,10 @@ pub fn derive_de_json_struct(struct_: &Struct) -> TokenStream {
     );
 
     format!(
-        "impl DeJson for {} {{
-            fn de_json(s: &mut nanoserde::DeJsonState, i: &mut std::str::Chars) -> std::result::Result<Self,
-            nanoserde::DeJsonErr> {{
-                std::result::Result::Ok({{ {} }})
+        "impl ::nanoserde::DeJson for {} {{
+            fn de_json(s: &mut ::nanoserde::DeJsonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self,
+            ::nanoserde::DeJsonErr> {{
+                ::std::result::Result::Ok({{ {} }})
             }}
         }}", struct_.name, body)
         .parse().unwrap()
@@ -341,8 +341,8 @@ pub fn derive_ser_json_enum(enum_: &Enum) -> TokenStream {
 
     format!(
         "
-        impl SerJson for {} {{
-            fn ser_json(&self, d: usize, s: &mut nanoserde::SerJsonState) {{
+        impl ::nanoserde::SerJson for {} {{
+            fn ser_json(&self, d: usize, s: &mut ::nanoserde::SerJsonState) {{
                 match self {{
                     {}
                 }}
@@ -384,7 +384,7 @@ pub fn derive_de_json_enum(enum_: &Enum) -> TokenStream {
             for _ in &variant.fields {
                 l!(
                     field_names,
-                    "{let r = DeJson::de_json(s,i)?;s.eat_comma_block(i)?;r},"
+                    "{let r = ::nanoserde::DeJson::de_json(s,i)?;s.eat_comma_block(i)?;r},"
                 );
             }
             l!(
@@ -398,8 +398,8 @@ pub fn derive_de_json_enum(enum_: &Enum) -> TokenStream {
     }
 
     let mut r = format!(
-        "impl DeJson for {} {{
-            fn de_json(s: &mut nanoserde::DeJsonState, i: &mut std::str::Chars) -> std::result::Result<Self, nanoserde::DeJsonErr> {{
+        "impl ::nanoserde::DeJson for {} {{
+            fn de_json(s: &mut ::nanoserde::DeJsonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self, ::nanoserde::DeJsonErr> {{
                 match s.tok {{",
         enum_.name,
     );
@@ -407,13 +407,13 @@ pub fn derive_de_json_enum(enum_: &Enum) -> TokenStream {
     if !r_rest.is_empty() {
         r.push_str(&format!(
             "
-                    nanoserde::DeJsonTok::CurlyOpen => {{
+                    ::nanoserde::DeJsonTok::CurlyOpen => {{
                         s.curly_open(i)?;
                         let _ = s.string(i)?;
                         s.colon(i)?;
-                        let r = std::result::Result::Ok(match s.strbuf.as_ref() {{
+                        let r = ::std::result::Result::Ok(match s.strbuf.as_ref() {{
                             {}
-                            _ => return std::result::Result::Err(s.err_enum(&s.strbuf))
+                            _ => return ::std::result::Result::Err(s.err_enum(&s.strbuf))
                         }});
                         s.curly_close(i)?;
                         r
@@ -425,11 +425,11 @@ pub fn derive_de_json_enum(enum_: &Enum) -> TokenStream {
     if !r_units.is_empty() {
         r.push_str(&format!(
             "
-                    nanoserde::DeJsonTok::Str => {{
+                    ::nanoserde::DeJsonTok::Str => {{
                         let _ = s.string(i)?;
-                        std::result::Result::Ok(match s.strbuf.as_ref() {{
+                        ::std::result::Result::Ok(match s.strbuf.as_ref() {{
                             {}
-                            _ => return std::result::Result::Err(s.err_enum(&s.strbuf))
+                            _ => return ::std::result::Result::Err(s.err_enum(&s.strbuf))
                         }})
                     }},",
             r_units,
@@ -438,7 +438,7 @@ pub fn derive_de_json_enum(enum_: &Enum) -> TokenStream {
 
     r.push_str(
         r#"
-                    _ => std::result::Result::Err(s.err_token("String or {")),
+                    _ => ::std::result::Result::Err(s.err_token("String or {")),
                 }
             }
         }
@@ -478,8 +478,8 @@ pub fn derive_ser_json_struct_unnamed(struct_: &Struct) -> TokenStream {
 
     format!(
         "
-        impl SerJson for {} {{
-            fn ser_json(&self, d: usize, s: &mut nanoserde::SerJsonState) {{
+        impl ::nanoserde::SerJson for {} {{
+            fn ser_json(&self, d: usize, s: &mut ::nanoserde::SerJsonState) {{
                 {}
             }}
         }}",
@@ -495,7 +495,7 @@ pub fn derive_de_json_struct_unnamed(struct_: &Struct) -> TokenStream {
     let transparent = shared::attrs_transparent(&struct_.attributes);
 
     for _ in &struct_.fields {
-        l!(body, "{ let r = DeJson::de_json(s, i)?;");
+        l!(body, "{ let r = ::nanoserde::DeJson::de_json(s, i)?;");
         if struct_.fields.len() != 1 {
             l!(body, "  s.eat_comma_block(i)?;");
         }
@@ -523,10 +523,10 @@ pub fn derive_de_json_struct_unnamed(struct_: &Struct) -> TokenStream {
     };
 
     format! ("
-        impl DeJson for {} {{
-            fn de_json(s: &mut nanoserde::DeJsonState, i: &mut std::str::Chars) -> std::result::Result<Self,nanoserde::DeJsonErr> {{
+        impl ::nanoserde::DeJson for {} {{
+            fn de_json(s: &mut ::nanoserde::DeJsonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self, ::nanoserde::DeJsonErr> {{
                 {}
-                std::result::Result::Ok(r)
+                ::std::result::Result::Ok(r)
             }}
         }}",struct_.name, body
     ).parse().unwrap()
diff --git a/derive/src/serde_ron.rs b/derive/src/serde_ron.rs
index e09a439..8e3e5c7 100644
--- a/derive/src/serde_ron.rs
+++ b/derive/src/serde_ron.rs
@@ -6,8 +6,8 @@ use crate::shared;
 
 pub fn derive_ser_ron_proxy(proxy_type: &str, type_: &str) -> TokenStream {
     format!(
-        "impl SerRon for {} {{
-            fn ser_ron(&self, d: usize, s: &mut nanoserde::SerRonState) {{
+        "impl ::nanoserde::SerRon for {} {{
+            fn ser_ron(&self, d: usize, s: &mut ::nanoserde::SerRonState) {{
                 let proxy: {} = self.into();
                 proxy.ser_ron(d, s);
             }}
@@ -20,10 +20,10 @@ pub fn derive_ser_ron_proxy(proxy_type: &str, type_: &str) -> TokenStream {
 
 pub fn derive_de_ron_proxy(proxy_type: &str, type_: &str) -> TokenStream {
     format!(
-        "impl DeRon for {} {{
-            fn de_ron(_s: &mut nanoserde::DeRonState, i: &mut std::str::Chars) -> std::result::Result<Self, nanoserde::DeRonErr> {{
-                let proxy: {} = DeRon::deserialize_ron(i)?;
-                std::result::Result::Ok(Into::into(&proxy))
+        "impl ::nanoserde::DeRon for {} {{
+            fn de_ron(_s: &mut ::nanoserde::DeRonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self, ::nanoserde::DeRonErr> {{
+                let proxy: {} = ::nanoserde::DeRon::deserialize_ron(i)?;
+                ::std::result::Result::Ok(Into::into(&proxy))
             }}
         }}",
         type_, proxy_type
@@ -42,7 +42,7 @@ pub fn derive_ser_ron_struct(struct_: &Struct) -> TokenStream {
         if field.ty.is_option {
             l!(
                 s,
-                "if let Some(t) = &self.{} {{
+                "if let Option::Some(t) = &self.{} {{
                     s.field(d+1, \"{}\");
                     t.ser_ron(d+1, s);
                     s.conl();
@@ -64,8 +64,8 @@ pub fn derive_ser_ron_struct(struct_: &Struct) -> TokenStream {
 
     format!(
         "
-        impl SerRon for {} {{
-            fn ser_ron(&self, d: usize, s: &mut nanoserde::SerRonState) {{
+        impl ::nanoserde::SerRon for {} {{
+            fn ser_ron(&self, d: usize, s: &mut ::nanoserde::SerRonState) {{
                 s.st_pre();
                 {}
                 s.st_post(d);
@@ -90,8 +90,8 @@ pub fn derive_ser_ron_struct_unnamed(struct_: &Struct) -> TokenStream {
     }
     format!(
         "
-        impl SerRon for {} {{
-            fn ser_ron(&self, d: usize, s: &mut nanoserde::SerRonState) {{
+        impl ::nanoserde::SerRon for {} {{
+            fn ser_ron(&self, d: usize, s: &mut ::nanoserde::SerRonState) {{
                 s.out.push('(');
                 {}
                 s.out.push(')');
@@ -122,18 +122,18 @@ pub fn derive_de_ron_named(
         let field_attr_default_with = shared::attrs_default_with(&field.attributes);
         let default_val = if let Some(v) = field_attr_default {
             if let Some(mut val) = v {
-                if field.ty.path == "String" {
+                if field.ty.path == "::std::string::String" {
                     val = format!("\"{}\".to_string()", val)
                 }
                 if field.ty.is_option {
-                    val = format!("Some({})", val);
+                    val = format!("Option::Some({})", val);
                 }
                 Some(val)
             } else {
                 if !field.ty.is_option {
-                    Some(String::from("Default::default()"))
+                    Some(String::from("::std::default::Default::default()"))
                 } else {
-                    Some(String::from("None"))
+                    Some(String::from("Option::None"))
                 }
             }
         } else if let Some(mut v) = field_attr_default_with {
@@ -148,34 +148,34 @@ pub fn derive_de_ron_named(
         if field.ty.is_option {
             unwraps.push(format!(
                 "{{
-                    if let Some(t) = {} {{
+                    if let Option::Some(t) = {} {{
                         t
                     }} else {{
                         {}
                     }}
                 }}",
                 localvar,
-                default_val.unwrap_or_else(|| String::from("None"))
+                default_val.unwrap_or_else(|| String::from("Option::None"))
             ));
         } else if container_attr_default || default_val.is_some() {
             unwraps.push(format!(
                 "{{
-                    if let Some(t) = {} {{
+                    if let Option::Some(t) = {} {{
                         t
                     }} else {{
                         {}
                     }}
                 }}",
                 localvar,
-                default_val.unwrap_or_else(|| String::from("Default::default()"))
+                default_val.unwrap_or_else(|| String::from("::std::default::Default::default()"))
             ));
         } else {
             unwraps.push(format!(
                 "{{
-                    if let Some(t) = {} {{
+                    if let Option::Some(t) = {} {{
                         t
                     }} else {{
-                        return Err(s.err_nf(\"{}\"))
+                        return ::std::result::Result::Err(s.err_nf(\"{}\"))
                     }}
                 }}",
                 localvar, struct_fieldname
@@ -190,7 +190,7 @@ pub fn derive_de_ron_named(
     let mut local_lets = String::new();
 
     for local in &local_vars {
-        l!(local_lets, "let mut {} = None;", local)
+        l!(local_lets, "let mut {} = Option::None;", local)
     }
 
     let match_names = if ron_field_names.len() != 0 {
@@ -200,7 +200,7 @@ pub fn derive_de_ron_named(
                 inner,
                 "\"{}\" => {{
                     s.next_colon(i)?;
-                    {} = Some(DeRon::de_ron(s, i)?)
+                    {} = Option::Some(DeRon::de_ron(s, i)?)
                 }},",
                 ron_field_name,
                 local_var
@@ -209,7 +209,7 @@ pub fn derive_de_ron_named(
         format!(
             "match s.identbuf.as_ref() {{
                 {}
-                _ => return std::result::Result::Err(s.err_exp(&s.identbuf))
+                _ => return ::std::result::Result::Err(s.err_exp(&s.identbuf))
             }}",
             inner
         )
@@ -227,7 +227,7 @@ pub fn derive_de_ron_named(
         "{{
             {}
             s.paren_open(i)?;
-            while let Some(_) = s.next_ident() {{
+            while let Option::Some(_) = s.next_ident() {{
                 {}
                 s.eat_comma_paren(i)?;
             }};
@@ -244,9 +244,9 @@ pub fn derive_de_ron_struct(struct_: &Struct) -> TokenStream {
     let body = derive_de_ron_named(&struct_.name, &struct_.fields, &struct_.attributes);
 
     format!(
-        "impl DeRon for {} {{
-            fn de_ron(s: &mut nanoserde::DeRonState, i: &mut std::str::Chars) -> std::result::Result<Self,nanoserde::DeRonErr> {{
-                std::result::Result::Ok({})
+        "impl ::nanoserde::DeRon for {} {{
+            fn de_ron(s: &mut ::nanoserde::DeRonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self, ::nanoserde::DeRonErr> {{
+                ::std::result::Result::Ok({})
             }}
         }}", struct_.name, body)
     .parse()
@@ -260,7 +260,7 @@ pub fn derive_de_ron_struct_unnamed(struct_: &Struct) -> TokenStream {
         l!(
             body,
             "{{
-                let r = DeRon::de_ron(s, i)?;
+                let r = ::nanoserde::DeRon::de_ron(s, i)?;
                 s.eat_comma_paren(i)?;
                 r
             }},"
@@ -268,12 +268,12 @@ pub fn derive_de_ron_struct_unnamed(struct_: &Struct) -> TokenStream {
     }
 
     format! ("
-        impl DeRon for {} {{
-            fn de_ron(s: &mut nanoserde::DeRonState, i: &mut std::str::Chars) -> std::result::Result<Self,nanoserde::DeRonErr> {{
+        impl ::nanoserde::DeRon for {} {{
+            fn de_ron(s: &mut ::nanoserde::DeRonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self, ::nanoserde::DeRonErr> {{
                 s.paren_open(i)?;
                 let r = Self({});
                 s.paren_close(i)?;
-                std::result::Result::Ok(r)
+                ::std::result::Result::Ok(r)
             }}
         }}",struct_.name, body
     ).parse().unwrap()
@@ -363,8 +363,8 @@ pub fn derive_ser_ron_enum(enum_: &Enum) -> TokenStream {
     }
     format!(
         "
-        impl SerRon for {} {{
-            fn ser_ron(&self, d: usize, s: &mut nanoserde::SerRonState) {{
+        impl ::nanoserde::SerRon for {} {{
+            fn ser_ron(&self, d: usize, s: &mut ::nanoserde::SerRonState) {{
                 match self {{
                     {}
                 }}
@@ -398,7 +398,7 @@ pub fn derive_de_ron_enum(enum_: &Enum) -> TokenStream {
                 l!(
                     inner,
                     "{
-                        let r = DeRon::de_ron(s, i)?;
+                        let r = ::nanoserde::DeRon::de_ron(s, i)?;
                         s.eat_comma_paren(i)?;
                         r
                     }, "
@@ -420,13 +420,13 @@ pub fn derive_de_ron_enum(enum_: &Enum) -> TokenStream {
     }
 
     format! ("
-        impl DeRon for {} {{
-            fn de_ron(s: &mut nanoserde::DeRonState, i: &mut std::str::Chars) -> std::result::Result<Self,nanoserde::DeRonErr> {{
+        impl ::nanoserde::DeRon for {} {{
+            fn de_ron(s: &mut nanoserde::DeRonState, i: &mut ::std::str::Chars) -> ::std::result::Result<Self, ::nanoserde::DeRonErr> {{
                 // we are expecting an identifier
                 s.ident(i)?;
-                std::result::Result::Ok(match s.identbuf.as_ref() {{
+                ::std::result::Result::Ok(match s.identbuf.as_ref() {{
                     {}
-                    _ => return std::result::Result::Err(s.err_enum(&s.identbuf))
+                    _ => return ::std::result::Result::Err(s.err_enum(&s.identbuf))
                 }})
             }}
         }}", enum_.name, body).parse().unwrap()