while let Some(msg) = receiver.receive().await {
    yield Ok(sse::Event::default().data(msg));
}

字符串
这意味着，只要receive()的返回值是Some(...)，就循环。如果是None，则退出循环。
所以如果你把它翻译成loop版本，它会是这样的：

loop {
    if let Some(msg) = receiver.receive().await {
        yield Ok(sse::Event::default().data(msg));
    } else {
        break;
    }
}

型
这里最大的问题是您试图与None进行什么通信。默认情况下，receive中的None s表示流结束。在这种情况下，使用while let非常有意义，因为希望在流结束后停止循环。
在你的例子中，你有这样的代码：

if message.team_id == self.team_id {
    println!("this is the issue, I'm returning None and it closes the stream! block");
    return None;
}

型
它返回一个None，以防消息不是你想要的。现在，它为外部创建了混合信号-在一种情况下，None用于传达流结束的信息，而在另一种情况下，它传达了消息应该被忽略的信息。
你得把这两个案子分开。我有两个办法：

• 引入另一个Option，如Option<Option<..>>，其中外部Option传达流的结尾，内部Option传达消息应该被忽略。
• 不要从receive函数返回，直到流结束或收到有效消息。

我个人倾向于第二种选择，我将进一步简化代码，使用.ok()?将Result转换为Option并传播None。

impl Listener {
    pub async fn receive(&mut self) -> Option<Arc<Message>> {
        loop {
            let message = self.receiver.recv().await.ok()?;
            if message.team_id != self.team_id {
                return Some(message);
            }
        }
    }
}

型
然后，使用while let版本，因为None现在再次表示您的连接已结束，在这种情况下，使用loop实际上是危险的，因为它将永远以100%的CPU功率旋转。
为了回答你对loop的担忧，loop本身并没有什么不好的，就像while一样。只有当它是一个忙碌循环时才是不好的，这意味着循环内部没有等待点。但是你的循环有一个.await，它经常挂起，所以没有CPU能量被浪费。（直到.await实际上不再等待，比如当receive()函数的连接关闭时）
补充说明：
如果你的情况有点复杂，你需要在多个地方中止当前包的处理，你可以使用loop和continue的组合来干净地实现这一点。像这样：

impl Listener {
    pub async fn receive(&mut self) -> Option<Arc<Message>> {
        loop {
            let message = self.receiver.recv().await.ok()?;

            if message.team_id == self.team_id {
                // Skip the current message
                continue;
            }

            // Return the message if we didn't hit any `continue`s
            return Some(message);
        }
    }
}

型