Adds #[inline] annotations to simple public functions

4 years ago · fdc0dbbeef
parent 10e4c1518d
commit fdc0dbbeef
7 changed files with 220 additions and 1 deletions
--- a/lib/src/io/format.rs
+++ b/lib/src/io/format.rs
@ -38,6 +38,7 @@ impl GraphFormat {
    ///
    /// assert_eq!(GraphFormat::NTriples.iri(), "http://www.w3.org/ns/formats/N-Triples")
    /// ```
+    #[inline]
    pub fn iri(self) -> &'static str {
        match self {
            GraphFormat::NTriples => "http://www.w3.org/ns/formats/N-Triples",
@ -53,6 +54,7 @@ impl GraphFormat {
    ///
    /// assert_eq!(GraphFormat::NTriples.media_type(), "application/n-triples")
    /// ```
+    #[inline]
    pub fn media_type(self) -> &'static str {
        match self {
            GraphFormat::NTriples => "application/n-triples",
@ -68,6 +70,7 @@ impl GraphFormat {
    ///
    /// assert_eq!(GraphFormat::NTriples.file_extension(), "nt")
    /// ```
+    #[inline]
    pub fn file_extension(self) -> &'static str {
        match self {
            GraphFormat::NTriples => "nt",
@ -141,6 +144,7 @@ impl DatasetFormat {
    ///
    /// assert_eq!(DatasetFormat::NQuads.iri(), "http://www.w3.org/ns/formats/N-Quads")
    /// ```
+    #[inline]
    pub fn iri(self) -> &'static str {
        match self {
            DatasetFormat::NQuads => "http://www.w3.org/ns/formats/N-Quads",
@ -155,6 +159,7 @@ impl DatasetFormat {
    ///
    /// assert_eq!(DatasetFormat::NQuads.media_type(), "application/n-quads")
    /// ```
+    #[inline]
    pub fn media_type(self) -> &'static str {
        match self {
            DatasetFormat::NQuads => "application/n-quads",
@ -169,6 +174,7 @@ impl DatasetFormat {
    ///
    /// assert_eq!(DatasetFormat::NQuads.file_extension(), "nq")
    /// ```
+    #[inline]
    pub fn file_extension(self) -> &'static str {
        match self {
            DatasetFormat::NQuads => "nq",
--- a/lib/src/model/blank_node.rs
+++ b/lib/src/model/blank_node.rs
@ -71,6 +71,7 @@ impl BlankNode {
    }

    /// Returns the underlying ID of this blank node
+    #[inline]
    pub fn as_str(&self) -> &str {
        match &self.0 {
            BlankNodeContent::Named(id) => id,
@ -79,6 +80,7 @@ impl BlankNode {
    }

    /// Returns the underlying ID of this blank node
+    #[inline]
    pub fn into_string(self) -> String {
        match self.0 {
            BlankNodeContent::Named(id) => id,
@ -86,6 +88,7 @@ impl BlankNode {
        }
    }

+    #[inline]
    pub fn as_ref(&self) -> BlankNodeRef<'_> {
        BlankNodeRef(match &self.0 {
            BlankNodeContent::Named(id) => BlankNodeRefContent::Named(id.as_str()),
@ -98,6 +101,7 @@ impl BlankNode {
 }

 impl fmt::Display for BlankNode {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
@ -105,6 +109,7 @@ impl fmt::Display for BlankNode {

 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]
    fn default() -> Self {
        Self::new_from_unique_id(random::<u128>())
    }
@ -166,6 +171,7 @@ impl<'a> BlankNodeRef<'a> {
    }

    /// Returns the underlying ID of this blank node
+    #[inline]
    pub fn as_str(self) -> &'a str {
        match self.0 {
            BlankNodeRefContent::Named(id) => id,
@ -174,6 +180,7 @@ impl<'a> BlankNodeRef<'a> {
    }

    /// Returns the internal numerical ID of this blank node, if it exists
+    #[inline]
    pub(crate) fn id(&self) -> Option<u128> {
        match self.0 {
            BlankNodeRefContent::Named(_) => None,
@ -181,6 +188,7 @@ impl<'a> BlankNodeRef<'a> {
        }
    }

+    #[inline]
    pub fn into_owned(self) -> BlankNode {
        BlankNode(match self.0 {
            BlankNodeRefContent::Named(id) => BlankNodeContent::Named(id.to_owned()),
@ -193,36 +201,42 @@ impl<'a> BlankNodeRef<'a> {
 }

 impl fmt::Display for BlankNodeRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        rio::BlankNode::from(*self).fmt(f)
    }
 }

 impl<'a> From<&'a BlankNode> for BlankNodeRef<'a> {
+    #[inline]
    fn from(node: &'a BlankNode) -> Self {
        node.as_ref()
    }
 }

 impl<'a> From<BlankNodeRef<'a>> for BlankNode {
+    #[inline]
    fn from(node: BlankNodeRef<'a>) -> Self {
        node.into_owned()
    }
 }

 impl<'a> From<BlankNodeRef<'a>> for rio::BlankNode<'a> {
+    #[inline]
    fn from(node: BlankNodeRef<'a>) -> Self {
        rio::BlankNode { id: node.as_str() }
    }
 }

 impl PartialEq<BlankNode> for BlankNodeRef<'_> {
+    #[inline]
    fn eq(&self, other: &BlankNode) -> bool {
        *self == other.as_ref()
    }
 }

 impl PartialEq<BlankNodeRef<'_>> for BlankNode {
+    #[inline]
    fn eq(&self, other: &BlankNodeRef<'_>) -> bool {
        self.as_ref() == *other
    }
@ -328,6 +342,7 @@ fn to_integer_id(id: &str) -> Option<u128> {
 pub struct BlankNodeIdParseError {}

 impl fmt::Display for BlankNodeIdParseError {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "The blank node identifier is invalid")
    }
--- a/lib/src/model/literal.rs
+++ b/lib/src/model/literal.rs
@ -45,11 +45,13 @@ enum LiteralContent {

 impl Literal {
    /// Builds an RDF [simple literal](https://www.w3.org/TR/rdf11-concepts/#dfn-simple-literal)
+    #[inline]
    pub fn new_simple_literal(value: impl Into<String>) -> Self {
        Literal(LiteralContent::String(value.into()))
    }

    /// Builds an RDF [literal](https://www.w3.org/TR/rdf11-concepts/#dfn-literal) with a [datatype](https://www.w3.org/TR/rdf11-concepts/#dfn-datatype-iri)
+    #[inline]
    pub fn new_typed_literal(value: impl Into<String>, datatype: impl Into<NamedNode>) -> Self {
        let value = value.into();
        let datatype = datatype.into();
@ -61,6 +63,7 @@ impl Literal {
    }

    /// Builds an RDF [language-tagged string](https://www.w3.org/TR/rdf11-concepts/#dfn-language-tagged-string)
+    #[inline]
    pub fn new_language_tagged_literal(
        value: impl Into<String>,
        language: impl Into<String>,
@ -81,6 +84,7 @@ impl Literal {
    ///
    /// Except if you really know what you do,
    /// you should use [`new_language_tagged_literal`](#method.new_language_tagged_literal).
+    #[inline]
    pub fn new_language_tagged_literal_unchecked(
        value: impl Into<String>,
        language: impl Into<String>,
@ -92,6 +96,7 @@ impl Literal {
    }

    /// The literal [lexical form](https://www.w3.org/TR/rdf11-concepts/#dfn-lexical-form)
+    #[inline]
    pub fn value(&self) -> &str {
        self.as_ref().value()
    }
@ -100,6 +105,7 @@ impl Literal {
    ///
    /// Language tags are defined by the [BCP47](https://tools.ietf.org/html/bcp47).
    /// They are normalized to lowercase by this implementation.
+    #[inline]
    pub fn language(&self) -> Option<&str> {
        self.as_ref().language()
    }
@ -108,6 +114,7 @@ impl Literal {
    ///
    /// The datatype of [language-tagged string](https://www.w3.org/TR/rdf11-concepts/#dfn-language-tagged-string) is always [rdf:langString](http://www.w3.org/1999/02/22-rdf-syntax-ns#langString).
    /// The datatype of [simple literals](https://www.w3.org/TR/rdf11-concepts/#dfn-simple-literal) is [xsd:string](http://www.w3.org/2001/XMLSchema#string).
+    #[inline]
    pub fn datatype(&self) -> NamedNodeRef<'_> {
        self.as_ref().datatype()
    }
@ -116,10 +123,12 @@ impl Literal {
    ///
    /// It returns true if the literal is a [language-tagged string](https://www.w3.org/TR/rdf11-concepts/#dfn-language-tagged-string)
    /// or has the datatype [xsd:string](http://www.w3.org/2001/XMLSchema#string).
+    #[inline]
    pub fn is_plain(&self) -> bool {
        self.as_ref().is_plain()
    }

+    #[inline]
    pub fn as_ref(&self) -> LiteralRef<'_> {
        LiteralRef(match &self.0 {
            LiteralContent::String(value) => LiteralRefContent::String(value),
@ -134,6 +143,7 @@ impl Literal {
    }

    /// Extract components from this literal
+    #[inline]
    pub fn destruct(self) -> (String, Option<NamedNode>, Option<String>) {
        match self.0 {
            LiteralContent::String(s) => (s, None, None),
@ -146,30 +156,35 @@ impl Literal {
 }

 impl fmt::Display for Literal {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
 }

 impl<'a> From<&'a str> for Literal {
+    #[inline]
    fn from(value: &'a str) -> Self {
        Literal(LiteralContent::String(value.into()))
    }
 }

 impl From<String> for Literal {
+    #[inline]
    fn from(value: String) -> Self {
        Literal(LiteralContent::String(value))
    }
 }

 impl<'a> From<Cow<'a, str>> for Literal {
+    #[inline]
    fn from(value: Cow<'a, str>) -> Self {
        Literal(LiteralContent::String(value.into()))
    }
 }

 impl From<bool> for Literal {
+    #[inline]
    fn from(value: bool) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -179,6 +194,7 @@ impl From<bool> for Literal {
 }

 impl From<i128> for Literal {
+    #[inline]
    fn from(value: i128) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -188,6 +204,7 @@ impl From<i128> for Literal {
 }

 impl From<i64> for Literal {
+    #[inline]
    fn from(value: i64) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -197,6 +214,7 @@ impl From<i64> for Literal {
 }

 impl From<i32> for Literal {
+    #[inline]
    fn from(value: i32) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -206,6 +224,7 @@ impl From<i32> for Literal {
 }

 impl From<i16> for Literal {
+    #[inline]
    fn from(value: i16) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -215,6 +234,7 @@ impl From<i16> for Literal {
 }

 impl From<u64> for Literal {
+    #[inline]
    fn from(value: u64) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -224,6 +244,7 @@ impl From<u64> for Literal {
 }

 impl From<u32> for Literal {
+    #[inline]
    fn from(value: u32) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -233,6 +254,7 @@ impl From<u32> for Literal {
 }

 impl From<u16> for Literal {
+    #[inline]
    fn from(value: u16) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -242,6 +264,7 @@ impl From<u16> for Literal {
 }

 impl From<f32> for Literal {
+    #[inline]
    fn from(value: f32) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -251,6 +274,7 @@ impl From<f32> for Literal {
 }

 impl From<f64> for Literal {
+    #[inline]
    fn from(value: f64) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -260,6 +284,7 @@ impl From<f64> for Literal {
 }

 impl From<Decimal> for Literal {
+    #[inline]
    fn from(value: Decimal) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -269,6 +294,7 @@ impl From<Decimal> for Literal {
 }

 impl From<DateTime> for Literal {
+    #[inline]
    fn from(value: DateTime) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -278,6 +304,7 @@ impl From<DateTime> for Literal {
 }

 impl From<Time> for Literal {
+    #[inline]
    fn from(value: Time) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -287,6 +314,7 @@ impl From<Time> for Literal {
 }

 impl From<Date> for Literal {
+    #[inline]
    fn from(value: Date) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -296,6 +324,7 @@ impl From<Date> for Literal {
 }

 impl From<GYearMonth> for Literal {
+    #[inline]
    fn from(value: GYearMonth) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -305,6 +334,7 @@ impl From<GYearMonth> for Literal {
 }

 impl From<GYear> for Literal {
+    #[inline]
    fn from(value: GYear) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -314,6 +344,7 @@ impl From<GYear> for Literal {
 }

 impl From<GMonthDay> for Literal {
+    #[inline]
    fn from(value: GMonthDay) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -323,6 +354,7 @@ impl From<GMonthDay> for Literal {
 }

 impl From<GMonth> for Literal {
+    #[inline]
    fn from(value: GMonth) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -332,6 +364,7 @@ impl From<GMonth> for Literal {
 }

 impl From<GDay> for Literal {
+    #[inline]
    fn from(value: GDay) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -341,6 +374,7 @@ impl From<GDay> for Literal {
 }

 impl From<Duration> for Literal {
+    #[inline]
    fn from(value: Duration) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -350,6 +384,7 @@ impl From<Duration> for Literal {
 }

 impl From<YearMonthDuration> for Literal {
+    #[inline]
    fn from(value: YearMonthDuration) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -359,6 +394,7 @@ impl From<YearMonthDuration> for Literal {
 }

 impl From<DayTimeDuration> for Literal {
+    #[inline]
    fn from(value: DayTimeDuration) -> Self {
        Literal(LiteralContent::TypedLiteral {
            value: value.to_string(),
@ -404,11 +440,13 @@ enum LiteralRefContent<'a> {

 impl<'a> LiteralRef<'a> {
    /// Builds an RDF [simple literal](https://www.w3.org/TR/rdf11-concepts/#dfn-simple-literal)
+    #[inline]
    pub fn new_simple_literal(value: &'a str) -> Self {
        LiteralRef(LiteralRefContent::String(value))
    }

    /// Builds an RDF [literal](https://www.w3.org/TR/rdf11-concepts/#dfn-literal) with a [datatype](https://www.w3.org/TR/rdf11-concepts/#dfn-datatype-iri)
+    #[inline]
    pub fn new_typed_literal(value: &'a str, datatype: impl Into<NamedNodeRef<'a>>) -> Self {
        let datatype = datatype.into();
        LiteralRef(if datatype == xsd::STRING {
@ -426,11 +464,13 @@ impl<'a> LiteralRef<'a> {
    ///
    /// Except if you really know what you do,
    /// you should use [`new_language_tagged_literal`](#method.new_language_tagged_literal).
+    #[inline]
    pub fn new_language_tagged_literal_unchecked(value: &'a str, language: &'a str) -> Self {
        LiteralRef(LiteralRefContent::LanguageTaggedString { value, language })
    }

    /// The literal [lexical form](https://www.w3.org/TR/rdf11-concepts/#dfn-lexical-form)
+    #[inline]
    pub fn value(self) -> &'a str {
        match self.0 {
            LiteralRefContent::String(value)
@ -443,6 +483,7 @@ impl<'a> LiteralRef<'a> {
    ///
    /// Language tags are defined by the [BCP47](https://tools.ietf.org/html/bcp47).
    /// They are normalized to lowercase by this implementation.
+    #[inline]
    pub fn language(self) -> Option<&'a str> {
        match self.0 {
            LiteralRefContent::LanguageTaggedString { language, .. } => Some(language),
@ -454,6 +495,7 @@ impl<'a> LiteralRef<'a> {
    ///
    /// The datatype of [language-tagged string](https://www.w3.org/TR/rdf11-concepts/#dfn-language-tagged-string) is always [rdf:langString](http://www.w3.org/1999/02/22-rdf-syntax-ns#langString).
    /// The datatype of [simple literals](https://www.w3.org/TR/rdf11-concepts/#dfn-simple-literal) is [xsd:string](http://www.w3.org/2001/XMLSchema#string).
+    #[inline]
    pub fn datatype(self) -> NamedNodeRef<'a> {
        match self.0 {
            LiteralRefContent::String(_) => xsd::STRING,
@ -466,6 +508,7 @@ impl<'a> LiteralRef<'a> {
    ///
    /// It returns true if the literal is a [language-tagged string](https://www.w3.org/TR/rdf11-concepts/#dfn-language-tagged-string)
    /// or has the datatype [xsd:string](http://www.w3.org/2001/XMLSchema#string).
+    #[inline]
    pub fn is_plain(self) -> bool {
        match self.0 {
            LiteralRefContent::String(_) | LiteralRefContent::LanguageTaggedString { .. } => true,
@ -473,6 +516,7 @@ impl<'a> LiteralRef<'a> {
        }
    }

+    #[inline]
    pub fn into_owned(self) -> Literal {
        Literal(match self.0 {
            LiteralRefContent::String(value) => LiteralContent::String(value.to_owned()),
@ -490,6 +534,7 @@ impl<'a> LiteralRef<'a> {
    }

    /// Extract components from this literal
+    #[inline]
    pub fn destruct(self) -> (&'a str, Option<NamedNodeRef<'a>>, Option<&'a str>) {
        match self.0 {
            LiteralRefContent::String(s) => (s, None, None),
@ -502,24 +547,28 @@ impl<'a> LiteralRef<'a> {
 }

 impl fmt::Display for LiteralRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        rio::Literal::from(*self).fmt(f)
    }
 }

 impl<'a> From<&'a Literal> for LiteralRef<'a> {
+    #[inline]
    fn from(node: &'a Literal) -> Self {
        node.as_ref()
    }
 }

 impl<'a> From<LiteralRef<'a>> for Literal {
+    #[inline]
    fn from(node: LiteralRef<'a>) -> Self {
        node.into_owned()
    }
 }

 impl<'a> From<LiteralRef<'a>> for rio::Literal<'a> {
+    #[inline]
    fn from(literal: LiteralRef<'a>) -> Self {
        match literal.0 {
            LiteralRefContent::String(value) => rio::Literal::Simple { value },
@ -535,18 +584,21 @@ impl<'a> From<LiteralRef<'a>> for rio::Literal<'a> {
 }

 impl<'a> From<&'a str> for LiteralRef<'a> {
+    #[inline]
    fn from(value: &'a str) -> Self {
        LiteralRef(LiteralRefContent::String(value))
    }
 }

 impl PartialEq<Literal> for LiteralRef<'_> {
+    #[inline]
    fn eq(&self, other: &Literal) -> bool {
        *self == other.as_ref()
    }
 }

 impl PartialEq<LiteralRef<'_>> for Literal {
+    #[inline]
    fn eq(&self, other: &LiteralRef<'_>) -> bool {
        self.as_ref() == *other
    }
--- a/lib/src/model/named_node.rs
+++ b/lib/src/model/named_node.rs
@ -30,6 +30,7 @@ impl NamedNode {
        Self::new(iri)
    }

+    #[inline]
    pub(crate) fn new_from_iri(iri: Iri<String>) -> Self {
        Self::new_unchecked(iri.into_inner())
    }
@ -39,48 +40,57 @@ impl NamedNode {
    /// It is the caller's responsibility to ensure that `iri` is a valid IRI.
    ///
    /// Except if you really know what you do, you should use [`parse`](#method.parse).
+    #[inline]
    pub fn new_unchecked(iri: impl Into<String>) -> Self {
        Self { iri: iri.into() }
    }

+    #[inline]
    pub fn as_str(&self) -> &str {
        self.iri.as_str()
    }

+    #[inline]
    pub fn into_string(self) -> String {
        self.iri
    }

+    #[inline]
    pub fn as_ref(&self) -> NamedNodeRef<'_> {
        NamedNodeRef::new_unchecked(&self.iri)
    }
 }

 impl fmt::Display for NamedNode {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
 }

 impl PartialEq<str> for NamedNode {
+    #[inline]
    fn eq(&self, other: &str) -> bool {
        self.as_str() == other
    }
 }

 impl PartialEq<NamedNode> for str {
+    #[inline]
    fn eq(&self, other: &NamedNode) -> bool {
        self == other.as_str()
    }
 }

 impl PartialEq<&str> for NamedNode {
+    #[inline]
    fn eq(&self, other: &&str) -> bool {
        self == *other
    }
 }

 impl PartialEq<NamedNode> for &str {
+    #[inline]
    fn eq(&self, other: &NamedNode) -> bool {
        *self == other
    }
@ -109,6 +119,7 @@ impl<'a> NamedNodeRef<'a> {
        Ok(Self::new_from_iri(Iri::parse(iri)?))
    }

+    #[inline]
    pub(crate) fn new_from_iri(iri: Iri<&'a str>) -> Self {
        Self::new_unchecked(iri.into_inner())
    }
@ -118,26 +129,31 @@ impl<'a> NamedNodeRef<'a> {
    /// It is the caller's responsibility to ensure that `iri` is a valid IRI.
    ///
    /// Except if you really know what you do, you should use [`parse`](#method.parse).
+    #[inline]
    pub const fn new_unchecked(iri: &'a str) -> Self {
        Self { iri }
    }

+    #[inline]
    pub const fn as_str(self) -> &'a str {
        self.iri
    }

+    #[inline]
    pub fn into_owned(self) -> NamedNode {
        NamedNode::new_unchecked(self.iri)
    }
 }

 impl fmt::Display for NamedNodeRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        rio::NamedNode::from(*self).fmt(f)
    }
 }

 impl From<NamedNodeRef<'_>> for NamedNode {
+    #[inline]
    fn from(node: NamedNodeRef<'_>) -> Self {
        node.into_owned()
    }
@ -150,42 +166,49 @@ impl<'a> From<&'a NamedNode> for NamedNodeRef<'a> {
 }

 impl<'a> From<NamedNodeRef<'a>> for rio::NamedNode<'a> {
+    #[inline]
    fn from(node: NamedNodeRef<'a>) -> Self {
        rio::NamedNode { iri: node.as_str() }
    }
 }

 impl PartialEq<NamedNode> for NamedNodeRef<'_> {
+    #[inline]
    fn eq(&self, other: &NamedNode) -> bool {
        self.as_str() == other.as_str()
    }
 }

 impl PartialEq<NamedNodeRef<'_>> for NamedNode {
+    #[inline]
    fn eq(&self, other: &NamedNodeRef<'_>) -> bool {
        self.as_str() == other.as_str()
    }
 }

 impl PartialEq<str> for NamedNodeRef<'_> {
+    #[inline]
    fn eq(&self, other: &str) -> bool {
        self.as_str() == other
    }
 }

 impl PartialEq<NamedNodeRef<'_>> for str {
+    #[inline]
    fn eq(&self, other: &NamedNodeRef<'_>) -> bool {
        self == other.as_str()
    }
 }

 impl PartialEq<&str> for NamedNodeRef<'_> {
+    #[inline]
    fn eq(&self, other: &&str) -> bool {
        self == *other
    }
 }

 impl PartialEq<NamedNodeRef<'_>> for &str {
+    #[inline]
    fn eq(&self, other: &NamedNodeRef<'_>) -> bool {
        *self == other
    }
--- a/lib/src/model/triple.rs
+++ b/lib/src/model/triple.rs
@ -13,14 +13,17 @@ pub enum NamedOrBlankNode {
 }

 impl NamedOrBlankNode {
+    #[inline]
    pub fn is_named_node(&self) -> bool {
        self.as_ref().is_named_node()
    }

+    #[inline]
    pub fn is_blank_node(&self) -> bool {
        self.as_ref().is_blank_node()
    }

+    #[inline]
    pub fn as_ref(&self) -> NamedOrBlankNodeRef<'_> {
        match self {
            Self::NamedNode(node) => NamedOrBlankNodeRef::NamedNode(node.as_ref()),
@ -30,30 +33,35 @@ impl NamedOrBlankNode {
 }

 impl fmt::Display for NamedOrBlankNode {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
 }

 impl From<NamedNode> for NamedOrBlankNode {
+    #[inline]
    fn from(node: NamedNode) -> Self {
        Self::NamedNode(node)
    }
 }

 impl From<NamedNodeRef<'_>> for NamedOrBlankNode {
+    #[inline]
    fn from(node: NamedNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
 }

 impl From<BlankNode> for NamedOrBlankNode {
+    #[inline]
    fn from(node: BlankNode) -> Self {
        Self::BlankNode(node)
    }
 }

 impl From<BlankNodeRef<'_>> for NamedOrBlankNode {
+    #[inline]
    fn from(node: BlankNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
@ -67,6 +75,7 @@ pub enum NamedOrBlankNodeRef<'a> {
 }

 impl<'a> NamedOrBlankNodeRef<'a> {
+    #[inline]
    pub fn is_named_node(&self) -> bool {
        match self {
            Self::NamedNode(_) => true,
@ -74,6 +83,7 @@ impl<'a> NamedOrBlankNodeRef<'a> {
        }
    }

+    #[inline]
    pub fn is_blank_node(&self) -> bool {
        match self {
            Self::NamedNode(_) => false,
@ -81,6 +91,7 @@ impl<'a> NamedOrBlankNodeRef<'a> {
        }
    }

+    #[inline]
    pub fn into_owned(self) -> NamedOrBlankNode {
        match self {
            Self::NamedNode(node) => NamedOrBlankNode::NamedNode(node.into_owned()),
@ -90,6 +101,7 @@ impl<'a> NamedOrBlankNodeRef<'a> {
 }

 impl fmt::Display for NamedOrBlankNodeRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NamedNode(node) => node.fmt(f),
@ -99,42 +111,49 @@ impl fmt::Display for NamedOrBlankNodeRef<'_> {
 }

 impl<'a> From<NamedNodeRef<'a>> for NamedOrBlankNodeRef<'a> {
+    #[inline]
    fn from(node: NamedNodeRef<'a>) -> Self {
        Self::NamedNode(node)
    }
 }

 impl<'a> From<&'a NamedNode> for NamedOrBlankNodeRef<'a> {
+    #[inline]
    fn from(node: &'a NamedNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<BlankNodeRef<'a>> for NamedOrBlankNodeRef<'a> {
+    #[inline]
    fn from(node: BlankNodeRef<'a>) -> Self {
        Self::BlankNode(node)
    }
 }

 impl<'a> From<&'a BlankNode> for NamedOrBlankNodeRef<'a> {
+    #[inline]
    fn from(node: &'a BlankNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<&'a NamedOrBlankNode> for NamedOrBlankNodeRef<'a> {
+    #[inline]
    fn from(node: &'a NamedOrBlankNode) -> Self {
        node.as_ref()
    }
 }

 impl<'a> From<NamedOrBlankNodeRef<'a>> for NamedOrBlankNode {
+    #[inline]
    fn from(node: NamedOrBlankNodeRef<'a>) -> Self {
        node.into_owned()
    }
 }

 impl<'a> From<NamedOrBlankNodeRef<'a>> for rio::NamedOrBlankNode<'a> {
+    #[inline]
    fn from(node: NamedOrBlankNodeRef<'a>) -> Self {
        match node {
            NamedOrBlankNodeRef::NamedNode(node) => rio::NamedNode::from(node).into(),
@ -153,18 +172,22 @@ pub enum Term {
 }

 impl Term {
+    #[inline]
    pub fn is_named_node(&self) -> bool {
        self.as_ref().is_named_node()
    }

+    #[inline]
    pub fn is_blank_node(&self) -> bool {
        self.as_ref().is_blank_node()
    }

+    #[inline]
    pub fn is_literal(&self) -> bool {
        self.as_ref().is_literal()
    }

+    #[inline]
    pub fn as_ref(&self) -> TermRef<'_> {
        match self {
            Self::NamedNode(node) => TermRef::NamedNode(node.as_ref()),
@ -175,48 +198,56 @@ impl Term {
 }

 impl fmt::Display for Term {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
 }

 impl From<NamedNode> for Term {
+    #[inline]
    fn from(node: NamedNode) -> Self {
        Self::NamedNode(node)
    }
 }

 impl From<NamedNodeRef<'_>> for Term {
+    #[inline]
    fn from(node: NamedNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
 }

 impl From<BlankNode> for Term {
+    #[inline]
    fn from(node: BlankNode) -> Self {
        Self::BlankNode(node)
    }
 }

 impl From<BlankNodeRef<'_>> for Term {
+    #[inline]
    fn from(node: BlankNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
 }

 impl From<Literal> for Term {
+    #[inline]
    fn from(literal: Literal) -> Self {
        Self::Literal(literal)
    }
 }

 impl From<LiteralRef<'_>> for Term {
+    #[inline]
    fn from(literal: LiteralRef<'_>) -> Self {
        literal.into_owned().into()
    }
 }

 impl From<NamedOrBlankNode> for Term {
+    #[inline]
    fn from(node: NamedOrBlankNode) -> Self {
        match node {
            NamedOrBlankNode::NamedNode(node) => node.into(),
@ -226,6 +257,7 @@ impl From<NamedOrBlankNode> for Term {
 }

 impl From<NamedOrBlankNodeRef<'_>> for Term {
+    #[inline]
    fn from(node: NamedOrBlankNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
@ -241,6 +273,7 @@ pub enum TermRef<'a> {
 }

 impl<'a> TermRef<'a> {
+    #[inline]
    pub fn is_named_node(&self) -> bool {
        match self {
            Self::NamedNode(_) => true,
@ -248,6 +281,7 @@ impl<'a> TermRef<'a> {
        }
    }

+    #[inline]
    pub fn is_blank_node(&self) -> bool {
        match self {
            Self::BlankNode(_) => true,
@ -255,6 +289,7 @@ impl<'a> TermRef<'a> {
        }
    }

+    #[inline]
    pub fn is_literal(&self) -> bool {
        match self {
            Self::Literal(_) => true,
@ -262,6 +297,7 @@ impl<'a> TermRef<'a> {
        }
    }

+    #[inline]
    pub fn into_owned(self) -> Term {
        match self {
            Self::NamedNode(node) => Term::NamedNode(node.into_owned()),
@ -272,6 +308,7 @@ impl<'a> TermRef<'a> {
 }

 impl fmt::Display for TermRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NamedNode(node) => node.fmt(f),
@ -282,42 +319,49 @@ impl fmt::Display for TermRef<'_> {
 }

 impl<'a> From<NamedNodeRef<'a>> for TermRef<'a> {
+    #[inline]
    fn from(node: NamedNodeRef<'a>) -> Self {
        Self::NamedNode(node)
    }
 }

 impl<'a> From<&'a NamedNode> for TermRef<'a> {
+    #[inline]
    fn from(node: &'a NamedNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<BlankNodeRef<'a>> for TermRef<'a> {
+    #[inline]
    fn from(node: BlankNodeRef<'a>) -> Self {
        Self::BlankNode(node)
    }
 }

 impl<'a> From<&'a BlankNode> for TermRef<'a> {
+    #[inline]
    fn from(node: &'a BlankNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<LiteralRef<'a>> for TermRef<'a> {
+    #[inline]
    fn from(literal: LiteralRef<'a>) -> Self {
        Self::Literal(literal)
    }
 }

 impl<'a> From<&'a Literal> for TermRef<'a> {
+    #[inline]
    fn from(literal: &'a Literal) -> Self {
        literal.as_ref().into()
    }
 }

 impl<'a> From<NamedOrBlankNodeRef<'a>> for TermRef<'a> {
+    #[inline]
    fn from(node: NamedOrBlankNodeRef<'a>) -> Self {
        match node {
            NamedOrBlankNodeRef::NamedNode(node) => node.into(),
@ -327,24 +371,28 @@ impl<'a> From<NamedOrBlankNodeRef<'a>> for TermRef<'a> {
 }

 impl<'a> From<&'a NamedOrBlankNode> for TermRef<'a> {
+    #[inline]
    fn from(node: &'a NamedOrBlankNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<&'a Term> for TermRef<'a> {
+    #[inline]
    fn from(node: &'a Term) -> Self {
        node.as_ref()
    }
 }

 impl<'a> From<TermRef<'a>> for Term {
+    #[inline]
    fn from(node: TermRef<'a>) -> Self {
        node.into_owned()
    }
 }

 impl<'a> From<TermRef<'a>> for rio::Term<'a> {
+    #[inline]
    fn from(node: TermRef<'a>) -> Self {
        match node {
            TermRef::NamedNode(node) => rio::NamedNode::from(node).into(),
@ -369,6 +417,7 @@ pub struct Triple {

 impl Triple {
    /// Builds an RDF [triple](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple)
+    #[inline]
    pub fn new(
        subject: impl Into<NamedOrBlankNode>,
        predicate: impl Into<NamedNode>,
@ -412,6 +461,7 @@ impl Triple {
    }

    /// Encodes that this triple is in a [RDF dataset](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset)
+    #[inline]
    pub fn in_graph(self, graph_name: impl Into<GraphName>) -> Quad {
        Quad {
            subject: self.subject,
@ -421,6 +471,7 @@ impl Triple {
        }
    }

+    #[inline]
    pub fn as_ref(&self) -> TripleRef<'_> {
        TripleRef {
            subject: self.subject.as_ref(),
@ -431,6 +482,7 @@ impl Triple {
 }

 impl fmt::Display for Triple {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
@ -451,6 +503,7 @@ pub struct TripleRef<'a> {

 impl<'a> TripleRef<'a> {
    /// Builds an RDF [triple](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple)
+    #[inline]
    pub fn new(
        subject: impl Into<NamedOrBlankNodeRef<'a>>,
        predicate: impl Into<NamedNodeRef<'a>>,
@ -464,6 +517,7 @@ impl<'a> TripleRef<'a> {
    }

    /// Encodes that this triple is in a [RDF dataset](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset)
+    #[inline]
    pub fn in_graph(self, graph_name: impl Into<GraphNameRef<'a>>) -> QuadRef<'a> {
        QuadRef {
            subject: self.subject,
@ -473,6 +527,7 @@ impl<'a> TripleRef<'a> {
        }
    }

+    #[inline]
    pub fn into_owned(self) -> Triple {
        Triple {
            subject: self.subject.into_owned(),
@ -483,24 +538,28 @@ impl<'a> TripleRef<'a> {
 }

 impl fmt::Display for TripleRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        rio::Triple::from(*self).fmt(f)
    }
 }

 impl<'a> From<&'a Triple> for TripleRef<'a> {
+    #[inline]
    fn from(triple: &'a Triple) -> Self {
        triple.as_ref()
    }
 }

 impl<'a> From<TripleRef<'a>> for Triple {
+    #[inline]
    fn from(triple: TripleRef<'a>) -> Self {
        triple.into_owned()
    }
 }

 impl<'a> From<TripleRef<'a>> for rio::Triple<'a> {
+    #[inline]
    fn from(triple: TripleRef<'a>) -> Self {
        rio::Triple {
            subject: triple.subject.into(),
@ -520,18 +579,22 @@ pub enum GraphName {
 }

 impl GraphName {
+    #[inline]
    pub fn is_named_node(&self) -> bool {
        self.as_ref().is_named_node()
    }

+    #[inline]
    pub fn is_blank_node(&self) -> bool {
        self.as_ref().is_blank_node()
    }

+    #[inline]
    pub fn is_default_graph(&self) -> bool {
        self.as_ref().is_default_graph()
    }

+    #[inline]
    pub fn as_ref(&self) -> GraphNameRef<'_> {
        match self {
            Self::NamedNode(node) => GraphNameRef::NamedNode(node.as_ref()),
@ -542,36 +605,42 @@ impl GraphName {
 }

 impl fmt::Display for GraphName {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
 }

 impl From<NamedNode> for GraphName {
+    #[inline]
    fn from(node: NamedNode) -> Self {
        GraphName::NamedNode(node)
    }
 }

 impl From<NamedNodeRef<'_>> for GraphName {
+    #[inline]
    fn from(node: NamedNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
 }

 impl From<BlankNode> for GraphName {
+    #[inline]
    fn from(node: BlankNode) -> Self {
        GraphName::BlankNode(node)
    }
 }

 impl From<BlankNodeRef<'_>> for GraphName {
+    #[inline]
    fn from(node: BlankNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
 }

 impl From<NamedOrBlankNode> for GraphName {
+    #[inline]
    fn from(node: NamedOrBlankNode) -> Self {
        match node {
            NamedOrBlankNode::NamedNode(node) => node.into(),
@ -581,12 +650,14 @@ impl From<NamedOrBlankNode> for GraphName {
 }

 impl From<NamedOrBlankNodeRef<'_>> for GraphName {
+    #[inline]
    fn from(node: NamedOrBlankNodeRef<'_>) -> Self {
        node.into_owned().into()
    }
 }

 impl From<Option<NamedOrBlankNode>> for GraphName {
+    #[inline]
    fn from(name: Option<NamedOrBlankNode>) -> Self {
        if let Some(node) = name {
            node.into()
@ -597,6 +668,7 @@ impl From<Option<NamedOrBlankNode>> for GraphName {
 }

 impl From<GraphName> for Option<NamedOrBlankNode> {
+    #[inline]
    fn from(name: GraphName) -> Self {
        match name {
            GraphName::NamedNode(node) => Some(node.into()),
@ -616,6 +688,7 @@ pub enum GraphNameRef<'a> {
 }

 impl<'a> GraphNameRef<'a> {
+    #[inline]
    pub fn is_named_node(&self) -> bool {
        match self {
            GraphNameRef::NamedNode(_) => true,
@ -623,6 +696,7 @@ impl<'a> GraphNameRef<'a> {
        }
    }

+    #[inline]
    pub fn is_blank_node(&self) -> bool {
        match self {
            GraphNameRef::BlankNode(_) => true,
@ -630,6 +704,7 @@ impl<'a> GraphNameRef<'a> {
        }
    }

+    #[inline]
    pub fn is_default_graph(&self) -> bool {
        match self {
            GraphNameRef::DefaultGraph => true,
@ -637,6 +712,7 @@ impl<'a> GraphNameRef<'a> {
        }
    }

+    #[inline]
    pub fn into_owned(self) -> GraphName {
        match self {
            Self::NamedNode(node) => GraphName::NamedNode(node.into_owned()),
@ -647,6 +723,7 @@ impl<'a> GraphNameRef<'a> {
 }

 impl fmt::Display for GraphNameRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NamedNode(node) => node.fmt(f),
@ -657,30 +734,35 @@ impl fmt::Display for GraphNameRef<'_> {
 }

 impl<'a> From<NamedNodeRef<'a>> for GraphNameRef<'a> {
+    #[inline]
    fn from(node: NamedNodeRef<'a>) -> Self {
        Self::NamedNode(node)
    }
 }

 impl<'a> From<&'a NamedNode> for GraphNameRef<'a> {
+    #[inline]
    fn from(node: &'a NamedNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<BlankNodeRef<'a>> for GraphNameRef<'a> {
+    #[inline]
    fn from(node: BlankNodeRef<'a>) -> Self {
        Self::BlankNode(node)
    }
 }

 impl<'a> From<&'a BlankNode> for GraphNameRef<'a> {
+    #[inline]
    fn from(node: &'a BlankNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<NamedOrBlankNodeRef<'a>> for GraphNameRef<'a> {
+    #[inline]
    fn from(node: NamedOrBlankNodeRef<'a>) -> Self {
        match node {
            NamedOrBlankNodeRef::NamedNode(node) => node.into(),
@ -690,24 +772,28 @@ impl<'a> From<NamedOrBlankNodeRef<'a>> for GraphNameRef<'a> {
 }

 impl<'a> From<&'a NamedOrBlankNode> for GraphNameRef<'a> {
+    #[inline]
    fn from(node: &'a NamedOrBlankNode) -> Self {
        node.as_ref().into()
    }
 }

 impl<'a> From<&'a GraphName> for GraphNameRef<'a> {
+    #[inline]
    fn from(node: &'a GraphName) -> Self {
        node.as_ref()
    }
 }

 impl<'a> From<GraphNameRef<'a>> for GraphName {
+    #[inline]
    fn from(node: GraphNameRef<'a>) -> Self {
        node.into_owned()
    }
 }

 impl<'a> From<Option<NamedOrBlankNodeRef<'a>>> for GraphNameRef<'a> {
+    #[inline]
    fn from(name: Option<NamedOrBlankNodeRef<'a>>) -> Self {
        if let Some(node) = name {
            node.into()
@ -718,6 +804,7 @@ impl<'a> From<Option<NamedOrBlankNodeRef<'a>>> for GraphNameRef<'a> {
 }

 impl<'a> From<GraphNameRef<'a>> for Option<NamedOrBlankNodeRef<'a>> {
+    #[inline]
    fn from(name: GraphNameRef<'a>) -> Self {
        match name {
            GraphNameRef::NamedNode(node) => Some(node.into()),
@ -728,6 +815,7 @@ impl<'a> From<GraphNameRef<'a>> for Option<NamedOrBlankNodeRef<'a>> {
 }

 impl<'a> From<GraphNameRef<'a>> for Option<rio::NamedOrBlankNode<'a>> {
+    #[inline]
    fn from(name: GraphNameRef<'a>) -> Self {
        match name {
            GraphNameRef::NamedNode(node) => Some(rio::NamedNode::from(node).into()),
@ -755,6 +843,7 @@ pub struct Quad {

 impl Quad {
    /// Builds an RDF [triple](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple) in a [RDF dataset](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset)
+    #[inline]
    pub fn new(
        subject: impl Into<NamedOrBlankNode>,
        predicate: impl Into<NamedNode>,
@ -810,6 +899,7 @@ impl Quad {
    }

    #[deprecated(note = "Use `Triple::from` instead")]
+    #[inline]
    pub fn into_triple(self) -> Triple {
        Triple::new(self.subject, self.predicate, self.object)
    }
@ -819,6 +909,7 @@ impl Quad {
        (self.subject, self.predicate, self.object, self.graph_name)
    }

+    #[inline]
    pub fn as_ref(&self) -> QuadRef<'_> {
        QuadRef {
            subject: self.subject.as_ref(),
@ -830,12 +921,14 @@ impl Quad {
 }

 impl fmt::Display for Quad {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.as_ref().fmt(f)
    }
 }

 impl From<Quad> for Triple {
+    #[inline]
    fn from(quad: Quad) -> Self {
        Self {
            subject: quad.subject,
@ -863,6 +956,7 @@ pub struct QuadRef<'a> {

 impl<'a> QuadRef<'a> {
    /// Builds an RDF [triple](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-triple) in a [RDF dataset](https://www.w3.org/TR/rdf11-concepts/#dfn-rdf-dataset)
+    #[inline]
    pub fn new(
        subject: impl Into<NamedOrBlankNodeRef<'a>>,
        predicate: impl Into<NamedNodeRef<'a>>,
@ -877,6 +971,7 @@ impl<'a> QuadRef<'a> {
        }
    }

+    #[inline]
    pub fn into_owned(self) -> Quad {
        Quad {
            subject: self.subject.into_owned(),
@ -888,12 +983,14 @@ impl<'a> QuadRef<'a> {
 }

 impl fmt::Display for QuadRef<'_> {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        rio::Quad::from(*self).fmt(f)
    }
 }

 impl<'a> From<QuadRef<'a>> for TripleRef<'a> {
+    #[inline]
    fn from(quad: QuadRef<'a>) -> Self {
        Self {
            subject: quad.subject,
@ -904,18 +1001,21 @@ impl<'a> From<QuadRef<'a>> for TripleRef<'a> {
 }

 impl<'a> From<&'a Quad> for QuadRef<'a> {
+    #[inline]
    fn from(quad: &'a Quad) -> Self {
        quad.as_ref()
    }
 }

 impl<'a> From<QuadRef<'a>> for Quad {
+    #[inline]
    fn from(quad: QuadRef<'a>) -> Self {
        quad.into_owned()
    }
 }

 impl<'a> From<QuadRef<'a>> for rio::Quad<'a> {
+    #[inline]
    fn from(quad: QuadRef<'a>) -> Self {
        rio::Quad {
            subject: quad.subject.into(),
--- a/lib/src/sparql/model.rs
+++ b/lib/src/sparql/model.rs
@ -107,6 +107,7 @@ impl QueryResult {
 }

 impl From<QuerySolutionsIterator> for QueryResult {
+    #[inline]
    fn from(value: QuerySolutionsIterator) -> Self {
        QueryResult::Solutions(value)
    }
@ -132,6 +133,7 @@ impl QueryResultFormat {
    ///
    /// assert_eq!(QueryResultFormat::Json.iri(), "http://www.w3.org/ns/formats/SPARQL_Results_JSON")
    /// ```
+    #[inline]
    pub fn iri(self) -> &'static str {
        match self {
            QueryResultFormat::Xml => "http://www.w3.org/ns/formats/SPARQL_Results_XML",
@ -145,6 +147,7 @@ impl QueryResultFormat {
    ///
    /// assert_eq!(QueryResultFormat::Json.media_type(), "application/sparql-results+json")
    /// ```
+    #[inline]
    pub fn media_type(self) -> &'static str {
        match self {
            QueryResultFormat::Xml => "application/sparql-results+xml",
@ -159,6 +162,7 @@ impl QueryResultFormat {
    ///
    /// assert_eq!(QueryResultFormat::Json.file_extension(), "srj")
    /// ```
+    #[inline]
    pub fn file_extension(self) -> &'static str {
        match self {
            QueryResultFormat::Xml => "srx",
@ -252,6 +256,7 @@ impl QuerySolutionsIterator {
    /// }
    /// # Result::<_,Box<dyn std::error::Error>>::Ok(())
    /// ```
+    #[inline]
    pub fn variables(&self) -> &[Variable] {
        &*self.variables
    }
@ -277,6 +282,7 @@ impl QuerySolutionsIterator {
 impl Iterator for QuerySolutionsIterator {
    type Item = Result<QuerySolution, EvaluationError>;

+    #[inline]
    fn next(&mut self) -> Option<Result<QuerySolution, EvaluationError>> {
        Some(self.iter.next()?.map(|values| QuerySolution {
            values,
@ -284,6 +290,7 @@ impl Iterator for QuerySolutionsIterator {
        }))
    }

+    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }
@ -304,21 +311,25 @@ impl QuerySolution {
    /// let foo = solution.get("foo"); // Get the value of the variable ?foo if it exists
    /// let first = solution.get(1); // Get the value of the second column if it exists
    /// ```
+    #[inline]
    pub fn get(&self, index: impl VariableSolutionIndex) -> Option<&Term> {
        self.values.get(index.index(self)?).and_then(|e| e.as_ref())
    }

    /// The number of variables which are bind
+    #[inline]
    pub fn len(&self) -> usize {
        self.values.len()
    }

    /// Is this binding empty?
+    #[inline]
    pub fn is_empty(&self) -> bool {
        self.values.is_empty()
    }

    /// Returns an iterator over bound variables
+    #[inline]
    pub fn iter(&self) -> impl Iterator<Item = (&Variable, &Term)> {
        self.values
            .iter()
@ -339,24 +350,28 @@ pub trait VariableSolutionIndex {
 }

 impl VariableSolutionIndex for usize {
+    #[inline]
    fn index(self, _: &QuerySolution) -> Option<usize> {
        Some(self)
    }
 }

 impl VariableSolutionIndex for &str {
+    #[inline]
    fn index(self, solution: &QuerySolution) -> Option<usize> {
        solution.variables.iter().position(|v| v.as_str() == self)
    }
 }

 impl VariableSolutionIndex for &Variable {
+    #[inline]
    fn index(self, solution: &QuerySolution) -> Option<usize> {
        solution.variables.iter().position(|v| v == self)
    }
 }

 impl VariableSolutionIndex for Variable {
+    #[inline]
    fn index(self, solution: &QuerySolution) -> Option<usize> {
        (&self).index(solution)
    }
@ -383,14 +398,17 @@ pub struct QueryTriplesIterator {
 impl Iterator for QueryTriplesIterator {
    type Item = Result<Triple, EvaluationError>;

+    #[inline]
    fn next(&mut self) -> Option<Result<Triple, EvaluationError>> {
        self.iter.next()
    }

+    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }

+    #[inline]
    fn fold<Acc, G>(self, init: Acc, mut g: G) -> Acc
    where
        G: FnMut(Acc, Self::Item) -> Acc,
@ -415,10 +433,12 @@ pub struct Variable {
 }

 impl Variable {
+    #[inline]
    pub fn new(name: impl Into<String>) -> Self {
        Variable { name: name.into() }
    }

+    #[inline]
    pub fn as_str(&self) -> &str {
        &self.name
    }
@ -428,16 +448,19 @@ impl Variable {
        Ok(self.as_str())
    }

+    #[inline]
    pub fn into_string(self) -> String {
        self.name
    }

+    #[inline]
    pub(crate) fn new_random() -> Self {
        Self::new(format!("{:x}", random::<u128>()))
    }
 }

 impl fmt::Display for Variable {
+    #[inline]
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "?{}", self.name)
    }
--- a/python/src/memory_store.rs
+++ b/python/src/memory_store.rs
@ -48,7 +48,7 @@ impl PyMemoryStore {
    /// [<Quad subject=<NamedNode value=http://example.com> predicate=<NamedNode value=http://example.com/p> object=<Literal value=1 datatype=<NamedNode value=http://www.w3.org/2001/XMLSchema#string>> graph_name=<NamedNode value=http://example.com/g>>]
    #[text_signature = "($self, quad)"]
    fn add(&self, quad: PyQuad) {
-        self.inner.insert(quad.into());
+        self.inner.insert(quad);
    }

    /// Removes a quad from the store