Enum TypedValue 

pub enum TypedValue<T: TypeSet = DefaultTypeSet> {
    Void,
    MaybeSignedInt(T::Integer),
    Int(T::Integer),
    SignedInt(T::SignedInteger),
    Float(T::Float),
    Bool(bool),
    String(T::String),
}

Represents any value in the expression language.

Variants

Void

Represents no value.

MaybeSignedInt(T::Integer)

Represents an integer that may be signed or unsigned.

MaybeSignedInt can compare equal with Int and SignedInt.

Int(T::Integer)

Represents an unsigned integer.

SignedInt(T::SignedInteger)

Represents a signed integer.

Float(T::Float)

Represents a floating-point.

Bool(bool)

Represents a boolean.

String(T::String)

Represents a string.

Implementations

impl<T: TypeSet> TypedValue<T>

pub fn type_of(&self) -> Type

Returns the Somni type of this value.

Trait Implementations

impl<T: TypeSet> Clone for TypedValue<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + TypeSet> Debug for TypedValue<T>

where T::Integer: Debug, T::SignedInteger: Debug, T::Float: Debug, T::String: Debug,

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

Formats the value using the given formatter.

impl<T: TypeSet> LoadOwned<T> for TypedValue<T>

type Output = TypedValue<T>

The type of the result.

fn load_owned(_ctx: &T, typed: &TypedValue<T>) -> Option<Self>

Loads an owned value from the given type context.

impl<T: TypeSet> LoadStore<T> for TypedValue<T>

type Output<'s> = TypedValue<T>

The type of the result.

fn load(ctx: &T, typed: &TypedValue<T>) -> Option<Self>

Loads a borrowed value from the given type context.

fn store(&self, _ctx: &mut T) -> TypedValue<T>

Stores a Rust value into a TypedValue using the given type context.

impl<T: TypeSet> PartialEq for TypedValue<T>

fn eq(&self, other: &Self) -> 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.