Rust 如果我有嵌套的async/await调用，我应该考虑累积的开销吗？

我正在通过多个通道处理数据，每个通道将数据送入下一个通道（管道处理）。最后，我在顶部看到一个

spawn

，如下所示：

Forwarder {
    pub fn validate_sequence(&mut self, msg: TestMessage) -> Result<TestMessage, TestMessage>
    pub async fn handle_action(&mut self, cmd: TestMessage);
    pub async fn handle_notification(&mut self);
    pub async fn receive(&mut self, cmd: TestMessage) {
        match self.handle_config(cmd) {
            Ok(_) => (),
            Err(msg) => match self.validate_sequence(msg) {
                Ok(msg) => {
                    self.handle_action(msg).await;
                    self.handle_notification().await;
                },
                Err(msg) => panic!("{} sequence error: expecting {} not cmd {:#?}", self.header(), self.next_seq, msg),
            },
        }
    }
}

让未来=异步移动{
而让Ok（msg）=r.recv（）等待{
货代。接收（味精）。等待；
}
};
执行器池：：执行器池：：繁殖（未来）.detach（）；

转发器

如下所示：

Forwarder {
    pub fn validate_sequence(&mut self, msg: TestMessage) -> Result<TestMessage, TestMessage>
    pub async fn handle_action(&mut self, cmd: TestMessage);
    pub async fn handle_notification(&mut self);
    pub async fn receive(&mut self, cmd: TestMessage) {
        match self.handle_config(cmd) {
            Ok(_) => (),
            Err(msg) => match self.validate_sequence(msg) {
                Ok(msg) => {
                    self.handle_action(msg).await;
                    self.handle_notification().await;
                },
                Err(msg) => panic!("{} sequence error: expecting {} not cmd {:#?}", self.header(), self.next_seq, msg),
            },
        }
    }
}

---

我们希望使用

迭代器，而不是
for
循环。然而，这将需要一个异步闭包——这是我甚至还没有弄清楚如何表达的东西。
仅仅嵌套
异步
函数不会带来任何开销

async
/
await
语法编译成一个
Future
，它基本上是一个状态机，可以以一种方式执行代码，在需要等待时可以挂起代码，稍后再恢复。一个
异步
函数和所有（静态已知的）
等待
'd期货一起编译成相同的
期货
；函数边界有点消失了。因此，是的，编译器“足够聪明，可以将这些”折叠在一起。
“看起来有点难看”-您能澄清什么阻碍了重构吗？在调用其他
async
函数时，您是否只是在谈论每个函数需要是
async
函数？是的。必须通过调用路径添加异步可能会导致异步方法和非异步方法几乎相同。我一直在想，是否应该有一种方法可以基于调用的返回参数规避async/Wait。