diff --git a/derive/src/generate/ser.rs b/derive/src/generate/ser.rs
index b743fa4..7821802 100644
--- a/derive/src/generate/ser.rs
+++ b/derive/src/generate/ser.rs
@@ -68,7 +68,7 @@ fn variant_compound_fields(
 				);
 
 				quote! {
-					<#ty as ::linked_data::LinkedDataSubject<I_, V_>>::visit_subject(#field_ref, &mut visitor)?;
+					<#ty as ::linked_data::LinkedDataSubject<I_, V_>>::accept_subject_visitor(#field_ref, &mut visitor)?;
 				}
 			} else {
 				match field_attrs.iri {
@@ -85,7 +85,7 @@ fn variant_compound_fields(
 							);
 
 							quote! {
-								visitor.predicate(
+								visitor.visit_predicate(
 									::linked_data::iref::Iri::new(#iri).unwrap(),
 									&Some(::linked_data::AnonymousGraph(#field_ref))
 								)?;
@@ -99,7 +99,7 @@ fn variant_compound_fields(
 							);
 
 							quote! {
-								visitor.predicate(
+								visitor.visit_predicate(
 									::linked_data::iref::Iri::new(#iri).unwrap(),
 									#field_ref
 								)?;
diff --git a/derive/src/generate/ser/enum.rs b/derive/src/generate/ser/enum.rs
index 2c3d3d6..b74fbf1 100644
--- a/derive/src/generate/ser/enum.rs
+++ b/derive/src/generate/ser/enum.rs
@@ -212,7 +212,7 @@ pub fn generate(
 		}
 
 		impl #subject_impl_generics ::linked_data::LinkedDataSubject<I_, V_> for #ident #ty_generics #subject_where_clauses {
-			fn visit_subject<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_subject_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::SubjectVisitor<I_, V_>
 			{
@@ -223,7 +223,7 @@ pub fn generate(
 		}
 
 		impl #predicate_impl_generics ::linked_data::LinkedDataPredicateObjects<I_, V_> for #ident #ty_generics #predicate_where_clauses {
-			fn visit_objects<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_objects_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::PredicateObjectsVisitor<I_, V_>
 			{
@@ -234,7 +234,7 @@ pub fn generate(
 		}
 
 		impl #graph_impl_generics ::linked_data::LinkedDataGraph<I_, V_> for #ident #ty_generics #graph_where_clauses {
-			fn visit_graph<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_graph_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::GraphVisitor<I_, V_>
 			{
@@ -245,7 +245,7 @@ pub fn generate(
 		}
 
 		impl #dataset_impl_generics ::linked_data::LinkedData<I_, V_> for #ident #ty_generics #dataset_where_clauses {
-			fn visit<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::Visitor<I_, V_>
 			{
@@ -393,7 +393,7 @@ fn variant_visit_subject(
 					);
 
 					quote! {
-						visitor.predicate(
+						visitor.visit_predicate(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							#id
 						)?;
@@ -408,7 +408,7 @@ fn variant_visit_subject(
 					vocabulary_bounds.add(inner_ty.visit_vocabulary_bounds);
 
 					quote! {
-						visitor.predicate(
+						visitor.visit_predicate(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							&#inner_id #input
 						)?;
@@ -433,7 +433,7 @@ fn variant_visit_subject(
 				);
 
 				quote! {
-					<#ty as ::linked_data::LinkedDataSubject<I_, V_>>::visit_subject(#id, visitor)
+					<#ty as ::linked_data::LinkedDataSubject<I_, V_>>::accept_subject_visitor(#id, visitor)
 				}
 			}
 			VariantShape::Compound(inner_ty) => {
@@ -444,7 +444,7 @@ fn variant_visit_subject(
 				vocabulary_bounds.add(inner_ty.visit_vocabulary_bounds);
 
 				quote! {
-					#inner_id #input .visit_subject(visitor)
+					#inner_id #input .accept_subject_visitor(visitor)
 				}
 			}
 			VariantShape::Unit => {
@@ -481,7 +481,7 @@ fn variant_visit_predicate(
 						::linked_data::AnonymousBinding(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							#id
-						).visit_objects(visitor)
+						).accept_objects_visitor(visitor)
 					}
 				}
 				VariantShape::Compound(inner_ty) => {
@@ -495,12 +495,12 @@ fn variant_visit_predicate(
 						::linked_data::AnonymousBinding(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							&#inner_id #input
-						).visit_objects(visitor)
+						).accept_objects_visitor(visitor)
 					}
 				}
 				VariantShape::Unit => {
 					quote! {
-						visitor.object(::linked_data::iref::Iri::new(#iri).unwrap())?;
+						visitor.visit_object(::linked_data::iref::Iri::new(#iri).unwrap())?;
 						visitor.end()
 					}
 				}
@@ -516,7 +516,7 @@ fn variant_visit_predicate(
 				);
 
 				quote! {
-					<#ty as ::linked_data::LinkedDataPredicateObjects<I_, V_>>::visit_objects(#id, visitor)
+					<#ty as ::linked_data::LinkedDataPredicateObjects<I_, V_>>::accept_objects_visitor(#id, visitor)
 				}
 			}
 			VariantShape::Compound(inner_ty) => {
@@ -527,7 +527,7 @@ fn variant_visit_predicate(
 				vocabulary_bounds.add(inner_ty.visit_vocabulary_bounds);
 
 				quote! {
-					#inner_id #input .visit_objects(visitor)
+					#inner_id #input .accept_objects_visitor(visitor)
 				}
 			}
 			VariantShape::Unit => {
@@ -564,7 +564,7 @@ fn variant_visit_graph(
 						::linked_data::AnonymousBinding(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							#id
-						).visit_graph(visitor)
+						).accept_graph_visitor(visitor)
 					}
 				}
 				VariantShape::Compound(inner_ty) => {
@@ -578,12 +578,12 @@ fn variant_visit_graph(
 						::linked_data::AnonymousBinding(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							&#inner_id #input
-						).visit_graph(visitor)
+						).accept_graph_visitor(visitor)
 					}
 				}
 				VariantShape::Unit => {
 					quote! {
-						visitor.subject(::linked_data::iref::Iri::new(#iri).unwrap())?;
+						visitor.visit_subject(::linked_data::iref::Iri::new(#iri).unwrap())?;
 						visitor.end()
 					}
 				}
@@ -599,7 +599,7 @@ fn variant_visit_graph(
 				);
 
 				quote! {
-					<#ty as ::linked_data::LinkedDataGraph<I_, V_>>::visit_graph(#id, visitor)
+					<#ty as ::linked_data::LinkedDataGraph<I_, V_>>::accept_graph_visitor(#id, visitor)
 				}
 			}
 			VariantShape::Compound(inner_ty) => {
@@ -610,7 +610,7 @@ fn variant_visit_graph(
 				vocabulary_bounds.add(inner_ty.visit_vocabulary_bounds);
 
 				quote! {
-					#inner_id #input .visit_graph(visitor)
+					#inner_id #input .accept_graph_visitor(visitor)
 				}
 			}
 			VariantShape::Unit => {
@@ -647,7 +647,7 @@ fn variant_serialize(
 						::linked_data::AnonymousBinding(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							#id
-						).visit(visitor)
+						).accept_visitor(visitor)
 					}
 				}
 				VariantShape::Compound(inner_ty) => {
@@ -661,12 +661,12 @@ fn variant_serialize(
 						::linked_data::AnonymousBinding(
 							::linked_data::iref::Iri::new(#iri).unwrap(),
 							&#inner_id #input
-						).visit(visitor)
+						).accept_visitor(visitor)
 					}
 				}
 				VariantShape::Unit => {
 					quote! {
-						visitor.default_graph(::linked_data::iref::Iri::new(#iri).unwrap())?;
+						visitor.visit_default_graph(::linked_data::iref::Iri::new(#iri).unwrap())?;
 						visitor.end()
 					}
 				}
@@ -682,7 +682,7 @@ fn variant_serialize(
 				);
 
 				quote! {
-					<#ty as ::linked_data::LinkedData<I_, V_>>::visit(#id, visitor)
+					<#ty as ::linked_data::LinkedData<I_, V_>>::accept_visitor(#id, visitor)
 				}
 			}
 			VariantShape::Compound(inner_ty) => {
@@ -693,7 +693,7 @@ fn variant_serialize(
 				vocabulary_bounds.add(inner_ty.visit_vocabulary_bounds);
 
 				quote! {
-					#inner_id #input .visit(visitor)
+					#inner_id #input .accept_visitor(visitor)
 				}
 			}
 			VariantShape::Unit => {
@@ -854,7 +854,7 @@ fn variant_subject_type(
 		}
 
 		impl #visit_impl_generics ::linked_data::LinkedDataSubject<I_, V_> for #subject_id #ty_generics #visit_where_clauses {
-			fn visit_subject<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_subject_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::SubjectVisitor<I_, V_>
 			{
@@ -864,31 +864,31 @@ fn variant_subject_type(
 		}
 
 		impl #visit_impl_generics ::linked_data::LinkedDataPredicateObjects<I_, V_> for #subject_id #ty_generics #visit_where_clauses {
-			fn visit_objects<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_objects_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::PredicateObjectsVisitor<I_, V_>
 			{
-				visitor.object(self)?;
+				visitor.visit_object(self)?;
 				visitor.end()
 			}
 		}
 
 		impl #visit_impl_generics ::linked_data::LinkedDataGraph<I_, V_> for #subject_id #ty_generics #visit_where_clauses {
-			fn visit_graph<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_graph_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::GraphVisitor<I_, V_>
 			{
-				visitor.subject(self)?;
+				visitor.visit_subject(self)?;
 				visitor.end()
 			}
 		}
 
 		impl #visit_impl_generics ::linked_data::LinkedData<I_, V_> for #subject_id #ty_generics #visit_where_clauses {
-			fn visit<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::Visitor<I_, V_>
 			{
-				visitor.default_graph(self)?;
+				visitor.visit_default_graph(self)?;
 				visitor.end()
 			}
 		}
diff --git a/derive/src/generate/ser/struct.rs b/derive/src/generate/ser/struct.rs
index 9310527..43f5508 100644
--- a/derive/src/generate/ser/struct.rs
+++ b/derive/src/generate/ser/struct.rs
@@ -36,7 +36,7 @@ pub fn generate(
 			let rdf_type = RDF_TYPE.as_str();
 
 			Ok(quote! {
-				visitor.predicate(
+				visitor.visit_predicate(
 					::linked_data::iref::Iri::new(#rdf_type).unwrap(),
 					::linked_data::iref::Iri::new(#iri).unwrap()
 				)?;
@@ -86,7 +86,7 @@ pub fn generate(
 		}
 
 		impl #impl_generics ::linked_data::LinkedDataSubject<I_, V_> for #ident #ty_generics #where_clause {
-			fn visit_subject<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_subject_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::SubjectVisitor<I_, V_>
 			{
@@ -96,31 +96,31 @@ pub fn generate(
 		}
 
 		impl #impl_generics ::linked_data::LinkedDataPredicateObjects<I_, V_> for #ident #ty_generics #where_clause {
-			fn visit_objects<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_objects_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::PredicateObjectsVisitor<I_, V_>
 			{
-				visitor.object(self)?;
+				visitor.visit_object(self)?;
 				visitor.end()
 			}
 		}
 
 		impl #impl_generics ::linked_data::LinkedDataGraph<I_, V_> for #ident #ty_generics #where_clause {
-			fn visit_graph<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_graph_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::GraphVisitor<I_, V_>
 			{
-				visitor.subject(self)?;
+				visitor.visit_subject(self)?;
 				visitor.end()
 			}
 		}
 
 		impl #impl_generics ::linked_data::LinkedData<I_, V_> for #ident #ty_generics #where_clause {
-			fn visit<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
+			fn accept_visitor<S_>(&self, mut visitor: S_) -> Result<S_::Ok, S_::Error>
 			where
 				S_: ::linked_data::Visitor<I_, V_>
 			{
-				visitor.default_graph(self)?;
+				visitor.visit_default_graph(self)?;
 				visitor.end()
 			}
 		}
diff --git a/src/anonymous.rs b/src/anonymous.rs
index 5b037bd..49d32da 100644
--- a/src/anonymous.rs
+++ b/src/anonymous.rs
@@ -14,7 +14,7 @@ impl<'a, T> AnonymousBinding<'a, T> {
 	}
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, T> LinkedDataResource<I, V> for AnonymousBinding<'a, T> {
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataResource<I, V> for AnonymousBinding<'_, T> {
 	fn interpretation(
 		&self,
 		_vocabulary: &mut V,
@@ -24,66 +24,59 @@ impl<'a, I: Interpretation, V: Vocabulary, T> LinkedDataResource<I, V> for Anony
 	}
 }
 
-impl<
-		'a,
-		V: Vocabulary + IriVocabularyMut,
-		I: Interpretation,
-		T: LinkedDataPredicateObjects<I, V>,
-	> LinkedDataSubject<I, V> for AnonymousBinding<'a, T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataSubject<I, V> for AnonymousBinding<'_, T>
+where
+	V: IriVocabularyMut,
+	T: LinkedDataPredicateObjects<I, V>,
 {
-	fn visit_subject<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		serializer.predicate(self.0, self.1)?;
-		serializer.end()
+		visitor.visit_predicate(self.0, self.1)?;
+		visitor.end()
 	}
 }
 
-impl<
-		'a,
-		V: Vocabulary + IriVocabularyMut,
-		I: Interpretation,
-		T: LinkedDataPredicateObjects<I, V>,
-	> LinkedDataPredicateObjects<I, V> for AnonymousBinding<'a, T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V>
+	for AnonymousBinding<'_, T>
+where
+	V: IriVocabularyMut,
+	T: LinkedDataPredicateObjects<I, V>,
 {
-	fn visit_objects<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		serializer.object(self)?;
-		serializer.end()
+		visitor.visit_object(self)?;
+		visitor.end()
 	}
 }
 
-impl<
-		'a,
-		V: Vocabulary + IriVocabularyMut,
-		I: Interpretation,
-		T: LinkedDataPredicateObjects<I, V>,
-	> LinkedDataGraph<I, V> for AnonymousBinding<'a, T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataGraph<I, V> for AnonymousBinding<'_, T>
+where
+	V: IriVocabularyMut,
+	T: LinkedDataPredicateObjects<I, V>,
 {
-	fn visit_graph<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
-		serializer.subject(self)?;
-		serializer.end()
+		visitor.visit_subject(self)?;
+		visitor.end()
 	}
 }
 
-impl<
-		'a,
-		V: Vocabulary + IriVocabularyMut,
-		I: Interpretation,
-		T: LinkedDataPredicateObjects<I, V>,
-	> LinkedData<I, V> for AnonymousBinding<'a, T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedData<I, V> for AnonymousBinding<'_, T>
+where
+	V: IriVocabularyMut,
+	T: LinkedDataPredicateObjects<I, V>,
 {
-	fn visit<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: Visitor<I, V>,
 	{
-		serializer.default_graph(self)?;
-		serializer.end()
+		visitor.visit_default_graph(self)?;
+		visitor.end()
 	}
 }
diff --git a/src/datatypes/ser.rs b/src/datatypes/ser.rs
index 94df846..a1b3c5b 100644
--- a/src/datatypes/ser.rs
+++ b/src/datatypes/ser.rs
@@ -24,7 +24,7 @@ macro_rules! datatype {
 			}
 
 			impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation> LinkedDataSubject<I, V> for $ty {
-				fn visit_subject<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+				fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 				where
 					S: crate::SubjectVisitor<I, V>
 				{
@@ -33,11 +33,11 @@ macro_rules! datatype {
 			}
 
 			impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation> LinkedDataPredicateObjects<I, V> for $ty {
-				fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+				fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 				where
 					S: PredicateObjectsVisitor<I, V>,
 				{
-					visitor.object(self)?;
+					visitor.visit_object(self)?;
 					visitor.end()
 				}
 			}
@@ -61,7 +61,7 @@ macro_rules! unsized_datatype {
 			}
 
 			impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation> LinkedDataSubject<I, V> for $ty {
-				fn visit_subject<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+				fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 				where
 					S: crate::SubjectVisitor<I, V>
 				{
@@ -70,11 +70,11 @@ macro_rules! unsized_datatype {
 			}
 
 			impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation> LinkedDataPredicateObjects<I, V> for $ty {
-				fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+				fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 				where
 					S: PredicateObjectsVisitor<I, V>,
 				{
-					visitor.object(self)?;
+					visitor.visit_object(self)?;
 					visitor.end()
 				}
 			}
@@ -126,7 +126,7 @@ impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation>
 impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation>
 	LinkedDataSubject<I, V> for xsd_types::AnyUriBuf
 {
-	fn visit_subject<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::SubjectVisitor<I, V>,
 	{
@@ -137,11 +137,11 @@ impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation>
 impl<V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut, I: Interpretation>
 	LinkedDataPredicateObjects<I, V> for xsd_types::AnyUriBuf
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		visitor.object(self)?;
+		visitor.visit_object(self)?;
 		visitor.end()
 	}
 }
diff --git a/src/graph.rs b/src/graph.rs
index b5669a8..776eacc 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -5,15 +5,14 @@ use crate::{LinkedData, LinkedDataPredicateObjects, LinkedDataResource, LinkedDa
 
 // use crate::SerializeSubject;
 
-/// Serialize a Linked-Data graph.
 pub trait LinkedDataGraph<I: Interpretation, V: Vocabulary> {
-	fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>;
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataGraph<I, V> for () {
-	fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
@@ -21,30 +20,32 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataGraph<I, V> for () {
 	}
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataGraph<I, V>> LinkedDataGraph<I, V>
-	for &'a T
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataGraph<I, V> for &T
+where
+	T: ?Sized + LinkedDataGraph<I, V>,
 {
-	fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
-		T::visit_graph(self, visitor)
+		T::accept_graph_visitor(self, visitor)
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataGraph<I, V>> LinkedDataGraph<I, V>
-	for Box<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataGraph<I, V> for Box<T>
+where
+	T: ?Sized + LinkedDataGraph<I, V>,
 {
-	fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
-		T::visit_graph(self, visitor)
+		T::accept_graph_visitor(self, visitor)
 	}
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataGraph<I, V> for Iri {
-	fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
@@ -53,7 +54,7 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataGraph<I, V> for Iri {
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataGraph<I, V> for IriBuf {
-	fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
@@ -61,29 +62,31 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataGraph<I, V> for IriBuf {
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>>
-	LinkedDataGraph<I, V> for [T]
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataGraph<I, V> for [T]
+where
+	T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>,
 {
-	fn visit_graph<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
 		for t in self {
-			visitor.subject(t)?;
+			visitor.visit_subject(t)?;
 		}
 		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>>
-	LinkedDataGraph<I, V> for Vec<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataGraph<I, V> for Vec<T>
+where
+	T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>,
 {
-	fn visit_graph<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
 		for t in self {
-			visitor.subject(t)?;
+			visitor.visit_subject(t)?;
 		}
 		visitor.end()
 	}
@@ -93,22 +96,25 @@ pub trait GraphVisitor<I: Interpretation, V: Vocabulary> {
 	type Ok;
 	type Error;
 
-	fn subject<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_subject<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataSubject<I, V>;
 
 	fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, S: GraphVisitor<I, V>> GraphVisitor<I, V> for &'a mut S {
+impl<I: Interpretation, V: Vocabulary, S> GraphVisitor<I, V> for &mut S
+where
+	S: GraphVisitor<I, V>,
+{
 	type Ok = ();
 	type Error = S::Error;
 
-	fn subject<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_subject<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataSubject<I, V>,
 	{
-		S::subject(self, value)
+		S::visit_subject(self, value)
 	}
 
 	fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -128,49 +134,53 @@ impl<I: Interpretation, V: Vocabulary, T> LinkedDataResource<I, V> for Anonymous
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataGraph<I, V>> LinkedDataSubject<I, V>
-	for AnonymousGraph<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataSubject<I, V> for AnonymousGraph<T>
+where
+	T: LinkedDataGraph<I, V>,
 {
-	fn visit_subject<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::SubjectVisitor<I, V>,
 	{
-		serializer.graph(&self.0)?;
-		serializer.end()
+		visitor.visit_graph(&self.0)?;
+		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataGraph<I, V>> LinkedDataPredicateObjects<I, V>
-	for AnonymousGraph<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V> for AnonymousGraph<T>
+where
+	T: LinkedDataGraph<I, V>,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::PredicateObjectsVisitor<I, V>,
 	{
-		visitor.object(self)?;
+		visitor.visit_object(self)?;
 		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataGraph<I, V>> LinkedDataGraph<I, V>
-	for AnonymousGraph<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataGraph<I, V> for AnonymousGraph<T>
+where
+	T: LinkedDataGraph<I, V>,
 {
-	fn visit_graph<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
-		T::visit_graph(&self.0, visitor)
+		T::accept_graph_visitor(&self.0, visitor)
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataGraph<I, V>> LinkedData<I, V>
-	for AnonymousGraph<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedData<I, V> for AnonymousGraph<T>
+where
+	T: LinkedDataGraph<I, V>,
 {
-	fn visit<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::Visitor<I, V>,
 	{
-		visitor.named_graph(self)?;
+		visitor.visit_named_graph(self)?;
 		visitor.end()
 	}
 }
diff --git a/src/impl/rdf_types/dataset_graph_view.rs b/src/impl/rdf_types/dataset_graph_view.rs
index 068cfc7..2f11876 100644
--- a/src/impl/rdf_types/dataset_graph_view.rs
+++ b/src/impl/rdf_types/dataset_graph_view.rs
@@ -9,12 +9,12 @@ use crate::{
 	ResourceInterpretation, SubjectVisitor,
 };
 
-impl<'a, I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for DatasetGraphView<'a, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for DatasetGraphView<'_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: PredicateTraversableDataset<Resource = I::Resource> + PatternMatchingDataset,
 {
-	fn visit_subject<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, mut serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
@@ -35,13 +35,13 @@ struct PredicateObjects<'d, 'v, D: Dataset> {
 	visited: &'v im::HashSet<&'d D::Resource>,
 }
 
-impl<'d, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataPredicateObjects<I, V>
-	for PredicateObjects<'d, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataPredicateObjects<I, V>
+	for PredicateObjects<'_, '_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: PredicateTraversableDataset<Resource = I::Resource> + PatternMatchingDataset,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
@@ -49,7 +49,7 @@ where
 			.dataset
 			.quad_objects(self.graph, self.subject, self.predicate)
 		{
-			visitor.object(&Object {
+			visitor.visit_object(&Object {
 				dataset: self.dataset,
 				graph: self.graph,
 				object,
@@ -61,8 +61,8 @@ where
 	}
 }
 
-impl<'a, 'v, I: Interpretation, V: Vocabulary, D: Dataset<Resource = I::Resource>>
-	LinkedDataResource<I, V> for Object<'a, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D: Dataset<Resource = I::Resource>> LinkedDataResource<I, V>
+	for Object<'_, '_, D>
 where
 	I::Resource: LinkedDataResource<I, V>,
 {
@@ -82,12 +82,12 @@ struct Object<'d, 'v, D: Dataset> {
 	visited: &'v im::HashSet<&'d D::Resource>,
 }
 
-impl<'d, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Object<'d, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Object<'_, '_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: PredicateTraversableDataset<Resource = I::Resource> + PatternMatchingDataset,
 {
-	fn visit_subject<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
@@ -145,7 +145,7 @@ impl<'d, 'v, D: PredicateTraversableDataset + PatternMatchingDataset> Subject<'d
 			.dataset
 			.quad_predicates_objects(self.graph, self.subject)
 		{
-			visitor.predicate(
+			visitor.visit_predicate(
 				predicate,
 				&PredicateObjects {
 					dataset: self.dataset,
@@ -161,12 +161,12 @@ impl<'d, 'v, D: PredicateTraversableDataset + PatternMatchingDataset> Subject<'d
 	}
 }
 
-impl<'d, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Subject<'d, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Subject<'_, '_, D>
 where
 	D::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: PredicateTraversableDataset<Resource = I::Resource> + PatternMatchingDataset,
 {
-	fn visit_subject<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
@@ -175,7 +175,7 @@ where
 				.dataset
 				.quad_predicates_objects(self.graph, self.subject)
 			{
-				visitor.predicate(
+				visitor.visit_predicate(
 					predicate,
 					&PredicateObjects {
 						dataset: self.dataset,
diff --git a/src/impl/rdf_types/dataset_view.rs b/src/impl/rdf_types/dataset_view.rs
index f91dfe8..f12dc8f 100644
--- a/src/impl/rdf_types/dataset_view.rs
+++ b/src/impl/rdf_types/dataset_view.rs
@@ -11,14 +11,14 @@ use rdf_types::{
 	Dataset, Interpretation, Quad, Vocabulary,
 };
 
-impl<'a, I: Interpretation, V: Vocabulary, D> LinkedDataGraph<I, V> for DatasetView<'a, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataGraph<I, V> for DatasetView<'_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: SubjectTraversableDataset<Resource = I::Resource>
 		+ PredicateTraversableDataset
 		+ PatternMatchingDataset,
 {
-	fn visit_graph<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
@@ -44,7 +44,7 @@ where
 		}
 
 		for subject in graph_subjects {
-			visitor.subject(&Subject::new(
+			visitor.visit_subject(&Subject::new(
 				self.dataset,
 				self.graph,
 				subject,
@@ -67,15 +67,15 @@ struct PredicateObjects<'d, 'v, D: Dataset> {
 	visited_graphs: &'v im::HashSet<&'d D::Resource>,
 }
 
-impl<'d, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataPredicateObjects<I, V>
-	for PredicateObjects<'d, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataPredicateObjects<I, V>
+	for PredicateObjects<'_, '_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: SubjectTraversableDataset<Resource = I::Resource>
 		+ PredicateTraversableDataset
 		+ PatternMatchingDataset,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
@@ -83,7 +83,7 @@ where
 			.dataset
 			.quad_objects(self.graph, self.subject, self.predicate)
 		{
-			visitor.object(&Object {
+			visitor.visit_object(&Object {
 				dataset: self.dataset,
 				graph: self.graph,
 				object,
@@ -96,7 +96,7 @@ where
 	}
 }
 
-impl<'a, 'v, D, I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for Object<'a, 'v, D>
+impl<D, I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for Object<'_, '_, D>
 where
 	I::Resource: LinkedDataResource<I, V>,
 	D: Dataset<Resource = I::Resource>,
@@ -118,14 +118,14 @@ struct Object<'a, 'v, D: Dataset> {
 	visited_graphs: &'v im::HashSet<&'a D::Resource>,
 }
 
-impl<'a, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Object<'a, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Object<'_, '_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: SubjectTraversableDataset
 		+ PredicateTraversableDataset<Resource = I::Resource>
 		+ PatternMatchingDataset,
 {
-	fn visit_subject<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
@@ -196,7 +196,7 @@ where
 				.dataset
 				.quad_predicates_objects(self.graph, self.subject)
 			{
-				visitor.predicate(
+				visitor.visit_predicate(
 					predicate,
 					&PredicateObjects {
 						dataset: self.dataset,
@@ -212,7 +212,7 @@ where
 			if self.dataset.contains_named_graph(self.subject) {
 				let mut visited_graphs = self.visited_graphs.clone();
 				if visited_graphs.insert(self.subject).is_none() {
-					visitor.graph(&NamedGraphView {
+					visitor.visit_graph(&NamedGraphView {
 						dataset: self.dataset,
 						graph: self.subject,
 						visited_graphs: &visited_graphs,
@@ -225,7 +225,7 @@ where
 	}
 }
 
-impl<'a, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataResource<I, V> for Subject<'a, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataResource<I, V> for Subject<'_, '_, D>
 where
 	I::Resource: LinkedDataResource<I, V>,
 	D: Dataset<Resource = I::Resource>,
@@ -239,14 +239,14 @@ where
 	}
 }
 
-impl<'a, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Subject<'a, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataSubject<I, V> for Subject<'_, '_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: SubjectTraversableDataset<Resource = I::Resource>
 		+ PredicateTraversableDataset
 		+ PatternMatchingDataset,
 {
-	fn visit_subject<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
@@ -254,7 +254,7 @@ where
 			.dataset
 			.quad_predicates_objects(self.graph, self.subject)
 		{
-			visitor.predicate(
+			visitor.visit_predicate(
 				predicate,
 				&PredicateObjects {
 					dataset: self.dataset,
@@ -277,8 +277,8 @@ struct NamedGraphView<'a, 'v, D: Dataset> {
 	visited_graphs: &'v im::HashSet<&'a D::Resource>,
 }
 
-impl<'a, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataResource<I, V>
-	for NamedGraphView<'a, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataResource<I, V>
+	for NamedGraphView<'_, '_, D>
 where
 	I::Resource: LinkedDataResource<I, V>,
 	D: Dataset<Resource = I::Resource>,
@@ -292,15 +292,15 @@ where
 	}
 }
 
-impl<'a, 'v, I: Interpretation, V: Vocabulary, D> LinkedDataGraph<I, V>
-	for NamedGraphView<'a, 'v, D>
+impl<I: Interpretation, V: Vocabulary, D> LinkedDataGraph<I, V>
+	for NamedGraphView<'_, '_, D>
 where
 	I::Resource: Eq + Hash + LinkedDataResource<I, V>,
 	D: SubjectTraversableDataset<Resource = I::Resource>
 		+ PredicateTraversableDataset
 		+ PatternMatchingDataset,
 {
-	fn visit_graph<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: GraphVisitor<I, V>,
 	{
@@ -322,7 +322,7 @@ where
 		}
 
 		for subject in graph_subjects {
-			visitor.subject(&Subject::new(
+			visitor.visit_subject(&Subject::new(
 				self.dataset,
 				Some(self.graph),
 				subject,
diff --git a/src/lib.rs b/src/lib.rs
index 5cb4f49..391ef41 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -161,33 +161,37 @@ impl FromLinkedDataError {
 /// [`visit`](Self::visit) method.
 pub trait LinkedData<I: Interpretation = (), V: Vocabulary = ()> {
 	/// Visit the RDF dataset represented by this type.
-	fn visit<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: Visitor<I, V>;
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, T: ?Sized + LinkedData<I, V>> LinkedData<I, V>
-	for &'a T
+impl<I: Interpretation, V: Vocabulary, T> LinkedData<I, V> for &T
+where
+	T: ?Sized + LinkedData<I, V>,
 {
-	fn visit<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: Visitor<I, V>,
 	{
-		T::visit(self, visitor)
+		T::accept_visitor(self, visitor)
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: ?Sized + LinkedData<I, V>> LinkedData<I, V> for Box<T> {
-	fn visit<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+impl<I: Interpretation, V: Vocabulary, T> LinkedData<I, V> for Box<T>
+where
+	T: ?Sized + LinkedData<I, V>,
+{
+	fn accept_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: Visitor<I, V>,
 	{
-		T::visit(self, visitor)
+		T::accept_visitor(self, visitor)
 	}
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedData<I, V> for Iri {
-	fn visit<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: Visitor<I, V>,
 	{
@@ -205,12 +209,12 @@ pub trait Visitor<I: Interpretation = (), V: Vocabulary = ()> {
 	type Error;
 
 	/// Visits the default graph of the dataset.
-	fn default_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_default_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataGraph<I, V>;
 
 	/// Visits a named graph of the dataset.
-	fn named_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_named_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataGraph<I, V>;
 
@@ -219,22 +223,25 @@ pub trait Visitor<I: Interpretation = (), V: Vocabulary = ()> {
 }
 
 /// Any mutable reference to a visitor is itself a visitor.
-impl<'s, I: Interpretation, V: Vocabulary, S: Visitor<I, V>> Visitor<I, V> for &'s mut S {
+impl<I: Interpretation, V: Vocabulary, S> Visitor<I, V> for &mut S
+where
+	S: Visitor<I, V>,
+{
 	type Ok = ();
 	type Error = S::Error;
 
-	fn default_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_default_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataGraph<I, V>,
 	{
-		S::default_graph(self, value)
+		S::visit_default_graph(self, value)
 	}
 
-	fn named_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_named_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataGraph<I, V>,
 	{
-		S::named_graph(self, value)
+		S::visit_named_graph(self, value)
 	}
 
 	fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -250,7 +257,7 @@ pub enum ResourceOrIriRef<'a, I: Interpretation> {
 	Anonymous,
 }
 
-impl<'a, I: Interpretation> ResourceOrIriRef<'a, I> {
+impl<I: Interpretation> ResourceOrIriRef<'_, I> {
 	pub fn into_iri<V>(self, vocabulary: &V, interpretation: &I) -> Option<IriBuf>
 	where
 		V: IriVocabulary,
@@ -347,7 +354,7 @@ pub enum ContextIris {
 	},
 }
 
-impl<'a, I: Interpretation> Default for Context<'a, I> {
+impl<I: Interpretation> Default for Context<'_, I> {
 	fn default() -> Self {
 		Self::Subject
 	}
diff --git a/src/macros.rs b/src/macros.rs
index a411679..a76efaf 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -19,11 +19,11 @@ macro_rules! json_literal {
 		}
 
 		impl<V: $crate::rdf_types::Vocabulary, I: $crate::rdf_types::Interpretation> $crate::LinkedDataPredicateObjects<I, V> for $ty {
-			fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+			fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 			where
 				S: $crate::PredicateObjectsVisitor<I, V>,
 			{
-				visitor.object(self)?;
+				visitor.visit_object(self)?;
 				visitor.end()
 			}
 		}
@@ -66,7 +66,7 @@ macro_rules! json_literal {
 		}
 
 		impl<V: $crate::rdf_types::Vocabulary, I: $crate::rdf_types::Interpretation> $crate::LinkedDataSubject<I, V> for $ty {
-			fn visit_subject<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+			fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 			where
 				S: $crate::SubjectVisitor<I, V>,
 			{
diff --git a/src/predicate.rs b/src/predicate.rs
index 1d401a8..c2d320d 100644
--- a/src/predicate.rs
+++ b/src/predicate.rs
@@ -15,13 +15,13 @@ use crate::{
 
 /// Type representing the objects of an RDF subject's predicate binding.
 pub trait LinkedDataPredicateObjects<I: Interpretation = (), V: Vocabulary = ()> {
-	fn visit_objects<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>;
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataPredicateObjects<I, V> for () {
-	fn visit_objects<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
@@ -29,67 +29,72 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataPredicateObjects<I, V> for () {
 	}
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataPredicateObjects<I, V>>
-	LinkedDataPredicateObjects<I, V> for &'a T
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V> for &T
+where
+	T: ?Sized + LinkedDataPredicateObjects<I, V>,
 {
-	fn visit_objects<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		T::visit_objects(self, visitor)
+		T::accept_objects_visitor(self, visitor)
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataPredicateObjects<I, V>>
-	LinkedDataPredicateObjects<I, V> for Box<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V> for Box<T>
+where
+	T: ?Sized + LinkedDataPredicateObjects<I, V>,
 {
-	fn visit_objects<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		T::visit_objects(self, visitor)
+		T::accept_objects_visitor(self, visitor)
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>>
-	LinkedDataPredicateObjects<I, V> for Option<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V> for Option<T>
+where
+	T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
 		if let Some(t) = self {
-			visitor.object(t)?;
+			visitor.visit_object(t)?;
 		}
 
 		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>>
-	LinkedDataPredicateObjects<I, V> for [T]
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V> for [T]
+where
+	T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
 		for t in self {
-			visitor.object(t)?;
+			visitor.visit_object(t)?;
 		}
 
 		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>>
-	LinkedDataPredicateObjects<I, V> for Vec<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V> for Vec<T>
+where
+	T: LinkedDataSubject<I, V> + LinkedDataResource<I, V>,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
 		for t in self {
-			visitor.object(t)?;
+			visitor.visit_object(t)?;
 		}
 
 		visitor.end()
@@ -100,11 +105,11 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataPredicateObjects<I, V> for Iri
 where
 	V: IriVocabularyMut,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		visitor.object(self)?;
+		visitor.visit_object(self)?;
 		visitor.end()
 	}
 }
@@ -113,11 +118,11 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataPredicateObjects<I, V> for IriB
 where
 	V: IriVocabularyMut,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		visitor.object(self)?;
+		visitor.visit_object(self)?;
 		visitor.end()
 	}
 }
@@ -126,11 +131,11 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataPredicateObjects<I, V> for Blan
 where
 	V: BlankIdVocabularyMut,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		visitor.object(self)?;
+		visitor.visit_object(self)?;
 		visitor.end()
 	}
 }
@@ -139,11 +144,11 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataPredicateObjects<I, V> for Blan
 where
 	V: BlankIdVocabularyMut,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
-		visitor.object(self)?;
+		visitor.visit_object(self)?;
 		visitor.end()
 	}
 }
@@ -153,13 +158,13 @@ where
 	T: LinkedDataPredicateObjects<I, V>,
 	B: LinkedDataPredicateObjects<I, V>,
 {
-	fn visit_objects<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: PredicateObjectsVisitor<I, V>,
 	{
 		match self {
-			Self::Iri(i) => i.visit_objects(visitor),
-			Self::Blank(b) => b.visit_objects(visitor),
+			Self::Iri(i) => i.accept_objects_visitor(visitor),
+			Self::Blank(b) => b.accept_objects_visitor(visitor),
 		}
 	}
 }
@@ -168,7 +173,7 @@ pub trait PredicateObjectsVisitor<I: Interpretation, V: Vocabulary> {
 	type Ok;
 	type Error;
 
-	fn object<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_object<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataSubject<I, V>;
 
@@ -274,8 +279,9 @@ where
 	deserialize_single_object!();
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataDeserializePredicateObjects<I, V>>
-	LinkedDataDeserializePredicateObjects<I, V> for Box<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataDeserializePredicateObjects<I, V> for Box<T>
+where
+	T: LinkedDataDeserializePredicateObjects<I, V>,
 {
 	fn deserialize_objects_in<'a, D>(
 		vocabulary: &V,
@@ -294,10 +300,10 @@ impl<I: Interpretation, V: Vocabulary, T: LinkedDataDeserializePredicateObjects<
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataDeserializeSubject<I, V>>
-	LinkedDataDeserializePredicateObjects<I, V> for Option<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataDeserializePredicateObjects<I, V> for Option<T>
 where
 	I: ReverseIriInterpretation<Iri = V::Iri>,
+	T: LinkedDataDeserializeSubject<I, V>,
 {
 	fn deserialize_objects_in<'a, D>(
 		vocabulary: &V,
diff --git a/src/quads.rs b/src/quads.rs
index 041163f..2475cc7 100644
--- a/src/quads.rs
+++ b/src/quads.rs
@@ -18,19 +18,21 @@ use crate::{
 	SubjectVisitor, Visitor,
 };
 
-pub fn to_interpreted_quads<I: Interpretation, V: Vocabulary>(
+pub fn to_interpreted_quads<I, V>(
 	vocabulary: &mut V,
 	interpretation: &mut I,
 	value: &impl LinkedData<I, V>,
 ) -> Result<Vec<InterpretedQuad<I>>, IntoQuadsError>
 where
-	I: InterpretationMut<V> + TermInterpretationMut<V::Iri, V::BlankId, V::Literal>,
-	I::Resource: Clone,
-	V: IriVocabularyMut + LiteralVocabularyMut,
+	V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut,
 	V::Iri: Clone,
 	V::BlankId: Clone,
+	I: Interpretation
+		+ InterpretationMut<V>
+		+ TermInterpretationMut<V::Iri, V::BlankId, V::Literal>,
+	I::Resource: Clone,
 {
-	value.visit(QuadSerializer {
+	value.accept_visitor(QuadSerializer {
 		vocabulary,
 		interpretation,
 		domain: &mut InterpretationDomain,
@@ -38,21 +40,22 @@ where
 	})
 }
 
-pub fn to_interpreted_subject_quads<I: Interpretation, V: Vocabulary>(
+pub fn to_interpreted_subject_quads<I, V>(
 	vocabulary: &mut V,
 	interpretation: &mut I,
 	graph: Option<&I::Resource>,
 	value: &(impl LinkedDataSubject<I, V> + LinkedDataResource<I, V>),
 ) -> Result<(I::Resource, Vec<InterpretedQuad<I>>), IntoQuadsError>
 where
-	I: InterpretationMut<V>
+	V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut,
+	V::Iri: Clone,
+	V::BlankId: Clone,
+	I: Interpretation
+		+ InterpretationMut<V>
 		+ IriInterpretationMut<V::Iri>
 		+ BlankIdInterpretationMut<V::BlankId>
 		+ LiteralInterpretationMut<V::Literal>,
 	I::Resource: Clone,
-	V: IriVocabularyMut + LiteralVocabularyMut,
-	V::Iri: Clone,
-	V::BlankId: Clone,
 {
 	let mut result = Vec::new();
 
@@ -61,7 +64,7 @@ where
 		ResourceInterpretation::Uninterpreted(_) => interpretation.new_resource(vocabulary),
 	};
 
-	value.visit_subject(QuadPropertiesSerializer {
+	value.accept_subject_visitor(QuadPropertiesSerializer {
 		vocabulary,
 		interpretation,
 		domain: &mut InterpretationDomain,
@@ -73,20 +76,21 @@ where
 	Ok((subject, result))
 }
 
-pub fn to_interpreted_graph_quads<I: Interpretation, V: Vocabulary>(
+pub fn to_interpreted_graph_quads<I, V>(
 	vocabulary: &mut V,
 	interpretation: &mut I,
 	value: &(impl LinkedDataGraph<I, V> + LinkedDataResource<I, V>),
 ) -> Result<(I::Resource, Vec<InterpretedQuad<I>>), IntoQuadsError>
 where
-	I: InterpretationMut<V>
+	V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut,
+	V::Iri: Clone,
+	V::BlankId: Clone,
+	I: Interpretation
+		+ InterpretationMut<V>
 		+ IriInterpretationMut<V::Iri>
 		+ BlankIdInterpretationMut<V::BlankId>
 		+ LiteralInterpretationMut<V::Literal>,
 	I::Resource: Clone,
-	V: IriVocabularyMut + LiteralVocabularyMut,
-	V::Iri: Clone,
-	V::BlankId: Clone,
 {
 	let mut result = Vec::new();
 
@@ -95,7 +99,7 @@ where
 		ResourceInterpretation::Uninterpreted(_) => interpretation.new_resource(vocabulary),
 	};
 
-	value.visit_graph(QuadGraphSerializer {
+	value.accept_graph_visitor(QuadGraphSerializer {
 		vocabulary,
 		interpretation,
 		domain: &mut InterpretationDomain,
@@ -106,18 +110,20 @@ where
 	Ok((graph, result))
 }
 
-pub fn to_lexical_quads_with<I: Interpretation, V: Vocabulary>(
+pub fn to_lexical_quads_with<I, V>(
 	vocabulary: &mut V,
 	interpretation: &mut I,
 	value: &impl LinkedData<I, V>,
 ) -> Result<Vec<RdfQuad>, IntoQuadsError>
 where
-	I: InterpretationMut<V>
+	V: Vocabulary,
+	I: Interpretation
+		+ InterpretationMut<V>
 		+ ReverseTermInterpretation<Iri = V::Iri, BlankId = V::BlankId, Literal = V::Literal>,
 {
 	let mut domain = LexicalDomain;
 
-	value.visit(QuadSerializer {
+	value.accept_visitor(QuadSerializer {
 		vocabulary,
 		interpretation,
 		domain: &mut domain,
@@ -125,14 +131,16 @@ where
 	})
 }
 
-pub fn to_lexical_subject_quads_with<I: Interpretation, V: Vocabulary>(
+pub fn to_lexical_subject_quads_with<I, V>(
 	vocabulary: &mut V,
 	interpretation: &mut I,
 	graph: Option<&Id>,
 	value: &(impl LinkedDataSubject<I, V> + LinkedDataResource<I, V>),
 ) -> Result<(Id, Vec<RdfQuad>), IntoQuadsError>
 where
-	I: InterpretationMut<V>
+	V: Vocabulary,
+	I: Interpretation
+		+ InterpretationMut<V>
 		+ ReverseTermInterpretation<Iri = V::Iri, BlankId = V::BlankId, Literal = V::Literal>,
 	I::Resource: Clone,
 {
@@ -141,7 +149,7 @@ where
 	let i = value.interpretation(vocabulary, interpretation);
 	let subject = LexicalDomain.subject(vocabulary, interpretation, i)?;
 
-	value.visit_subject(QuadPropertiesSerializer {
+	value.accept_subject_visitor(QuadPropertiesSerializer {
 		vocabulary,
 		interpretation,
 		domain: &mut LexicalDomain,
@@ -171,21 +179,22 @@ pub fn to_lexical_subject_quads<G: Generator>(
 	to_lexical_subject_quads_with(&mut (), &mut interpretation, graph, value)
 }
 
-pub fn to_quads_with<I: InterpretationMut<V>, V: Vocabulary>(
+pub fn to_quads_with<I, V>(
 	vocabulary: &mut V,
 	interpretation: &mut I,
 	value: &impl LinkedData<I, V>,
 ) -> Result<Vec<RdfQuad<V>>, IntoQuadsError>
 where
-	V: IriVocabularyMut + LiteralVocabularyMut,
+	V: Vocabulary + IriVocabularyMut + LiteralVocabularyMut,
 	V::BlankId: Clone,
 	V::Iri: Clone,
 	V::Literal: Clone,
+	I: InterpretationMut<V>,
 	I: ReverseTermInterpretation<Iri = V::Iri, BlankId = V::BlankId, Literal = V::Literal>,
 {
 	let mut domain = VocabularyDomain;
 
-	value.visit(QuadSerializer {
+	value.accept_visitor(QuadSerializer {
 		vocabulary,
 		interpretation,
 		domain: &mut domain,
@@ -331,7 +340,13 @@ where
 	type Subject = RdfId<V>;
 	type Predicate = V::Iri;
 	type Object = Term<RdfId<V>, V::Literal>;
-	type ObjectRef<'a> = Term<&'a RdfId<V>, &'a V::Literal> where V::Iri: 'a, V::BlankId: 'a, V::Literal: 'a, I::Resource: 'a;
+	type ObjectRef<'a>
+		= Term<&'a RdfId<V>, &'a V::Literal>
+	where
+		V::Iri: 'a,
+		V::BlankId: 'a,
+		V::Literal: 'a,
+		I::Resource: 'a;
 
 	fn subject(
 		&mut self,
@@ -502,7 +517,13 @@ where
 	type Subject = I::Resource;
 	type Predicate = I::Resource;
 	type Object = I::Resource;
-	type ObjectRef<'a> = &'a I::Resource where V::Iri: 'a, V::BlankId: 'a, V::Literal: 'a, I::Resource: 'a;
+	type ObjectRef<'a>
+		= &'a I::Resource
+	where
+		V::Iri: 'a,
+		V::BlankId: 'a,
+		V::Literal: 'a,
+		I::Resource: 'a;
 
 	fn subject(
 		&mut self,
@@ -715,7 +736,13 @@ where
 	type Subject = Id;
 	type Predicate = IriBuf;
 	type Object = Term;
-	type ObjectRef<'a> = Term<&'a Id, &'a rdf_types::Literal> where V::Iri: 'a, V::BlankId: 'a, V::Literal: 'a, I::Resource: 'a;
+	type ObjectRef<'a>
+		= Term<&'a Id, &'a rdf_types::Literal>
+	where
+		V::Iri: 'a,
+		V::BlankId: 'a,
+		V::Literal: 'a,
+		I::Resource: 'a;
 
 	fn subject(
 		&mut self,
@@ -899,13 +926,13 @@ struct QuadSerializer<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> {
 	result: Vec<DomainQuad<I, V, D>>,
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> Visitor<I, V>
-	for QuadSerializer<'a, I, V, D>
+impl<I: Interpretation, V: Vocabulary, D: Domain<I, V>> Visitor<I, V>
+	for QuadSerializer<'_, I, V, D>
 {
 	type Ok = Vec<DomainQuad<I, V, D>>;
 	type Error = IntoQuadsError;
 
-	fn default_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_default_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + crate::LinkedDataGraph<I, V>,
 	{
@@ -917,10 +944,10 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> Visitor<I, V>
 			graph: None,
 		};
 
-		value.visit_graph(graph_serializer)
+		value.accept_graph_visitor(graph_serializer)
 	}
 
-	fn named_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_named_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + crate::LinkedDataGraph<I, V>,
 	{
@@ -935,7 +962,7 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> Visitor<I, V>
 			graph: Some(&graph),
 		};
 
-		value.visit_graph(graph_serializer)
+		value.accept_graph_visitor(graph_serializer)
 	}
 
 	fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -951,13 +978,13 @@ struct QuadGraphSerializer<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>
 	graph: Option<&'a D::Subject>,
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> GraphVisitor<I, V>
-	for QuadGraphSerializer<'a, I, V, D>
+impl<I: Interpretation, V: Vocabulary, D: Domain<I, V>> GraphVisitor<I, V>
+	for QuadGraphSerializer<'_, I, V, D>
 {
 	type Ok = ();
 	type Error = IntoQuadsError;
 
-	fn subject<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_subject<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + crate::LinkedDataSubject<I, V>,
 	{
@@ -975,7 +1002,7 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> GraphVisitor<I, V>
 			subject: SubjectOrObject::Subject(&term),
 		};
 
-		value.visit_subject(properties_serializer)
+		value.accept_subject_visitor(properties_serializer)
 	}
 
 	fn end(self) -> Result<Self::Ok, Self::Error> {
@@ -1015,13 +1042,13 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> SubjectOrObject<'a,
 	}
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> SubjectVisitor<I, V>
-	for QuadPropertiesSerializer<'a, I, V, D>
+impl<I: Interpretation, V: Vocabulary, D: Domain<I, V>> SubjectVisitor<I, V>
+	for QuadPropertiesSerializer<'_, I, V, D>
 {
 	type Ok = ();
 	type Error = IntoQuadsError;
 
-	fn predicate<L, T>(&mut self, predicate: &L, value: &T) -> Result<(), Self::Error>
+	fn visit_predicate<L, T>(&mut self, predicate: &L, value: &T) -> Result<(), Self::Error>
 	where
 		L: ?Sized + LinkedDataResource<I, V>,
 		T: ?Sized + crate::LinkedDataPredicateObjects<I, V>,
@@ -1043,10 +1070,10 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> SubjectVisitor<I, V>
 			predicate: term,
 		};
 
-		value.visit_objects(objects_serializer)
+		value.accept_objects_visitor(objects_serializer)
 	}
 
-	fn reverse_predicate<L, T>(&mut self, predicate: &L, subjects: &T) -> Result<(), Self::Error>
+	fn visit_reverse_predicate<L, T>(&mut self, predicate: &L, subjects: &T) -> Result<(), Self::Error>
 	where
 		L: ?Sized + LinkedDataResource<I, V>,
 		T: ?Sized + crate::LinkedDataPredicateObjects<I, V>,
@@ -1068,10 +1095,10 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> SubjectVisitor<I, V>
 			predicate: term,
 		};
 
-		subjects.visit_objects(subjects_serializer)
+		subjects.accept_objects_visitor(subjects_serializer)
 	}
 
-	fn graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataGraph<I, V>,
 	{
@@ -1085,10 +1112,10 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> SubjectVisitor<I, V>
 			graph: Some(graph),
 		};
 
-		value.visit_graph(graph_serializer)
+		value.accept_graph_visitor(graph_serializer)
 	}
 
-	fn include<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_include<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataSubject<I, V>,
 	{
@@ -1097,7 +1124,7 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> SubjectVisitor<I, V>
 			.domain
 			.subject(self.vocabulary, self.interpretation, i)?;
 
-		value.visit_subject(QuadPropertiesSerializer {
+		value.accept_subject_visitor(QuadPropertiesSerializer {
 			vocabulary: self.vocabulary,
 			interpretation: self.interpretation,
 			domain: self.domain,
@@ -1124,13 +1151,13 @@ struct ObjectsSerializer<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>>
 	predicate: D::Predicate,
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> PredicateObjectsVisitor<I, V>
-	for ObjectsSerializer<'a, I, V, D>
+impl<I: Interpretation, V: Vocabulary, D: Domain<I, V>> PredicateObjectsVisitor<I, V>
+	for ObjectsSerializer<'_, I, V, D>
 {
 	type Ok = ();
 	type Error = IntoQuadsError;
 
-	fn object<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_object<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + crate::LinkedDataSubject<I, V>,
 	{
@@ -1147,7 +1174,7 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> PredicateObjectsVisi
 			subject: SubjectOrObject::Object(&term),
 		};
 
-		value.visit_subject(subject_serializer)?;
+		value.accept_subject_visitor(subject_serializer)?;
 		self.result.push(Quad(
 			self.subject.clone(),
 			self.predicate.clone(),
@@ -1172,13 +1199,13 @@ struct ReversePredicateSerializer<'a, I: Interpretation, V: Vocabulary, D: Domai
 	predicate: D::Predicate,
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> PredicateObjectsVisitor<I, V>
-	for ReversePredicateSerializer<'a, I, V, D>
+impl<I: Interpretation, V: Vocabulary, D: Domain<I, V>> PredicateObjectsVisitor<I, V>
+	for ReversePredicateSerializer<'_, I, V, D>
 {
 	type Ok = ();
 	type Error = IntoQuadsError;
 
-	fn object<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_object<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + crate::LinkedDataSubject<I, V>,
 	{
@@ -1196,7 +1223,7 @@ impl<'a, I: Interpretation, V: Vocabulary, D: Domain<I, V>> PredicateObjectsVisi
 			subject: SubjectOrObject::Subject(&subject),
 		};
 
-		value.visit_subject(subject_serializer)?;
+		value.accept_subject_visitor(subject_serializer)?;
 		self.result.push(Quad(
 			subject,
 			self.predicate.clone(),
diff --git a/src/rdf.rs b/src/rdf.rs
index 0e4f772..0863b7e 100644
--- a/src/rdf.rs
+++ b/src/rdf.rs
@@ -78,7 +78,7 @@ pub enum CowRef<'a, T> {
 	Owned(T),
 }
 
-impl<'a, T> AsRef<T> for CowRef<'a, T> {
+impl<T> AsRef<T> for CowRef<'_, T> {
 	fn as_ref(&self) -> &T {
 		match self {
 			Self::Borrowed(t) => t,
@@ -87,7 +87,7 @@ impl<'a, T> AsRef<T> for CowRef<'a, T> {
 	}
 }
 
-impl<'a, T> Borrow<T> for CowRef<'a, T> {
+impl<T> Borrow<T> for CowRef<'_, T> {
 	fn borrow(&self) -> &T {
 		match self {
 			Self::Borrowed(t) => t,
@@ -150,7 +150,7 @@ pub trait AsRdfLiteral<V: IriVocabulary + LiteralVocabulary> {
 		&'a self,
 		vocabulary: &V,
 		ty: LiteralTypeRef<'a, V::Iri>,
-	) -> CowRdfLiteral<V>;
+	) -> CowRdfLiteral<'a, V>;
 }
 
 impl<V: IriVocabulary + LiteralVocabulary> AsRdfLiteral<V> for str {
@@ -158,7 +158,7 @@ impl<V: IriVocabulary + LiteralVocabulary> AsRdfLiteral<V> for str {
 		&'a self,
 		_vocabulary: &V,
 		ty: LiteralTypeRef<'a, V::Iri>,
-	) -> CowRdfLiteral<V> {
+	) -> CowRdfLiteral<'a, V> {
 		CowRdfLiteral::Borrowed(RdfLiteralRef::Any(self, ty))
 	}
 }
@@ -168,7 +168,7 @@ impl<V: IriVocabulary + LiteralVocabulary> AsRdfLiteral<V> for String {
 		&'a self,
 		vocabulary: &V,
 		ty: LiteralTypeRef<'a, V::Iri>,
-	) -> CowRdfLiteral<V> {
+	) -> CowRdfLiteral<'a, V> {
 		self.as_str().as_rdf_literal(vocabulary, ty)
 	}
 }
@@ -255,7 +255,7 @@ pub enum RdfLiteralRef<'a, V: IriVocabulary = ()> {
 	Json(&'a json_syntax::Value),
 }
 
-impl<'a, V: IriVocabulary> RdfLiteralRef<'a, V> {
+impl<V: IriVocabulary> RdfLiteralRef<'_, V> {
 	pub fn into_lexical(self, vocabulary: &V) -> rdf_types::Literal {
 		match self {
 			Self::Any(s, LiteralTypeRef::Any(ty)) => rdf_types::Literal::new(
@@ -294,7 +294,7 @@ pub enum CowRdfLiteral<'a, V: IriVocabulary = ()> {
 	Owned(RdfLiteral<V>),
 }
 
-impl<'a, V: IriVocabulary> CowRdfLiteral<'a, V> {
+impl<V: IriVocabulary> CowRdfLiteral<'_, V> {
 	pub fn into_owned(self) -> RdfLiteral<V>
 	where
 		V::Iri: Clone,
diff --git a/src/reference.rs b/src/reference.rs
index a737c1c..e5b8284 100644
--- a/src/reference.rs
+++ b/src/reference.rs
@@ -15,8 +15,9 @@ impl<T> From<T> for Ref<T> {
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataResource<I, V>> LinkedDataResource<I, V>
-	for Ref<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataResource<I, V> for Ref<T>
+where
+	T: LinkedDataResource<I, V>,
 {
 	fn interpretation(
 		&self,
@@ -28,44 +29,49 @@ impl<I: Interpretation, V: Vocabulary, T: LinkedDataResource<I, V>> LinkedDataRe
 }
 
 impl<I: Interpretation, V: Vocabulary, T> LinkedDataSubject<I, V> for Ref<T> {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::SubjectVisitor<I, V>,
 	{
-		serializer.end()
+		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataResource<I, V>> LinkedDataPredicateObjects<I, V>
-	for Ref<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataPredicateObjects<I, V> for Ref<T>
+where
+	T: LinkedDataResource<I, V>,
 {
-	fn visit_objects<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_objects_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::PredicateObjectsVisitor<I, V>,
 	{
-		visitor.object(self)?;
+		visitor.visit_object(self)?;
 		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataResource<I, V>> LinkedDataGraph<I, V>
-	for Ref<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataGraph<I, V> for Ref<T>
+where
+	T: LinkedDataResource<I, V>,
 {
-	fn visit_graph<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+	fn accept_graph_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::GraphVisitor<I, V>,
 	{
-		visitor.subject(self)?;
+		visitor.visit_subject(self)?;
 		visitor.end()
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataResource<I, V>> LinkedData<I, V> for Ref<T> {
-	fn visit<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
+impl<I: Interpretation, V: Vocabulary, T> LinkedData<I, V> for Ref<T>
+where
+	T: LinkedDataResource<I, V>,
+{
+	fn accept_visitor<S>(&self, mut visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: crate::Visitor<I, V>,
 	{
-		visitor.default_graph(self)?;
+		visitor.visit_default_graph(self)?;
 		visitor.end()
 	}
 }
diff --git a/src/resource.rs b/src/resource.rs
index d741dff..e13de92 100644
--- a/src/resource.rs
+++ b/src/resource.rs
@@ -111,8 +111,8 @@ pub trait LinkedDataResource<I: Interpretation = (), V: Vocabulary = ()> {
 	}
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataResource<I, V>>
-	LinkedDataResource<I, V> for &'a T
+impl<I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataResource<I, V>>
+	LinkedDataResource<I, V> for &T
 {
 	fn interpretation(
 		&self,
@@ -161,7 +161,10 @@ impl<I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for Anonymous {
 	}
 }
 
-impl<V: Vocabulary + IriVocabularyMut, I: Interpretation> LinkedDataResource<I, V> for Iri {
+impl<I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for Iri
+where
+	V: IriVocabularyMut,
+{
 	fn interpretation(
 		&self,
 		vocabulary: &mut V,
@@ -173,7 +176,10 @@ impl<V: Vocabulary + IriVocabularyMut, I: Interpretation> LinkedDataResource<I,
 	}
 }
 
-impl<V: Vocabulary + IriVocabularyMut, I: Interpretation> LinkedDataResource<I, V> for IriBuf {
+impl<I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for IriBuf
+where
+	V: IriVocabularyMut,
+{
 	fn interpretation(
 		&self,
 		vocabulary: &mut V,
@@ -185,7 +191,10 @@ impl<V: Vocabulary + IriVocabularyMut, I: Interpretation> LinkedDataResource<I,
 	}
 }
 
-impl<V: Vocabulary + BlankIdVocabularyMut, I: Interpretation> LinkedDataResource<I, V> for BlankId {
+impl<I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for BlankId
+where
+	V: BlankIdVocabularyMut,
+{
 	fn interpretation(
 		&self,
 		vocabulary: &mut V,
@@ -197,8 +206,9 @@ impl<V: Vocabulary + BlankIdVocabularyMut, I: Interpretation> LinkedDataResource
 	}
 }
 
-impl<V: Vocabulary + BlankIdVocabularyMut, I: Interpretation> LinkedDataResource<I, V>
-	for BlankIdBuf
+impl<I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for BlankIdBuf
+where
+	V: BlankIdVocabularyMut,
 {
 	fn interpretation(
 		&self,
@@ -211,12 +221,10 @@ impl<V: Vocabulary + BlankIdVocabularyMut, I: Interpretation> LinkedDataResource
 	}
 }
 
-impl<
-		V: Vocabulary,
-		I: Interpretation,
-		T: LinkedDataResource<I, V>,
-		B: LinkedDataResource<I, V>,
-	> LinkedDataResource<I, V> for Id<T, B>
+impl<I: Interpretation, V: Vocabulary, T, B> LinkedDataResource<I, V> for Id<T, B>
+where
+	T: LinkedDataResource<I, V>,
+	B: LinkedDataResource<I, V>,
 {
 	fn interpretation(
 		&self,
@@ -230,13 +238,11 @@ impl<
 	}
 }
 
-impl<
-		V: Vocabulary,
-		I: Interpretation,
-		T: LinkedDataResource<I, V>,
-		B: LinkedDataResource<I, V>,
-		L: LinkedDataResource<I, V>,
-	> LinkedDataResource<I, V> for Term<Id<T, B>, L>
+impl<I: Interpretation, V: Vocabulary, T, B, L> LinkedDataResource<I, V> for Term<Id<T, B>, L>
+where
+	T: LinkedDataResource<I, V>,
+	B: LinkedDataResource<I, V>,
+	L: LinkedDataResource<I, V>,
 {
 	fn interpretation(
 		&self,
@@ -250,7 +256,7 @@ impl<
 	}
 }
 
-impl<V: Vocabulary, I: Interpretation> LinkedDataResource<I, V> for rdf_types::Literal<V::Iri> {
+impl<I: Interpretation, V: Vocabulary> LinkedDataResource<I, V> for rdf_types::Literal<V::Iri> {
 	fn interpretation(
 		&self,
 		_vocabulary: &mut V,
@@ -262,8 +268,9 @@ impl<V: Vocabulary, I: Interpretation> LinkedDataResource<I, V> for rdf_types::L
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: LinkedDataResource<I, V>> LinkedDataResource<I, V>
-	for Option<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataResource<I, V> for Option<T>
+where
+	T: LinkedDataResource<I, V>,
 {
 	fn interpretation(
 		&self,
diff --git a/src/subject.rs b/src/subject.rs
index ed10871..9c1ffeb 100644
--- a/src/subject.rs
+++ b/src/subject.rs
@@ -11,77 +11,78 @@ use crate::{
 	Context, FromLinkedDataError, LinkedDataGraph, LinkedDataPredicateObjects, LinkedDataResource,
 };
 
-/// Serialize a Linked-Data node.
 pub trait LinkedDataSubject<I: Interpretation = (), V: Vocabulary = ()> {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>;
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataSubject<I, V> for () {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		serializer.end()
+		visitor.end()
 	}
 }
 
-impl<'a, I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataSubject<I, V>>
-	LinkedDataSubject<I, V> for &'a T
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataSubject<I, V> for &T
+where
+	T: ?Sized + LinkedDataSubject<I, V>,
 {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		T::visit_subject(self, serializer)
+		T::accept_subject_visitor(self, visitor)
 	}
 }
 
-impl<I: Interpretation, V: Vocabulary, T: ?Sized + LinkedDataSubject<I, V>> LinkedDataSubject<I, V>
-	for Box<T>
+impl<I: Interpretation, V: Vocabulary, T> LinkedDataSubject<I, V> for Box<T>
+where
+	T: ?Sized + LinkedDataSubject<I, V>,
 {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		T::visit_subject(self, serializer)
+		T::accept_subject_visitor(self, visitor)
 	}
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataSubject<I, V> for Iri {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		serializer.end()
+		visitor.end()
 	}
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataSubject<I, V> for IriBuf {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		serializer.end()
+		visitor.end()
 	}
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataSubject<I, V> for BlankId {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		serializer.end()
+		visitor.end()
 	}
 }
 
 impl<I: Interpretation, V: Vocabulary> LinkedDataSubject<I, V> for BlankIdBuf {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
-		serializer.end()
+		visitor.end()
 	}
 }
 
@@ -90,13 +91,13 @@ where
 	T: LinkedDataSubject<I, V>,
 	B: LinkedDataSubject<I, V>,
 {
-	fn visit_subject<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+	fn accept_subject_visitor<S>(&self, visitor: S) -> Result<S::Ok, S::Error>
 	where
 		S: SubjectVisitor<I, V>,
 	{
 		match self {
-			Self::Iri(i) => i.visit_subject(serializer),
-			Self::Blank(b) => b.visit_subject(serializer),
+			Self::Iri(i) => i.accept_subject_visitor(visitor),
+			Self::Blank(b) => b.accept_subject_visitor(visitor),
 		}
 	}
 }
@@ -106,62 +107,71 @@ pub trait SubjectVisitor<I: Interpretation, V: Vocabulary> {
 	type Error;
 
 	/// Visit a predicate of the graph.
-	fn predicate<L, T>(&mut self, predicate: &L, objects: &T) -> Result<(), Self::Error>
+	fn visit_predicate<L, T>(&mut self, predicate: &L, objects: &T) -> Result<(), Self::Error>
 	where
 		L: ?Sized + LinkedDataResource<I, V>,
 		T: ?Sized + LinkedDataPredicateObjects<I, V>;
 
 	/// Visit a reverse predicate of the graph.
-	fn reverse_predicate<L, T>(&mut self, predicate: &L, subjects: &T) -> Result<(), Self::Error>
+	fn visit_reverse_predicate<L, T>(
+		&mut self,
+		predicate: &L,
+		subjects: &T,
+	) -> Result<(), Self::Error>
 	where
 		L: ?Sized + LinkedDataResource<I, V>,
 		T: ?Sized + LinkedDataPredicateObjects<I, V>;
 
-	fn graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataGraph<I, V>;
 
-	fn include<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_include<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataSubject<I, V>;
 
 	fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
-impl<'s, I: Interpretation, V: Vocabulary, S: SubjectVisitor<I, V>> SubjectVisitor<I, V>
-	for &'s mut S
+impl<I: Interpretation, V: Vocabulary, S> SubjectVisitor<I, V> for &mut S
+where
+	S: SubjectVisitor<I, V>,
 {
 	type Ok = ();
 	type Error = S::Error;
 
-	fn predicate<L, T>(&mut self, predicate: &L, objects: &T) -> Result<(), Self::Error>
+	fn visit_predicate<L, T>(&mut self, predicate: &L, objects: &T) -> Result<(), Self::Error>
 	where
 		L: ?Sized + LinkedDataResource<I, V>,
 		T: ?Sized + LinkedDataPredicateObjects<I, V>,
 	{
-		S::predicate(self, predicate, objects)
+		S::visit_predicate(self, predicate, objects)
 	}
 
-	fn reverse_predicate<L, T>(&mut self, predicate: &L, subjects: &T) -> Result<(), Self::Error>
+	fn visit_reverse_predicate<L, T>(
+		&mut self,
+		predicate: &L,
+		subjects: &T,
+	) -> Result<(), Self::Error>
 	where
 		L: ?Sized + LinkedDataResource<I, V>,
 		T: ?Sized + LinkedDataPredicateObjects<I, V>,
 	{
-		S::reverse_predicate(self, predicate, subjects)
+		S::visit_reverse_predicate(self, predicate, subjects)
 	}
 
-	fn graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_graph<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataGraph<I, V>,
 	{
-		S::graph(self, value)
+		S::visit_graph(self, value)
 	}
 
-	fn include<T>(&mut self, value: &T) -> Result<(), Self::Error>
+	fn visit_include<T>(&mut self, value: &T) -> Result<(), Self::Error>
 	where
 		T: ?Sized + LinkedDataResource<I, V> + LinkedDataSubject<I, V>,
 	{
-		S::include(self, value)
+		S::visit_include(self, value)
 	}
 
 	fn end(self) -> Result<Self::Ok, Self::Error> {