Rust中FuturesUnordered添加Future时遇不透明类型匹配错误求解

原始代码 #

use core::fmt::Debug;
use tokio::io::AsyncRead;
use tokio::io::AsyncWrite;
use core::cell::RefCell;
use futures::StreamExt;
use futures::stream::FuturesUnordered;

struct State {
    foo: String
}

pub async fn test<A: AsyncWrite + AsyncRead + Unpin + Debug>(
    peers: &mut FuturesUnordered<impl futures::Future<Output = Result<(State, A), std::io::Error>>>,
) {
    let mut pp: Vec<Rc<RefCell<(State, A)>>> = Vec::new();
    for p in pp {
        peers.push(async move {
            let p: (State, A) = p.into_inner();
            std::io::Result::Ok(p)
        });
    }
}

编译错误信息 #

error[E0308]: mismatched types
   --> src/lib.rs:17:20
    |
13  |       peers: &mut FuturesUnordered<impl futures::Future<Output = Result<(State, A), std::io::Error>>>,
    |                                    ----------------------------------------------------------------- this type parameter
...
17  |           peers.push(async move {
    |  _______________----_^
    | |               |
    | |               arguments to this function are incorrect
18  | |             let p: (State, A) = p.into_inner();
19  | |             std::io::Result::Ok(p)
20  | |         });
    | |_________^ expected type parameter `impl futures::Future<Output = Result<(State, A), std::io::Error>>`, found opaque type
    |
    = note: expected type parameter `impl futures::Future<Output = Result<(State, A), std::io::Error>>` (type parameter `impl futures::Future<Output = Result<(State, A), std::io::Error>>`)
                  found opaque type `impl futures::Future<Output = Result<(State, A), std::io::Error>>` (opaque type at </rustc/897e37553bba8b42751c67658967889d11ecd120/library/core/src/future/mod.rs:72:43>)
    = help: type parameters must be constrained to match other types
    = note: for more information, visit https://doc.rust-lang.org/bo

错误原因 #

你在函数参数中使用的impl futures::Future<...>是泛型类型参数占位符，它的含义是：调用test函数时，由调用方指定一个具体的Future类型，FuturesUnordered只能容纳这个特定类型的Future。

而函数内部async move块会生成一个全新的匿名opaque类型——尽管它的输出类型和参数要求一致，但Rust类型系统会将其视为完全独立的类型，因此两者无法匹配，导致编译错误。

修复方案 #

将FuturesUnordered的类型改为泛型参数，让它能接受任何符合输出要求的Future类型，同时补充缺失的依赖导入并修正逻辑错误：

use core::fmt::Debug;
use tokio::io::AsyncRead;
use tokio::io::AsyncWrite;
use core::cell::RefCell;
use std::rc::Rc; // 补充Rc的导入
use futures::StreamExt;
use futures::stream::FuturesUnordered;
use futures::Future; // 导入Future trait

struct State {
    foo: String
}

pub async fn test<A, F>(
    peers: &mut FuturesUnordered<F>,
) where
    A: AsyncWrite + AsyncRead + Unpin + Debug,
    F: Future<Output = Result<(State, A), std::io::Error>>,
{
    let mut pp: Vec<Rc<RefCell<(State, A)>>> = Vec::new();
    for p in pp {
        peers.push(async move {
            // 修正逻辑：先解开Rc（确保无其他引用），再取出RefCell内部值
            let cell = Rc::try_unwrap(p)
                .map_err(|_| std::io::Error::new(std::io::ErrorKind::Other, "Rc存在其他引用"))?;
            Ok(cell.into_inner())
        });
    }
}

关键修改点 #

1. 泛型参数重构：将FuturesUnordered<impl ...>改为泛型参数FuturesUnordered<F>，并在where子句中约束F为符合要求的Future类型。这样FuturesUnordered可以接受任何满足约束的Future，包括内部创建的async块。
2. 补充缺失导入：添加std::rc::Rc和futures::Future的导入，解决原代码中未导入依赖的问题。
3. 逻辑错误修正：Rc<RefCell<...>>无法直接调用into_inner，需要先通过Rc::try_unwrap消费Rc（确保没有其他引用），再取出RefCell的内部值。

内容的提问来源于stack exchange，提问作者Kevin