What to use as a minimal meaningless return type for a hook?

[fleetingbytes]

With my World I am creating some temporary files and directories (tempfile crate) and in some cases these files are kept and persisted. I don't want to wait for my OS's temporary file cleaner to delete them. I would like to clean these up manually with the after hook.

I wrote some code which works and does what I want, but I don't know exactly what to return, so I put something like a mirosleep there because I saw it in the documentation. But if possible, I would like to construct a minimal meaningless Pin-Box-Future-Output and return that, kind of like we return Ok(()) for Result<(), T> return types. (I'm still very much a newbie to tokio, Futures, and never had anything to do with Pins)

#[tokio::main]
async fn main() {
    World::cucumber()
        .after(|_feature, _rule, _scenario, _event, world| {
            /* my code cleaning the persistent temp files omitted here */
  
            // fn after() must return a Pin<Box<dyn futures::Future<Output = ()>>>
            // and I don't know how to construct such a thing.
            // Instead I use a very short sleep, in a way I found in cucumber documentation
            time::sleep(Duration::from_micros(1)).boxed_local()
        })
        .run("tests/features/file_checks.feature")
        .await;
}

[ilslv]

Cucumber::after hook receives a closure that has return type of Pin<Box<dyn Future + 'a>>, which basically means any Future allocated on the heap. This is done to support returned Futures of any stack size. From what I can see in your example, all code in the hook is synchronous (doesn't have .awaits) and you are trying to bridge synchronous and asynchronous code. I suggest doing it in 1 of 2 ways:

1. Wrap your synchronous code into an async { ... } block and add .boxed_local() at the end:

#[tokio::main]
async fn main() {
    World::cucumber()
        .after(|_feature, _rule, _scenario, _event, world| async {
            //                                             ^^^^^
            /* my code cleaning the persistent temp files omitted here */
        }.boxed_local())
        // ^^^^^^^^^^
        .run("tests/features/file_checks.feature")
        .await;
}

2. Leave it as synchronous block and add future::ready(()).boxed_local():

#[tokio::main]
async fn main() {
    World::cucumber()
        .after(|_feature, _rule, _scenario, _event, world| {
            /* my code cleaning the persistent temp files omitted here */
  
            // fn after() must return a Pin<Box<dyn futures::Future<Output = ()>>>
            // and I don't know how to construct such a thing.
            future::ready(()).boxed_local()
        })
        .run("tests/features/file_checks.feature")
        .await;
}

[fleetingbytes]

Thank you, that's exactly it. I have asynchronous code there. This helped.