Konstruieren eines asynchronen Stream-Iterators über direkte Poll-Methoden

use std::pin::Pin;
use std::task::{Context, Poll};
 
pub trait AsyncProducer {
    type Item;
    type Error;
 
    fn poll_next(
        self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<Result<Self::Item, Self::Error>>>;
}
 
pub struct FallbackProducer<P> {
    primary: P,
    fallback_active: bool,
}
 
impl<P> FallbackProducer<P> {
    pub fn new(primary: P) -> Self {
        Self {
            primary,
            fallback_active: false,
        }
    }
}
 
impl<P> AsyncProducer for FallbackProducer<P>
where
    P: AsyncProducer<Item = String> + Unpin,
{
    type Item = String;
    type Error = P::Error;
 
    fn poll_next(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
    ) -> Poll<Option<Result<Self::Item, Self::Error>>>
    {
        if self.fallback_active {
            return Poll::Ready(None);
        }
        match Pin::new(&mut self.primary).poll_next(cx) {
            Poll::Ready(Some(Err(_))) => {
                self.fallback_active = true;
                Poll::Ready(Some(Ok(String::from("Recovered"))))
            }
            other => other,
        }
    }
}