How to call an async function in a callback style?

[sxyazi]

I want to implement an await function that takes an asynchronous function and, after the async function completes, invokes a callback function with its result:

let globals = lua.globals();

globals.set("some_work", lua.create_async_function(|_, ()| async move {
  tokio::time::sleep(std::time::Duration::from_secs(1)).await;
  Ok("Slept for 1 second".to_owned())
})?)?;

globals.set("await", lua.create_function(|_, (f, cb): (Function, Function)| {
  // ...
})?)?;

In Lua:

await(some_work, function (ret)
  print(ret)  -- Prints "Slept for 1 second"
end)

The mlua::Lua instance has a 'static lifetime, so the callback function is always valid.

Is there a way to achieve this without enabling the send feature?

[khvzak]

Is there a way to achieve this without enabling the send feature?

I'm not sure I understand the problem. Why you need send feature?

[sxyazi]

The first f in await function takes an async function, so .call_async() is needed, but call_async returns a Future, and it seems I can only wrap it in a tokio::spawn, but tokio::spawn requires Send + 'static:

lua.create_function(|lua, (f, cb): (Function, Function)| {
  tokio::spawn(async move {
    let ret: Value = f.call_async(()).await.unwrap();
    cb.call(ret);
  });
  Ok(())
})

[khvzak]

You need to use spawn_local with LocalSet or LocalRuntime.

[sxyazi]

My await function is a sync function, how can I local.await within it:

lua.create_function(|_, (f, cb): (Function, Function)| {
  let local = tokio::task::LocalSet::new();

  local.spawn_local(async move {
    let ret: Value = f.call_async(()).await.unwrap();
    cb.call::<()>(ret).unwrap();
  });

  local.await;  // Error: `await` is only allowed inside `async` functions and blocks

  Ok(())
})

Or am I misunderstanding something?

[khvzak]

You don't need to create LocalSet inside function, you can create it once, enter and use everywhere through task::spawn_local.

#[tokio::main]
async fn main() -> Result<()> {
    let local_set = tokio::task::LocalSet::new();
    let _guard = local_set.enter();
    let lua = Lua::new();

    let globals = lua.globals();

    globals.set(
        "some_work",
        lua.create_async_function(|_, ()| async move {
            tokio::time::sleep(std::time::Duration::from_secs(1)).await;
            Ok("Slept for 1 second".to_owned())
        })?,
    )?;

    globals.set(
        "await",
        lua.create_function(|_, (f, cb): (Function, Function)| {
            tokio::task::spawn_local(async move {
                let ret = f.call_async::<Value>(()).await?;
                cb.call::<()>(ret)
            });
            Ok(())
        })?,
    )?;

    lua.load(
        r#"
    await(some_work, function (ret)
        print(ret)  -- Prints "Slept for 1 second"
    end)
    "#,
    )
    .exec_async()
    .await?;

    local_set.await;

    Ok(())
}

[sxyazi]

It works! TIL I can use a LocalSet globally

Thank you, you are the goat ;)