[StackOverflow/rust] Why is there a difference regarding lifetime elision of impl trait function arguments between async and non-async functions?

### ROOT CAUSE The issue arises due to the interaction between the following Rust features: 1. **Async function syntax**: Async functions have a special signature with an implicit `async` block and a hidden continuation task handle. 2. **Impl Trait in parameters**: When using `impl Trait` in function parameters, Rust relies on trait object bounds which include dynamic dispatch overhead. 3. **Lifetime elision**: Rust's lifetime elision rules do not account for the hidden parameter added by async functions, leading to unsatisfied lifetime bounds in certain cases. The core problem is that the compiler's lifetime elision rules do not consider the implicit parameter (`_at`) added by async functions when inferring lifetimes for `impl Trait` parameters. This breaks when the function signature requires explicit lifetimes due to trait bounds. --- ### CODE FIX To resolve the issue, explicitly specify the required lifetimes for the `impl Trait` parameter. This ensures the compiler correctly accounts for the async function's implicit parameter and avoids unsatisfied trait bounds. **Example Fix:** ```rust async fn example<'a>(arg: impl FnOnce(&'a str)) {} // ❌ Fails without explicit lifetime // ✅ Solution: Specify lifetime in impl Trait async fn example<'a>(arg: impl FnOnce(&'a str)) {} // Now compiles ``` **Explanation:** - The async function `example` requires an argument that is a closure taking a `&str` with a specific lifetime `'a`. - By explicitly declaring the lifetime `'a`, we ensure the compiler includes it in the function signature, accommodating the async function's hidden parameter and avoiding inference failures. **Note:** This fix works because the explicit lifetime `'a` satisfies the trait bounds required by the async function's implementation details.