I originally implemented support for the Windows IAsyncXxx interfaces in the windows-future crate to match how I had implemented it for C++/WinRT and while the async pattern must be implemented in exactly the same way to interop reliably, the language-specific helpers need not look exactly the same. The C++ version included a blocking get method to wait for the results. This was based on C++'s std::future but I realized that this is not very intuitive for Rust developers who might equate this more naturally with Rust's JoinHandle. I might create a thread and wait for its result using the Standard Library as follows:

let thread = std::thread::spawn(|| 123);

let result = thread.join().unwrap();
println!("{result}");

This update renames the existing get method to join so that it follows the same pattern:

let future = windows_future::IAsyncOperation::spawn(|| Ok(123));

let result = future.join().unwrap();
println!("{result}");

The join method works exactly the same and is implemented in the same way as before, although the implementation is now more streamlined to simplify maintenance.

This update also adds the when method. While the windows-future crate implements the Standard Library's IntoFuture and Future traits, this isn't for everyone and you might just want a simple way to execute a closure when the future completes but without blocking the calling thread as join does. Wiring this up is syntactically complicated for historical reasons:

let future = windows_future::IAsyncOperation::spawn(|| Ok(123));

future
    .SetCompleted(&windows_future::AsyncOperationCompletedHandler::new(
        |sender, _| {
            let result = sender.unwrap().GetResults().unwrap();
            println!("{result:?}");
            Ok(())
        },
    ))
    .unwrap();

That's what when is for. It greatly simplifies this scenario:

let future = windows_future::IAsyncOperation::spawn(|| Ok(123));

future.when(|result| println!("{result:?}")).unwrap();