[][src]Struct mlua::Thread

pub struct Thread<'lua>(_);

Handle to an internal Lua thread (or coroutine).


impl<'lua> Thread<'lua>[src]

pub fn resume<A, R>(&self, args: A) -> Result<R> where
    A: ToLuaMulti<'lua>,
    R: FromLuaMulti<'lua>, 

Resumes execution of this thread.

Equivalent to coroutine.resume.

Passes args as arguments to the thread. If the coroutine has called coroutine.yield, it will return these arguments. Otherwise, the coroutine wasn't yet started, so the arguments are passed to its main function.

If the thread is no longer in Active state (meaning it has finished execution or encountered an error), this will return Err(CoroutineInactive), otherwise will return Ok as follows:

If the thread calls coroutine.yield, returns the values passed to yield. If the thread returns values from its main function, returns those.


let thread: Thread = lua.load(r#"
        assert(arg == 42)
        local yieldarg = coroutine.yield(123)
        assert(yieldarg == 43)
        return 987

assert_eq!(thread.resume::<_, u32>(42)?, 123);
assert_eq!(thread.resume::<_, u32>(43)?, 987);

// The coroutine has now returned, so `resume` will fail
match thread.resume::<_, u32>(()) {
    Err(Error::CoroutineInactive) => {},
    unexpected => panic!("unexpected result {:?}", unexpected),

pub fn status(&self) -> ThreadStatus[src]

Gets the status of the thread.

pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R> where
    A: ToLuaMulti<'lua>,
    R: FromLuaMulti<'lua>, 

Converts Thread to an AsyncThread which implements Future and Stream traits.

args are passed as arguments to the thread function for first call. The object call resume() while polling and also allows to run rust futures to completion using an executor.

Using AsyncThread as a Stream allows to iterate through coroutine.yield() values whereas Future version discards that values and poll until the final one (returned from the thread function).


use futures::stream::TryStreamExt;
let thread: Thread = lua.load(r#"
    coroutine.create(function (sum)
        for i = 1,10 do
            sum = sum + i
        return sum

let mut stream = thread.into_async::<_, i64>(1);
let mut sum = 0;
while let Some(n) = stream.try_next().await? {
    sum += n;

assert_eq!(sum, 286);

Trait Implementations

impl<'lua> Clone for Thread<'lua>[src]

impl<'lua> Debug for Thread<'lua>[src]

impl<'lua> FromLua<'lua> for Thread<'lua>[src]

impl<'lua> PartialEq<Thread<'lua>> for Thread<'lua>[src]

impl<'lua> ToLua<'lua> for Thread<'lua>[src]

Auto Trait Implementations

impl<'lua> !RefUnwindSafe for Thread<'lua>

impl<'lua> !Send for Thread<'lua>

impl<'lua> !Sync for Thread<'lua>

impl<'lua> Unpin for Thread<'lua>

impl<'lua> !UnwindSafe for Thread<'lua>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized

impl<T> Borrow<T> for T where
    T: ?Sized

impl<T> BorrowMut<T> for T where
    T: ?Sized

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 

impl<T> ToOwned for T where
    T: Clone

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.