Rust报错E0308：expected与found类型相同却提示不匹配如何解决

• 所有“打印出来完全一致的两个类型报不匹配”的Rust错误，本质都是隐式生命周期参数不满足约束：当错误场景涉及高阶生命周期（HRTB）、impl Trait返回值时，Rust不会把类型内部携带的隐式生命周期参数打印到错误提示里，才会出现“自己和自己不匹配”的迷惑提示。
• 具体到当前代码，有两层核心问题：
  1. 函数签名的生命周期约束缺失：f: impl Fn(&U) -> W的写法没有给输入引用&U和返回的FutureW绑定生命周期关系。Rust会默认推导为高阶生命周期约束for<'a> Fn(&'a U) -> W，但实际传入的异步函数f返回的Future是捕获输入引用生命周期'a的，当前签名把W声明为和'a无关的泛型，等于要求W对任意生命周期'a都合法，和实际行为矛盾。
  2. 代码逻辑的生命周期不合法：你在stream!宏内用tokio::spawn执行f(&items[i])，而tokio::spawn要求传入的Future必须满足'static生命周期（避免任务执行过程中引用的内存被释放产生悬垂指针），但&items[i]是对stream!内items变量的临时引用，生命周期完全不满足'static要求。

根据你是否需要tokio::spawn的多线程并发能力，二选一即可：

方案1：移除spawn，直接调度Future（无额外开销） #

如果不需要多线程任务调度的能力，直接去掉tokio::spawn，同时修正函数签名的生命周期约束，明确返回Future和输入引用的绑定关系即可：

use futures::stream::{FuturesUnordered, StreamExt};
use async_stream::stream;

pub fn map<U, V, W>(f: impl for<'a> Fn(&'a U) -> W, items: Vec<U>) -> impl futures::Stream<Item = V>
where
    V: Send,
    W: futures::Future<Output = V> + Send + 'a,
{
    stream! {
        let mut futures = FuturesUnordered::new();
        let mut i = 2;
        if 2 <= items.len() {
            futures.push(f(&items[0]));
            futures.push(f(&items[1]));
            while let Some(result) = futures.next().await {
                yield result;
                futures.push(f(&items[i]));
                i += 1
            }
        }
    }
}

#[tokio::main]
async fn main() {
    async fn f(x: &u32) -> u32 {
        x + 1
    }
    let input = vec![1, 2, 3];
    let output = map(f, input);
    futures::pin_mut!(output);
    while let Some(x) = output.next().await {
        println!("{:?}", x);
    }
}

这个版本的Future都在当前Stream的执行线程内调度，没有跨线程同步开销，也不需要满足'static约束，性能更好。

方案2：保留spawn，调整所有权规避生命周期问题 #

如果确实需要用tokio::spawn做多线程并发，就不能给异步函数传递短期借用，需要通过Arc做共享所有权保证引用的内存不会提前释放，同时调整函数签名匹配'static约束：

use futures::stream::{FuturesUnordered, StreamExt};
use async_stream::stream;
use std::sync::Arc;

pub fn map<U, V, W>(f: impl Fn(U) -> W, items: Vec<U>) -> impl futures::Stream<Item = V>
where
    U: Clone + Send + Sync + 'static,
    V: Send + 'static,
    W: futures::Future<Output = V> + Send + 'static,
{
    stream! {
        let mut futures = FuturesUnordered::new();
        let mut i = 2;
        if 2 <= items.len() {
            let items = Arc::new(items);
            let items_clone = Arc::clone(&items);
            futures.push(tokio::spawn(f(items_clone[0].clone())));
            let items_clone = Arc::clone(&items);
            futures.push(tokio::spawn(f(items_clone[1].clone())));
            while let Some(result) = futures.next().await {
                let y = result.unwrap();
                yield y;
                let items_clone = Arc::clone(&items);
                futures.push(tokio::spawn(f(items_clone[i].clone())));
                i += 1
            }
        }
    }
}

#[tokio::main]
async fn main() {
    async fn f(x: u32) -> u32 {
        x + 1
    }
    let input = vec![1, 2, 3];
    let output = map(f, input);
    futures::pin_mut!(output);
    while let Some(x) = output.next().await {
        println!("{:?}", x);
    }
}

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