same async recursion code using tokio::task::{spawn/spawn_local}, but one of them can't compile while the other pass compiler check.

[aj3n]

I worte following code for a test:

//error[E0391]: cycle detected when computing type of `tokio_recure::{opaque#0}`
async fn tokio_recure(cnt: i32) {
	if cnt > 0 {
		let j = tokio::task::spawn(async move { tokio_recure(cnt - 1).await });
		j.await.unwrap()
	}
}

// it's ok
async fn tokio_local_recure(cnt: i32) {
    if cnt > 0 {
        let j = tokio::task::spawn_local(async move { tokio_local_recure(cnt - 1).await });
        j.await.unwrap()
    }
}

I'm not sure if this acts as expected.
If it does, what exactly caused the difference.
If it doesn't, is there any workaround to fix it? Who should this be reported to? tokio team or rustc team?

[notgull]

Usually, recursive blowups like this can be solved by boxing the future. For the recursive task, try boxing and casting it to Box<dyn Future>.

[aj3n]

I think this is not the cause, or else tokio_local_recure won't compile either.
In my situation, JoinHandle<T> should act the same as Box<dyn Future>, its size is also irrelevant to T.
Thanks for replying though.

[Noah-Kennedy]

This is definitely a bit unexpected.

[Darksonn]

I don't know why it only happens for one of them, but the easiest way to solve this is to wrap the tokio::spawn call in a non-async function.

fn spawn_tokio_recure(cnt: i32) -> JoinHandle<()> {
    tokio::task::spawn(tokio_recure(cnr))
}

async fn tokio_recure(cnt: i32) {
	if cnt > 0 {
		let j = spawn_tokio_recure(cnt - 1);
		j.await.unwrap()
	}
}

[aj3n]

Thanks a lot, your answer fixed my problem!
But I'm still confused why it happened. I think I will report this to rustc team.
Thanks again!

[Noah-Kennedy]

I'm still interested in why this happened as well. I'm traveling right now, otherwise I'd dig into this.