Introduction

In Rust, an async closure parameter is really two types: the closure itself and the future it returns. You do not need a where clause to express that relationship, but you do need to write the trait bounds directly in the generic parameter list or erase the future type with boxing.

Why async closure parameters feel awkward

A normal closure parameter can often be written as impl Fn(...) -> .... Async work adds another layer because the closure does not return the final value directly. It returns a type that implements Future, and that future has its own output type.

That is why a function such as "run this callback and await the result" needs to describe both pieces. A where clause is one way to write that, but inline bounds work just as well for short signatures.

Writing the bounds inline

If you want to stay generic and avoid heap allocation, put the bounds in the angle-bracket list. Declare the future type first, then the closure type that returns it.

1use std::future::Future;
2
3async fn run_async<Fut: Future<Output = i32>, F: FnOnce(i32) -> Fut>(
4    value: i32,
5    callback: F,
6) -> i32 {
7    callback(value).await
8}
9
10#[tokio::main]
11async fn main() {
12    let result = run_async(21, |n| async move { n * 2 }).await;
13    println!("{result}");
14}

This version is compact and keeps static dispatch. The compiler sees the concrete closure type and the concrete future type, so there is no boxing overhead. It is a good choice when the function is generic anyway and the signature is still readable.

Using impl FnOnce with a boxed future

Sometimes the generic form gets noisy, especially when the callback is stored, returned, or passed through multiple layers. In that case, a boxed future can simplify the signature.

1use std::future::Future;
2use std::pin::Pin;
3
4type BoxFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
5
6async fn run_boxed(
7    value: String,
8    callback: impl FnOnce(String) -> BoxFuture<usize>,
9) -> usize {
10    callback(value).await
11}
12
13#[tokio::main]
14async fn main() {
15    let len = run_boxed("rust".to_owned(), |text| {
16        Box::pin(async move { text.len() })
17    })
18    .await;
19
20    println!("{len}");
21}

This style avoids a where clause too, and the parameter list can be easier to read. The tradeoff is that boxing introduces dynamic dispatch and heap allocation for the returned future.

Choosing the right closure trait

Use FnOnce unless you specifically need repeated calls. Many async closures move captured values into the future, which naturally makes them one-shot callbacks. If the closure must be reusable, switch to FnMut or Fn, but only when the capture pattern actually supports it.

It is also common to hit borrow-checker issues when the future holds references to local data. In practice, moving owned values into the async block often simplifies the design. If the callback needs borrowed data with precise lifetimes, a where clause may still be clearer even though it is not strictly required.

Common Pitfalls

• Trying to type the parameter as just impl FnOnce(...) -> ... and forgetting that the return value is a future, not the final output.
• Using Fn when the async block moves captured values. In that case FnOnce is usually the correct trait.
• Boxing too early. A boxed future is convenient, but the generic form is cheaper when the API can stay monomorphic at the call site.
• Declaring the closure type before the future type in inline bounds and making the signature harder to express.
• Forgetting that some examples need an async runtime such as Tokio to run the main function.

Summary

• An async closure parameter means "closure plus future type," not just one trait bound.
• You can avoid a where clause by writing inline generic bounds such as Fut: Future<Output = T> and F: FnOnce(...) -> Fut.
• Inline generic bounds keep static dispatch and avoid boxing overhead.
• A boxed future can make the signature shorter when ergonomic simplicity matters more than zero-cost abstraction.
• Pick FnOnce, FnMut, or Fn based on how the closure captures and reuses its environment.