Should it be possible to create a future from "itself"? Conceptually:
async fn foo(job: Job) {
// ... blah ...
let fut = foo(newjob);
spawn(fut);
// ... blah ...
}
I did a quick test and the compiler errored out about circular something something, so I assumed it's not supported, but thinking back my code may have been broken in other ways so now I'm not sure.
Not directly, but if you add jndirection you can. The simplest way is to use future.boxed().await, which basically reduces to (Box::pin(future) as Box<dyn Future + Send>).await
An alternative if you want to avoid the Box id to use pin_utils::pin_mut
pin_mut!(future);
(future as &mut dyn Future + Send).await;
The type erasure is key because of how Rust desugaes async functions. If the async function's type appears in any of it's fields (whatever the async function captures), it makes an infinitely large type. Note this is not a type whose size is infinite, the name of the type is infinite, and Rust can't represent that.
There may be a desugarring that allows indirection without dynamic dispatch, but not without indirection. This is because all captures are stored inline, so if you tried this without indirection, you would get something like this: