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

Any way to make Rust understand an `fn(T) -> impl Future` always returns the same type?

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

为方便起见,我想使用 async fn 来创造未来,据我所知,这需要 returning 一个 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 在条件语句中出现异常,因为调用方绝对相信两个分支之间的未来一定会有所不同:

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 以最终得到单一具体类型之外,还有其他方法可以解决此问题吗?

我不认为你可以避免拳击,但至少你可以避免拳击未来本身:

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() {}

据我了解,问题不在于未来,而是实际上为参数构建不同的类型,并以某种方式涌入 return 类型。虽然它不会是有道理的。

Playground