generics - 有什么方法可以让 Rust 理解 `fn(T) -> impl Future` 总是返回相同的类型？

Question

我有一个函数，它接受一个通用参数，从中获取它需要的东西，然后返回一个 future 。 Future 实际上并不存储通用数据，它是完全单态的。

为方便起见，我想使用 async fn 来创建 future ，据我所知，这需要返回 impl Future 作为 async fn return不透明类型:https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=c3b061d12a126dc30099ac3bd018c273

use std::io::{Read, stdin};
use std::fs::File;
use std::future::Future;
use std::path::Path;

fn caller(p: Option<&Path>) -> impl Future<Output=()> {
    if let Some(p) = p {
        f(File::open(p).unwrap())
    } else {
        f(stdin())
    }
}

fn f<R: Read>(_: R) -> impl Future<Output=()> {
    fut()
}

async fn fut() {}

但是 rustc 在条件语句中出现异常，因为调用方绝对相信两个分支之间的 future 一定是不同的:

error[E0308]: `if` and `else` have incompatible types
  --> src/lib.rs:10:9
   |
7  | /     if let Some(p) = p {
8  | |         f(File::open(p).unwrap())
   | |         ------------------------- expected because of this
9  | |     } else {
10 | |         f(stdin())
   | |         ^^^^^^^^^^ expected struct `File`, found struct `Stdin`
11 | |     }
   | |_____- `if` and `else` have incompatible types
...
14 |   fn f<R: Read>(_: R) -> impl Future<Output=()> {
   |                          ---------------------- the found opaque type
   |
   = note:     expected type `impl Future<Output = ()>` (struct `File`)
           found opaque type `impl Future<Output = ()>` (struct `Stdin`)

除了装箱 future 或手动滚动 fut 以最终得到一个具体类型之外，是否有解决此问题的方法？

Answer 1

我不认为你可以避免拳击，但至少你可以避免拳击 future 本身:

use std::io::{Read, stdin};
use std::fs::File;
use std::future::Future;
use std::path::Path;

fn caller(p: Option<&Path>) -> impl Future<Output=()> {
    let read = if let Some(p) = p {
        Box::new(File::open(p).unwrap()) as Box<dyn Read>
    } else {
        Box::new(stdin())
    };
    f(read)
}

fn f<R: Read>(_: R) -> impl Future<Output=()> {
    fut()
}

async fn fut() {}

据我了解，问题不在于 future ，而在于实际上为参数构建不同的类型，并以某种方式涌入返回类型。不过，这是有道理的。

Playground