如何使用组合器（每个组合器除外）在Rust中运行流直到完成，而不使用while循环？

我有一个使用组合器的流，我需要运行它直到完成。我可以使用

while

循环或

for_每个

组合器。它们都会起作用，但我认为一定有更好的办法

看起来像我要找的东西，特别是，但我不知道如何使用它

使用while循环

使用未来：{StreamExt，trysteamext}；//0.3.6
使用tokio；//0.3.0
#[tokio:：main]
异步fn main（）{
让mut stream=Box:：pin(
未来：：流：：iter（0..20）
.map（foo）
.map|u ok（| x | x*10）
.和_然后（bar）
.filter（|x | futures:：future:：ready（x.is_ok（）），
);
而让一些（）=stream.next（）等待{
//这里没什么可做的，我只需要跑小溪。
}
}
fn foo（x:i32）->结果{
如果x！=10{
Ok（x）
}否则{
Err（“eer.to_string（））
}
}
异步fn条（x:i32）->结果{
异步的{
如果x==13{
Err（“errr.”to_string（）
}否则{
好（（））
}
}
.等待
}

对每个_使用

：

使用未来：{StreamExt，trysteamext}；//0.3.6
使用tokio；//0.3.0
#[tokio:：main]
异步fn main（）{
未来：：流：：iter（0..20）
.map（foo）
.map|u ok（| x | x*10）
.和_然后（bar）
.filter（|x | futures:：future:：ready（x.is_ok（）））
.for|each（| | futures:：future:：ready（（））//这里没什么可做的，只是运行流
.等待；
}
fn foo（x:i32）->结果{
如果x！=10{
Ok（x）
}否则{
Err（“eer.to_string（））
}
}
异步fn条（x:i32）->结果{
异步的{
如果x==13{
Err（“errr.”to_string（）
}否则{
好（（））
}
}
.等待
}

我想要如下的东西。无需精确地使用
排放
组合器，只需使用一些组合器来运行流：

使用未来：{StreamExt，trysteamext}；//0.3.6
使用tokio；//0.3.0
#[tokio:：main]
异步fn main（）{
未来：：流：：iter（0..20）
.map（foo）
.map|u ok（| x | x*10）
.和_然后（bar）
.filter（|x | futures:：future:：ready（x.is_ok（）））
.forward（未来：：接收器：：排水管（））
.等待；
}
fn foo（x:i32）->结果{
如果x！=10{
Ok（x）
}否则{
Err（“eer.to_string（））
}
}
异步fn条（x:i32）->结果{
异步的{
如果x==13{
Err（“errr.”to_string（）
}否则{
好（（））
}
}
.等待
}

这不起作用，可能是因为drain对
错误类型设置了一些界限：

error[E0271]：类型不匹配解析`::error==std:：string:：string`
-->src/main.rs:11:10
|
11 |.前进（未来：：下沉：：排水（）
|^^^^^应为枚举'std:：convert:：Infallible'，找到结构'std:：string:：string'`
错误[E0271]：类型不匹配正在解决`，futures:：future:：Ready[closure@src/main.rs:10:17:10:54]>as futures:：Stream>：：Item==std:：result:：result`
-->src/main.rs:6:5
|
6 |/futures:：stream:：iter（0..20）
7 | |地图（foo）
8 | |地图|正常（| x | x*10）
9 | |和|然后（巴）
10.filter（| x | futures:：future:：ready（x.is|u ok（））
11 | |.前进（未来：：下沉：：排水（）
12 | |等待；
||uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu^预期结构'std:：string:：string'，找到枚举'std:：convert:：Infallible'`
|
=注意：预期枚举`std:：result:：result`
找到枚举'std:：result:：result'`
=注意：由于“futures\u util:：stream:：stream:：forward:：forward，futures:：Future:：Ready”的“futures:：Future”impl上的要求，因此需要[closure@src/main.rs:10:17:10:54]>，futures:：sink:：Drain，（）>`
Sink
特征容易出错（没有
TrySink
），但
drain（）
返回一个
drain
，其
错误
是
无误的

而
Stream:：forward（）
要求流是易出错的（实际上
TryStream
），并且具有与给定接收器相同的错误类型。您的代码失败，因为您的错误类型是
String
，并且无法排出

由于您正在过滤
结果，因此解决方案是_ok
结果，因此需要打开并重新包装值：

#[tokio::main]
async fn main() {
    futures::stream::iter(0..20)
        .map(foo)
        .map_ok(|x| x * 10)
        .and_then(bar)
        .filter(|x| futures::future::ready(x.is_ok()))
        .map(|x| Ok(x.unwrap())) // <---- rewrap!
        .forward(futures::sink::drain())
        .await.unwrap();
}

#[tokio:：main]
异步fn main（）{
未来：：流：：iter（0..20）
.map（foo）
.map|u ok（| x | x*10）
.和_然后（bar）
.filter（|x | futures:：future:：ready（x.is_ok（）））
.map（| x | Ok（x.unwrap（））//不清楚您为什么不喜欢
。\u each
，但喜欢
forward
。有什么区别？区别在于它更详细，不能很好地显示我的意图。我的意图是运行流或者如果愿意的话将其耗尽。for each和while的意图是对元素做些什么。
。filter\u map（|x | async move{x.ok（）.map（ok）}）
@Shepmaster:啊，是的，这行将同时替换
过滤器和
映射调用，避免调用
展开（）。