rust 在两个向量中处理并发的未来？

des4xlb0 于 2023-08-05 发布在其他

关注(0)|答案(2)|浏览(81)

我正在尝试编写一个函数，该函数并发处理期货集合，并在它们变得可用后返回values和errors。
不幸的是，我不能征服这里的语法。这就是我在的地方：

async fn handle_futures<I, T, E>(futures: I) -> (Vec<T>, Vec<E>) where I: IntoIterator<Item = impl Future<Output = Result<T, E>>>, { // <- this line errors
    let mut futures = FuturesUnordered::from_iter(futures);

    let (mut successes, mut errors) = (vec![], vec![]);

    while let Some(result) = futures.next().await {
        match result {
            Ok(value) => successes.push(value),
            Err(error) => errors.push(error),
        }
    }

    (successes, errors)
}

字符串
我现在看到这个错误：
impl Trait只允许在函数和固有方法返回类型中使用，不允许在绑定中使用
有人能帮我找到一个有效的实现吗？

**编辑：**我认为这是一个技巧：

async fn handle_futures<I, T, E, P>(futures: I) -> (Vec<T>, Vec<E>)
where
    P: Future<Output = Result<T, E>>,
    I: IntoIterator<Item = P>,
{
    let mut futures = FuturesUnordered::from_iter(futures);

    let (mut successes, mut errors) = (vec![], vec![]);

    while let Some(result) = futures.next().await {
        match result {
            Ok(value) => successes.push(value),
            Err(error) => errors.push(error),
        }
    }

    (successes, errors)
}

型

rust

来源：https://stackoverflow.com/questions/76606575/handle-concurrent-futures-in-two-vectors

2条答案

按热度按时间

0tdrvxhp1#

不要使用匿名类型参数（也称为impl Trait in argument position）语法，因为不支持将它们嵌套在trait边界内。请为将来的类型使用普通的旧泛型类型参数：

use futures::prelude::*;
use futures::stream::FuturesUnordered;

async fn handle_futures<I, T, E, U>(futures: I) -> (Vec<T>, Vec<E>)
where
    I: IntoIterator<Item = U>,
    U: Future<Output = Result<T, E>>,
{
    let mut futures = FuturesUnordered::from_iter(futures);

    let (mut successes, mut errors) = (vec![], vec![]);

    while let Some(result) = futures.next().await {
        match result {
            Ok(value) => successes.push(value),
            Err(error) => errors.push(error),
        }
    }

    (successes, errors)
}

字符串
Playground.

赞(0）回复(0）举报 2023-08-05

qxgroojn2#

您需要为将来引入另一个泛型参数：

async fn handle_futures<I, Fut, T, E>(futures: I) -> (Vec<T>, Vec<E>)
where
    I: IntoIterator<Item = Fut>,
    Fut: Future<Output = Result<T, E>>,
{
    // ...
}

字符串
或者，如果愿意，可以直接约束I::Item：

async fn handle_futures<I, T, E>(futures: I) -> (Vec<T>, Vec<E>)
where
    I: IntoIterator,
    I::Item: Future<Output = Result<T, E>>,
{
    // ...
}

型

赞(0）回复(0）举报 2023-08-05

我来回答

rust 在两个向量中处理并发的未来？

2条答案

相关问题

热门标签

最新问答