Enum Value 

pub enum Value {
    Nil,
    Bool(bool),
    Number(f64),
    Str(Vec<u8>),
    Table(Table),
    Function(Func),
    Global(Global),
}

A Lua value.

Numbers are f64, matching Lua’s default number type. Strings hold raw bytes because Lua strings are byte sequences and may contain NUL or other control characters. Tables are shared handles so two references to the same table compare equal by identity.

Equality follows Lua. Scalars compare by value. NaN is not equal to itself. Tables, functions, and globals compare by identity, not by contents.

Variants

Nil

Lua nil.

Bool(bool)

Lua boolean.

Number(f64)

Lua number. Serialized with numformat, or as 1/0, -1/0, 0/0 for the special values.

Str(Vec<u8>)

Lua string, stored as raw bytes.

Table(Table)

Lua table with an array part and a hash part.

Function(Func)

A Lua function. Held opaquely by an identity id. The serializer emits a bytecode-reload stub or, under nocode, an empty body.

Global(Global)

A value known by a global name, such as print or io.stdin. The serializer emits the name verbatim.

Implementations

impl Value

pub fn ident(&self) -> Option<Ident>

The identity of a reference value, if it has one.

Only tables, functions, and globals participate in shared-reference tracking. Scalars return None.

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl PartialEq for Value

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