Enum SemanticValue 

pub enum SemanticValue<S: SemanticString> {
    Bool(bool),
    Int(i32),
    Float(f32),
    Double(f64),
    String(S),
}

A value that forms part of the semantic information for a recognized phrase.

Variants

Bool(bool)

Int(i32)

Float(f32)

Double(f64)

String(S)

Implementations

impl<S: SemanticString> SemanticValue<S>

pub fn into<T: SemanticString>(self) -> SemanticValue<T>

where S: Into<T>,

Converts the value from one generic type into a compatible generic type.

pub fn as_bool(&self) -> Option<&bool>

Borrows the underlying value, if this is a SemanticValue::Bool.

pub fn as_int(&self) -> Option<&i32>

Borrows the underlying value, if this is a SemanticValue::Int.

pub fn as_float(&self) -> Option<&f32>

Borrows the underlying value, if this is a SemanticValue::Float.

pub fn as_double(&self) -> Option<&f64>

Borrows the underlying value, if this is a SemanticValue::Double.

pub fn as_string(&self) -> Option<&S>

Borrows the underlying value, if this is a SemanticValue::String.

Trait Implementations

impl<S: Clone + SemanticString> Clone for SemanticValue<S>

fn clone(&self) -> SemanticValue<S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Debug + SemanticString> Debug for SemanticValue<S>

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

Formats the value using the given formatter.

impl<F: SemanticString + Into<T>, T: SemanticString> From<F> for SemanticValue<T>

fn from(source: F) -> Self

Converts to this type from the input type.

impl<S: SemanticString> From<bool> for SemanticValue<S>

fn from(source: bool) -> Self

Converts to this type from the input type.

impl<S: SemanticString> From<f32> for SemanticValue<S>

fn from(source: f32) -> Self

Converts to this type from the input type.

impl<S: SemanticString> From<f64> for SemanticValue<S>

fn from(source: f64) -> Self

Converts to this type from the input type.

impl<S: SemanticString> From<i32> for SemanticValue<S>

fn from(source: i32) -> Self

Converts to this type from the input type.

impl<S: SemanticString> PartialEq<&OsStr> for SemanticValue<S>

fn eq(&self, other: &&OsStr) -> 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<S: SemanticString> PartialEq<&str> for SemanticValue<S>

fn eq(&self, other: &&str) -> 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<S: SemanticString> PartialEq<OsStr> for SemanticValue<S>

fn eq(&self, other: &OsStr) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for &OsStr

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for &str

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for OsStr

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for bool

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for f32

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for f64

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for i32

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<SemanticValue<S>> for str

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> PartialEq<bool> for SemanticValue<S>

fn eq(&self, other: &bool) -> 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<S: SemanticString> PartialEq<f32> for SemanticValue<S>

fn eq(&self, other: &f32) -> 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<S: SemanticString> PartialEq<f64> for SemanticValue<S>

fn eq(&self, other: &f64) -> 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<S: SemanticString> PartialEq<i32> for SemanticValue<S>

fn eq(&self, other: &i32) -> 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<S: SemanticString> PartialEq<str> for SemanticValue<S>

fn eq(&self, other: &str) -> 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<S: PartialEq + SemanticString> PartialEq for SemanticValue<S>

fn eq(&self, other: &SemanticValue<S>) -> 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<S: SemanticString> StructuralPartialEq for SemanticValue<S>