Struct Chunk

pub struct Chunk<'a> { /* private fields */ }

Returned from Lua::load and is used to finalize loading and executing Lua main chunks.

Implementations

impl Chunk<'_>

pub fn name(&self) -> &str

Returns the name of this chunk.

pub fn set_name(self, name: impl Into<StdString>) -> Self

Sets the name of this chunk, which results in more informative error traces.

Possible name prefixes:

• @ - file path (when truncation is needed, the end of the file path is kept, as this is more useful for identifying the file)
• = - custom chunk name (when truncation is needed, the beginning of the name is kept)

pub fn environment(&self) -> Option<&Table>

Returns the environment of this chunk.

pub fn set_environment(self, env: Table) -> Self

Sets the environment of the loaded chunk to the given value.

In Lua >=5.2 main chunks always have exactly one upvalue, and this upvalue is used as the _ENV variable inside the chunk. By default this value is set to the global environment.

Calling this method changes the _ENV upvalue to the value provided, and variables inside the chunk will refer to the given environment rather than the global one.

All global variables (including the standard library!) are looked up in _ENV, so it may be necessary to populate the environment in order for scripts using custom environments to be useful.

pub fn mode(&self) -> ChunkMode

Returns the mode (auto-detected by default) of this chunk.

pub fn set_mode(self, mode: ChunkMode) -> Self

Sets whether the chunk is text or binary (autodetected by default).

Be aware, Lua does not check the consistency of the code inside binary chunks. Running maliciously crafted bytecode can crash the interpreter.

pub fn set_compiler(self, compiler: Compiler) -> Self

Available on crate feature luau only.

Sets or overwrites a Luau compiler used for this chunk.

See Compiler for details and possible options.

pub fn exec(self) -> Result<()>

Execute this chunk of code.

This is equivalent to calling the chunk function with no arguments and no return values.

pub async fn exec_async(self) -> Result<()>

Available on crate feature async only.

Asynchronously execute this chunk of code.

See exec for more details.

pub fn eval<R: FromLuaMulti>(self) -> Result<R>

Evaluate the chunk as either an expression or block.

If the chunk can be parsed as an expression, this loads and executes the chunk and returns the value that it evaluates to. Otherwise, the chunk is interpreted as a block as normal, and this is equivalent to calling exec.

pub async fn eval_async<R>(self) -> Result<R>

where R: FromLuaMulti,

Available on crate feature async only.

Asynchronously evaluate the chunk as either an expression or block.

See eval for more details.

pub fn call<R: FromLuaMulti>(self, args: impl IntoLuaMulti) -> Result<R>

Load the chunk function and call it with the given arguments.

This is equivalent to into_function and calling the resulting function.

pub async fn call_async<R>(self, args: impl IntoLuaMulti) -> Result<R>

where R: FromLuaMulti,

Available on crate feature async only.

Load the chunk function and asynchronously call it with the given arguments.

See call for more details.

pub fn into_function(self) -> Result<Function>

Load this chunk into a regular Function.

This simply compiles the chunk without actually executing it.