diff --git a/derive/src/difference.rs b/derive/src/difference.rs
index c763f20..918a862 100644
--- a/derive/src/difference.rs
+++ b/derive/src/difference.rs
@@ -193,18 +193,18 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                         (_, (_, true, _)) => (),
                         (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                             l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                            l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
+                            l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
                             l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
-                            l!(setters_body, "\n\tlet diff = <Self as StructDiff>::Diff::{}(value.clone());", field_name);
+                            l!(setters_body, "\n\tlet diff = <Self as structdiff::StructDiff>::Diff::{}(value.clone());", field_name);
                             l!(setters_body, "\n\tself.{} = value;", field_name);
                             l!(setters_body, "\n\treturn Some(diff)");
                             l!(setters_body, "\n}");
                         },
                         (true, (_, false, None)) | (false, (true, false, None)) => {
                             l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                            l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
+                            l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
                             l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
-                            l!(setters_body, "\n\tlet diff = <Self as StructDiff>::Diff::{}(value.clone());", field_name);
+                            l!(setters_body, "\n\tlet diff = <Self as structdiff::StructDiff>::Diff::{}(value.clone());", field_name);
                             l!(setters_body, "\n\tself.{} = value;", field_name);
                             l!(setters_body, "\n\treturn Some(diff)");
                             l!(setters_body, "\n}");
@@ -258,18 +258,18 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                         (_, (_, true, _)) => (),
                         (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                             l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                            l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
+                            l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
                             l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
-                            l!(setters_body, "\n\tlet diff = <Self as StructDiff>::Diff::{}(value.clone());", field_name);
+                            l!(setters_body, "\n\tlet diff = <Self as structdiff::StructDiff>::Diff::{}(value.clone());", field_name);
                             l!(setters_body, "\n\tself.{} = value;", field_name);
                             l!(setters_body, "\n\treturn Some(diff)");
                             l!(setters_body, "\n}");
                         },
                         (true, (_, false, None)) | (false, (true, false, None)) => {
                             l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                            l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
+                            l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
                             l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
-                            l!(setters_body, "\n\tlet diff = <Self as StructDiff>::Diff::{}(value.clone());", field_name);
+                            l!(setters_body, "\n\tlet diff = <Self as structdiff::StructDiff>::Diff::{}(value.clone());", field_name);
                             l!(setters_body, "\n\tself.{} = value;", field_name);
                             l!(setters_body, "\n\treturn Some(diff)");
                             l!(setters_body, "\n}");
@@ -279,9 +279,9 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                 },
                 (true, None, false)  => { // Recurse inwards and generate a Vec<SubStructDiff> instead of cloning the entire thing
                     let typename = format!("__{field_name}StructDiffVec");
-                    l!(owned_type_aliases, "///Generated aliases from StructDiff\n type {} = Vec<<{} as StructDiff>::Diff>;", typename, field.ty.full());
+                    l!(owned_type_aliases, "///Generated aliases from StructDiff\n type {} = Vec<<{} as structdiff::StructDiff>::Diff>;", typename, field.ty.full());
                     let typename_ref = format!("__{field_name}StructDiffRefVec<'__diff_target>");
-                    l!(ref_type_aliases, "///Generated aliases from StructDiff\n type {} = Vec<<{} as StructDiff>::DiffRef<'__diff_target>>;", typename_ref, field.ty.full());
+                    l!(ref_type_aliases, "///Generated aliases from StructDiff\n type {} = Vec<<{} as structdiff::StructDiff>::DiffRef<'__diff_target>>;", typename_ref, field.ty.full());
 
                     l!(diff_enum_body, " {}({}),", field_name, typename);
                     l!(diff_ref_enum_body, " {}({}),", field_name, typename_ref);
@@ -330,18 +330,18 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                         (_, (_, true, _)) => (),
                         (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                             l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                            l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
+                            l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
                             l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
-                            l!(setters_body, "\n\tlet diff = <Self as StructDiff>::Diff::{}(self.{}.diff(&value));", field_name, field_name);
+                            l!(setters_body, "\n\tlet diff = <Self as structdiff::StructDiff>::Diff::{}(self.{}.diff(&value));", field_name, field_name);
                             l!(setters_body, "\n\tself.{} = value;", field_name);
                             l!(setters_body, "\n\treturn Some(diff)");
                             l!(setters_body, "\n}");
                         },
                         (true, (_, false, None)) | (false, (true, false, None)) => {
                             l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                            l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
+                            l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
                             l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
-                            l!(setters_body, "\n\tlet diff = <Self as StructDiff>::Diff::{}(self.{}.diff(&value));", field_name, field_name);
+                            l!(setters_body, "\n\tlet diff = <Self as structdiff::StructDiff>::Diff::{}(self.{}.diff(&value));", field_name, field_name);
                             l!(setters_body, "\n\tself.{} = value;", field_name);
                             l!(setters_body, "\n\treturn Some(diff)");
                             l!(setters_body, "\n}");
@@ -351,7 +351,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                 },
                 (true, None, true)  => { // Recurse inwards and generate an Option<Vec<SubStructDiff>> instead of cloning the entire thing
                     let typename = format!("__{field_name}StructDiffVec");
-                    l!(owned_type_aliases, "///Generated aliases from StructDiff\n type {} = Vec<<{} as StructDiff>::Diff>;", 
+                    l!(owned_type_aliases, "///Generated aliases from StructDiff\n type {} = Vec<<{} as structdiff::StructDiff>::Diff>;", 
                         typename,
                         field.ty.wraps.as_ref().expect("Option must wrap a type").first().expect("Option must wrap a type").full()
                     );
@@ -359,7 +359,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                     let ref_typename = format!("__{field_name}StructDiffRefVec<'__diff_target>");
                     l!(
                         ref_type_aliases,
-                        "///Generated aliases from StructDiff\n type {} = Vec<<{} as StructDiff>::DiffRef<'__diff_target>>;", 
+                        "///Generated aliases from StructDiff\n type {} = Vec<<{} as structdiff::StructDiff>::DiffRef<'__diff_target>>;", 
                         ref_typename,
                         field.ty.wraps.as_ref().expect("Option must wrap a type").first().expect("Option must wrap a type").full()
                     );
@@ -407,9 +407,9 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                     {
                         let diff_body_fragment_setter = format!(
                             "match (&self.{field_name}, &value) {{
-                                (Some(val1), Some(val2)) if &val1 != &val2 => <Self as StructDiff>::Diff::{field_name}(Some(val1.diff(&val2))),
-                                (Some(val1), None) => <Self as StructDiff>::Diff::{field_name}(None),
-                                (None, Some(val2)) => <Self as StructDiff>::Diff::{field_name}_full(val2.clone()),
+                                (Some(val1), Some(val2)) if &val1 != &val2 => <Self as structdiff::StructDiff>::Diff::{field_name}(Some(val1.diff(&val2))),
+                                (Some(val1), None) => <Self as structdiff::StructDiff>::Diff::{field_name}(None),
+                                (None, Some(val2)) => <Self as structdiff::StructDiff>::Diff::{field_name}_full(val2.clone()),
                                 _ => return None,
                             }};"
                         );
@@ -418,7 +418,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
 
                             (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                 l!(setters_body, "\n\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
+                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
                                 l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
                                 l!(setters_body, "\n\tlet diff = {}", diff_body_fragment_setter);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
@@ -427,7 +427,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                             },
                             (true, (_, false, None)) | (false, (true, false, None)) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
+                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
                                 l!(setters_body, "\n\tif self.{} == value {{return None}};", field_name);
                                 l!(setters_body, "\n\tlet diff = {}", diff_body_fragment_setter);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
@@ -563,7 +563,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                             (_, (_, true, _)) => (),
                             (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
+                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
                                 l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like_recursive::unordered_hashcmp(self.{}.iter(), value.iter(), true);", field_name);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
                                 l!(setters_body, "\n\tret");
@@ -571,7 +571,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                             },
                             (true, (_, false, None)) | (false, (true, false, None)) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
+                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
                                 l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like_recursive::unordered_hashcmp(self.{}.iter(), value.iter(), true);", field_name);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
                                 l!(setters_body, "\n\tret");
@@ -637,16 +637,16 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                             (_, (_, true, _)) => (),
                             (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                l!(setters_body, "\n\tlet ret = structdiff::collections::ordered_array_like::hirschberg(&value, &self.{}).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::ordered_array_like::hirschberg(&value, &self.{}).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
                                 l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
                             },
                             (true, (_, false, None)) | (false, (true, false, None)) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                l!(setters_body, "\n\tlet ret = structdiff::collections::ordered_array_like::hirschberg(&value, &self.{}).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::ordered_array_like::hirschberg(&value, &self.{}).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
                                 l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
@@ -705,16 +705,16 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                             (_, (_, true, _)) => (),
                             (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
                                 l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
                             },
                             (true, (_, false, None)) | (false, (true, false, None)) => {
                                 l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
+                                l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_array_like::unordered_hashcmp(self.{}.iter(), value.iter()).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                 l!(setters_body, "\n\tself.{} = value;", field_name);
                                 l!(setters_body, "\n\tret");
                                 l!(setters_body, "\n}");
@@ -775,16 +775,16 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                                 (_, (_, true, _)) => (),
                                 (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                                    l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                     l!(setters_body, "\n\tself.{} = value;", field_name);
                                     l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
                                 },
                                 (true, (_, false, None)) | (false, (true, false, None)) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                                    l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), true).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                     l!(setters_body, "\n\tself.{} = value;", field_name);
                                     l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
@@ -844,16 +844,16 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                                 (_, (_, true, _)) => (),
                                 (true, (_, false, Some(name_override))) | (false, (true, false, Some(name_override))) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", name_override);
-                                    l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", name_override, field.ty.full());
-                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\npub fn {}(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", name_override, field.ty.full());
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                     l!(setters_body, "\n\tself.{} = value;", field_name);
                                     l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
                                 },
                                 (true, (_, false, None)) | (false, (true, false, None)) => {
                                     l!(setters_body, "\n/// Setter generated by StructDiff. Use to set the {} field and generate a diff if necessary", field_name);
-                                    l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as StructDiff>::Diff> {{", field_name, field.ty.full());
-                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as StructDiff>::Diff::{}(x.into()));", field_name, field_name);
+                                    l!(setters_body, "\npub fn set_{}_with_diff(&mut self, value: {}) -> Option<<Self as structdiff::StructDiff>::Diff> {{", field_name, field.ty.full());
+                                    l!(setters_body, "\n\tlet ret = structdiff::collections::unordered_map_like::unordered_hashcmp(self.{}.iter(), value.iter(), false).map(|x| <Self as structdiff::StructDiff>::Diff::{}(x.into()));", field_name, field_name);
                                     l!(setters_body, "\n\tself.{} = value;", field_name);
                                     l!(setters_body, "\n\tret");
                                     l!(setters_body, "\n}");
@@ -1023,7 +1023,7 @@ pub(crate) fn derive_struct_diff_struct(struct_: &Struct) -> TokenStream {
                 }}
             }}
             
-            impl{impl_generics} StructDiff for {struct_name}{struct_generics} 
+            impl{impl_generics} structdiff::StructDiff for {struct_name}{struct_generics} 
             where 
             {struct_where_bounds}
             {{
@@ -1456,7 +1456,7 @@ pub(crate) fn derive_struct_diff_enum(enum_: &Enum) -> TokenStream {
                 }}
             }}
             
-            impl{impl_generics} StructDiff for {struct_name}{struct_generics} 
+            impl{impl_generics} structdiff::StructDiff for {struct_name}{struct_generics} 
             where 
             {struct_where_bounds}
             {{