chore: place TryFrom directly below From

lib/oxrdf/src/blank_node.rs

@@ -103,22 +103,6 @@ impl fmt::Display for BlankNode {
     }
 }
 
-impl TryFrom<Term> for BlankNode {
-    type Error = TermCastError;
-
-    #[inline]
-    fn try_from(term: Term) -> Result<Self, Self::Error> {
-        if let Term::BlankNode(node) = term {
-            Ok(node)
-        } else {
-            Err(
-                TermCastErrorKind::Msg(format!("Cannot convert term to a blank node: {}", term))
-                    .into(),
-            )
-        }
-    }
-}
-
 impl Default for BlankNode {
     /// Builds a new RDF [blank node](https://www.w3.org/TR/rdf11-concepts/#dfn-blank-node) with a unique id.
     #[inline]
@@ -249,6 +233,22 @@ impl<'a> From<BlankNodeRef<'a>> for BlankNode {
     }
 }
 
+impl TryFrom<Term> for BlankNode {
+    type Error = TermCastError;
+
+    #[inline]
+    fn try_from(term: Term) -> Result<Self, Self::Error> {
+        if let Term::BlankNode(node) = term {
+            Ok(node)
+        } else {
+            Err(
+                TermCastErrorKind::Msg(format!("Cannot convert term to a blank node: {}", term))
+                    .into(),
+            )
+        }
+    }
+}
+
 impl PartialEq<BlankNode> for BlankNodeRef<'_> {
     #[inline]
     fn eq(&self, other: &BlankNode) -> bool {

lib/oxrdf/src/literal.rs

@@ -161,22 +161,6 @@ impl fmt::Display for Literal {
     }
 }
 
-impl TryFrom<Term> for Literal {
-    type Error = TermCastError;
-
-    #[inline]
-    fn try_from(term: Term) -> Result<Self, Self::Error> {
-        if let Term::Literal(node) = term {
-            Ok(node)
-        } else {
-            Err(
-                TermCastErrorKind::Msg(format!("Cannot convert term to a literal: {}", term))
-                    .into(),
-            )
-        }
-    }
-}
-
 impl<'a> From<&'a str> for Literal {
     #[inline]
     fn from(value: &'a str) -> Self {
@@ -438,6 +422,22 @@ impl From<DayTimeDuration> for Literal {
     }
 }
 
+impl TryFrom<Term> for Literal {
+    type Error = TermCastError;
+
+    #[inline]
+    fn try_from(term: Term) -> Result<Self, Self::Error> {
+        if let Term::Literal(node) = term {
+            Ok(node)
+        } else {
+            Err(
+                TermCastErrorKind::Msg(format!("Cannot convert term to a literal: {}", term))
+                    .into(),
+            )
+        }
+    }
+}
+
 /// A borrowed RDF [literal](https://www.w3.org/TR/rdf11-concepts/#dfn-literal).
 ///
 /// The default string formatter is returning an N-Triples, Turtle, and SPARQL compatible representation:

lib/oxrdf/src/named_node.rs

@@ -218,22 +218,6 @@ impl PartialOrd<NamedNodeRef<'_>> for NamedNode {
     }
 }
 
-impl TryFrom<Term> for NamedNode {
-    type Error = TermCastError;
-
-    #[inline]
-    fn try_from(term: Term) -> Result<Self, Self::Error> {
-        if let Term::NamedNode(node) = term {
-            Ok(node)
-        } else {
-            Err(
-                TermCastErrorKind::Msg(format!("Cannot convert term to a named node: {}", term))
-                    .into(),
-            )
-        }
-    }
-}
-
 impl From<Iri<String>> for NamedNode {
     #[inline]
     fn from(iri: Iri<String>) -> Self {
@@ -252,6 +236,22 @@ impl<'a> From<Iri<&'a str>> for NamedNodeRef<'a> {
     }
 }
 
+impl TryFrom<Term> for NamedNode {
+    type Error = TermCastError;
+
+    #[inline]
+    fn try_from(term: Term) -> Result<Self, Self::Error> {
+        if let Term::NamedNode(node) = term {
+            Ok(node)
+        } else {
+            Err(
+                TermCastErrorKind::Msg(format!("Cannot convert term to a named node: {}", term))
+                    .into(),
+            )
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #![allow(clippy::panic_in_result_fn)]

lib/oxrdf/src/triple.rs

@@ -196,25 +196,6 @@ impl fmt::Display for Subject {
     }
 }
 
-impl TryFrom<Term> for Subject {
-    type Error = TermCastError;
-
-    #[inline]
-    fn try_from(term: Term) -> Result<Self, Self::Error> {
-        match term {
-            Term::NamedNode(node) => Ok(Subject::NamedNode(node)),
-            Term::BlankNode(node) => Ok(Subject::BlankNode(node)),
-            #[cfg(feature = "rdf-star")]
-            Term::Triple(triple) => Ok(Subject::Triple(triple)),
-            Term::Literal(literal) => Err(TermCastErrorKind::Msg(format!(
-                "Cannot convert a literal to a subject: {}",
-                literal
-            ))
-            .into()),
-        }
-    }
-}
-
 impl From<NamedNode> for Subject {
     #[inline]
     fn from(node: NamedNode) -> Self {
@@ -243,6 +224,25 @@ impl From<BlankNodeRef<'_>> for Subject {
     }
 }
 
+impl TryFrom<Term> for Subject {
+    type Error = TermCastError;
+
+    #[inline]
+    fn try_from(term: Term) -> Result<Self, Self::Error> {
+        match term {
+            Term::NamedNode(node) => Ok(Subject::NamedNode(node)),
+            Term::BlankNode(node) => Ok(Subject::BlankNode(node)),
+            #[cfg(feature = "rdf-star")]
+            Term::Triple(triple) => Ok(Subject::Triple(triple)),
+            Term::Literal(literal) => Err(TermCastErrorKind::Msg(format!(
+                "Cannot convert a literal to a subject: {}",
+                literal
+            ))
+            .into()),
+        }
+    }
+}
+
 #[cfg(feature = "rdf-star")]
 impl From<Triple> for Subject {
     #[inline]