Enum LuaVersion 

#[non_exhaustive]
pub enum LuaVersion {
    V51,
    V52,
    V53,
    V54,
    V55,
}

Which Lua language version a runtime instance speaks.

Default is LuaVersion::V54 — the version this codebase currently implements end-to-end — so that Lua::new() and any other defaulted construction keeps the existing 5.4 behavior.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

V51

Lua 5.1 — float-only, fenv-based globals. Deferred (separate core).

V52

Lua 5.2 — float-only, modern _ENV globals. Deferred (separate core).

V53

Lua 5.3 — dual subtype, modern _ENV. Deferred.

V54

Lua 5.4 — the implemented baseline today.

V55

Lua 5.5 — dual subtype, declared-globals scope model. Deferred.

Implementations

impl LuaVersion

pub fn number_model(self) -> NumberModel

The family-level numeric model for this version.

pub fn is_supported(self) -> bool

Whether this version has a real backend. The modern family (5.3/5.4/5.5) and 5.2 (float-only + _ENV) are complete. 5.1 reuses the 5.2 float-only core plus three faithful 5.1-specific axes:

• fenv globals — getfenv/setfenv (the per-function environment model, Option B over the reused _ENV upvalue; specs/followup/5.1-fenv.md).
• metamethod diffs — #t never consults a table __len, no __pairs/__ipairs, no __gc on tables (userdata only).
• roster + syntax — unpack is global (no table.unpack/pack/ move); loadstring + reader-only load; table.getn/setn(stub)/ maxn/foreach/foreachi; module/package.seeall/package.loaders (no package.searchers); string.gfind; math.log 1-arg + log10/atan2/pow/mod (no math.type); gcinfo; newproxy; xpcall-no-extra-args; coroutine.running nil in main; no bit32/ utf8/rawlen; goto/labels////bitwise/<const>/\x-\z escapes rejected (goto stays a valid identifier). See specs/followup/5.1-roster-syntax.md. Documented divergences: the math.random C-rand() sequence and os.execute raw-status byte are host-dependent (contract matches; exact bytes do not).

pub fn version_str(self) -> &'static str

The _VERSION global string for this version (e.g. "Lua 5.4").

pub fn luac_version_byte(self) -> u8

The LUAC_VERSION byte written into a luac/string.dump header for this version. Upstream encodes the version as (major << 4) | minor, e.g. 5.4 → 0x54.

Trait Implementations

impl Clone for LuaVersion

fn clone(&self) -> LuaVersion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LuaVersion

impl Debug for LuaVersion

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

Formats the value using the given formatter.

impl Default for LuaVersion

fn default() -> Self

Returns the “default value” for a type.

impl Eq for LuaVersion

impl Hash for LuaVersion

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

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 PartialEq for LuaVersion

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