Thread into_async should be generic on args

[cheesycod]

Right now, Thread::into_async is not really usable because it returns a AsyncThread<impl IntoLuaMulti, R> where the impl IntoLuaMulti is the same as A:

    pub fn into_async<R>(self, args: impl IntoLuaMulti) -> AsyncThread<impl IntoLuaMulti, R>
    where
        R: FromLuaMulti,
    {
        AsyncThread {
            thread: self,
            init_args: Some(args),
            ret: PhantomData,
            recycle: false,
        }
    }

Instead, this should probably use a second type parameter of A in into_async to allow for rust to correctly infer the type using the passed value for args like so:

    pub fn into_async<A, R>(self, args: A) -> AsyncThread<A, R>
    where
        A: IntoLuaMulti
        R: FromLuaMulti,
    {
        AsyncThread {
            thread: self,
            init_args: Some(args),
            ret: PhantomData,
            recycle: false,
        }
    }

[khvzak]

Right now, Thread::into_async is not really usable

Could you provide more details/example please?

[khvzak]

I probably better remove A completely and instead push args to the thread.
This may also solve #500

[cheesycod]

Right now, Thread::into_async is not really usable

Could you provide more details/example please?

The issue right now is that the returned AsyncThread is a AsyncThread<impl IntoLuaMulti, R> which cannot be (easily) put in a struct. So the below is not possible:

pub struct A { a: AsyncThread<LuaMultiValue, LuaMultiValue> }

A {a: thread.into_async::<LuaMultiValue>(args) } // Assume args is a LuaMultiValue for sake of brevity

Due to the lack of genericizing on args, rust does not realise that the A of AsyncThread is actually a LuaMultiValue (from args) leading to a value that cannot be (easily) put into a struct and can basically only exist as a variable.

I probably better remove A completely and instead push args to the thread.

This may also solve #500

This is probably the better long-term option yeah.

[khvzak]

Unfortunately both options are a breaking change.

I committed to the dev branch the new approach with pushing args to the thread during into_async and removed A generic.

[cheesycod]

Unfortunately both options are a breaking change.

I committed to the dev branch the new approach with pushing args to the thread during into_async and removed A generic.

This fixes the issue (still need to figure out the task lib stuff but the mlua AsyncThread works fine in structs now + can be reused at least for a perf improvement)

[cheesycod]

@khvzak In addition to this, can a yield method (lua_yield in C API) be added to mlua. Right now, this forces me to use a small luau wrapper script to just do coroutine.yield()

[cheesycod]

@khvzak Also, can lua_resumeerror be added to mlua somehow? This is a Luau specific C API for resuming a thread with the error being the top value on stack

[khvzak]

can a yield method (lua_yield in C API) be added to mlua.

It will not work since you cannot yield across C/Rust-call boundary.

[cheesycod]

can a yield method (lua_yield in C API) be added to mlua.

It will not work since you cannot yield across C/Rust-call boundary.

Btw, do you mind reviewing #513

[cheesycod]

@khvzak Seems like the commit for AsyncThread got inadvertently reverted in the dev main merge btw

[khvzak]

@cheesycod which commit? The ea5eccc (Change AsyncThread<A, R> to AsyncThread<R>) is in main branch