Struct Isle 

pub struct Isle { /* private fields */ }

Handle to a thread-isolated Lua VM.

Isle owns the communication channel and the join handle for the Lua thread. All operations are thread-safe (Isle: Send + Sync).

Lifecycle

1. Isle::spawn creates the Lua VM on a dedicated thread.
2. Use eval, call, or exec to run code.
3. shutdown sends a graceful stop signal and joins the thread.

If the Isle is dropped without calling shutdown, the channel disconnects and the Lua thread exits on its next receive attempt.

Implementations

impl Isle

pub fn spawn<F>(init: F) -> Result<Self, IsleError>

where F: FnOnce(&Lua) -> Result<(), Error> + Send + 'static,

Spawn a new Lua VM on a dedicated thread.

The init closure runs on the Lua thread before any requests are processed. Use it to register globals, install mlua-pkg resolvers, load mlua-batteries, etc.

Errors

Returns IsleError::Init if the init closure fails.

pub fn eval(&self, code: &str) -> Result<String, IsleError>

Evaluate a Lua chunk (blocking).

Returns the result as a string. Equivalent to spawn_eval(code).wait().

pub fn spawn_eval(&self, code: &str) -> Task

Evaluate a Lua chunk, returning a cancellable Task.

pub fn call(&self, func: &str, args: &[&str]) -> Result<String, IsleError>

Call a named global Lua function with string arguments (blocking).

pub fn spawn_call(&self, func: &str, args: &[&str]) -> Task

Call a named global Lua function, returning a cancellable Task.

pub fn exec<F>(&self, f: F) -> Result<String, IsleError>

where F: FnOnce(&Lua) -> Result<String, IsleError> + Send + 'static,

Execute an arbitrary closure on the Lua thread (blocking).

The closure receives &Lua and can perform any operation. This is the escape hatch for complex interactions that don’t fit into eval or call.

Note: The cancel hook only fires during Lua instruction execution. If the closure blocks in Rust code (e.g. HTTP calls, file I/O), cancellation will not take effect until control returns to the Lua VM.

pub fn spawn_exec<F>(&self, f: F) -> Task

where F: FnOnce(&Lua) -> Result<String, IsleError> + Send + 'static,

Execute a closure on the Lua thread, returning a cancellable Task.

pub fn shutdown(self) -> Result<(), IsleError>

Graceful shutdown: signal the Lua thread to exit and join it.

After shutdown, all subsequent requests will return IsleError::Shutdown.

pub fn is_alive(&self) -> bool

Check if the Lua thread is still alive.

Trait Implementations

impl Drop for Isle

fn drop(&mut self)

Executes the destructor for this type.