Enum Term

pub enum Term<T = IriBuf, B = BlankIdBuf> {
    Null,
    Id(Id<T, B>),
    Keyword(Keyword),
}

Identifier, keyword or @null.

Variants

Null

@null value.

Id(Id<T, B>)

Node identifier.

Keyword(Keyword)

Keyword.

Implementations

impl<I, B> Term<I, B>

pub fn is_null(&self) -> bool

Checks if this term is @null.

pub fn into_iri(self) -> Result<I, Term<I, B>>

Turns this term into an IRI if possible.

If it is not an IRI, returns the term itself.

pub fn is_keyword(&self) -> bool

Checks if this term is a keyword.

pub fn as_iri(&self) -> Option<&I>

Returns a reference to the IRI representation of the term, if any.

pub fn map_id<U, C>(self, f: impl FnOnce(Id<I, B>) -> Id<U, C>) -> Term<U, C>

impl<T, B> Term<T, B>

where T: AsRef<str>, B: AsRef<str>,

pub fn as_str(&self) -> &str

Trait Implementations

impl<T, B, N> AsRefWithContext<str, N> for Term<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn as_ref_with<'a>(&'a self, vocabulary: &'a N) -> &'a str

impl<T, B> Clone for Term<T, B>

where T: Clone, B: Clone,

fn clone(&self) -> Term<T, B>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, B> Debug for Term<T, B>

where T: Debug, B: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, B> Display for Term<T, B>

where T: Display, B: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, B, N> DisplayWithContext<N> for Term<T, B>

where N: Vocabulary<Iri = T, BlankId = B>,

fn fmt_with(&self, vocabulary: &N, f: &mut Formatter<'_>) -> Result<(), Error>

impl<'a, T, B> From<&'a Term<T, B>> for Term<&'a T, &'a B>

fn from(t: &'a Term<T, B>) -> Term<&'a T, &'a B>

Converts to this type from the input type.

impl<T, B> From<Id<T, B>> for Term<T, B>

fn from(prop: Id<T, B>) -> Term<T, B>

Converts to this type from the input type.

impl<T, B> From<T> for Term<T, B>

fn from(id: T) -> Term<T, B>

Converts to this type from the input type.

impl<I, B> From<Type<I>> for Term<I, B>

fn from(t: Type<I>) -> Term<I, B>

Converts to this type from the input type.

impl<T, B> Hash for Term<T, B>

where T: Hash, B: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, B> PartialEq<Id<T, B>> for Term<T, B>

where T: PartialEq, B: PartialEq,

fn eq(&self, r: &Id<T, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, B> PartialEq<Term<T, B>> for Id<T, B>

where T: PartialEq, B: PartialEq,

fn eq(&self, term: &Term<T, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, B> PartialEq for Term<T, B>

where T: PartialEq, B: PartialEq,

fn eq(&self, other: &Term<T, B>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I, B> TryFrom<Term<I, B>> for Type<I>

type Error = Term<I, B>

The type returned in the event of a conversion error.

fn try_from(term: Term<I, B>) -> Result<Type<I>, Term<I, B>>

Performs the conversion.

impl<T, B> TryFrom<Term<T, B>> for Id<T, B>

type Error = Term<T, B>

The type returned in the event of a conversion error.

fn try_from(term: Term<T, B>) -> Result<Id<T, B>, Term<T, B>>

Performs the conversion.

impl<T, B> Eq for Term<T, B>

where T: Eq, B: Eq,

impl<T, B> StructuralPartialEq for Term<T, B>