pub struct Thread<'lua>(/* private fields */);Expand description
Handle to an internal Lua thread (or coroutine).
Implementations§
Source§impl<'lua> Thread<'lua>
impl<'lua> Thread<'lua>
Sourcepub fn resume<A, R>(&self, args: A) -> Result<R>where
A: ToLuaMulti<'lua>,
R: FromLuaMulti<'lua>,
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.
§Examples
let thread: Thread = lua.load(r#"
coroutine.create(function(arg)
assert(arg == 42)
local yieldarg = coroutine.yield(123)
assert(yieldarg == 43)
return 987
end)
"#).eval()?;
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),
}Sourcepub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R> ⓘwhere
A: ToLuaMulti<'lua>,
R: FromLuaMulti<'lua>,
Available on crate feature async only.
pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R> ⓘwhere
A: ToLuaMulti<'lua>,
R: FromLuaMulti<'lua>,
async only.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 calls 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).
Requires feature = "async"
§Examples
use futures::stream::TryStreamExt;
let thread: Thread = lua.load(r#"
coroutine.create(function (sum)
for i = 1,10 do
sum = sum + i
coroutine.yield(sum)
end
return sum
end)
"#).eval()?;
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);