Sketch out rfold

src/stream/double_ended/mod.rs

@@ -1,8 +1,10 @@
 mod nth_back;
 mod rfind;
+mod rfold;
 
 use nth_back::NthBackFuture;
 use rfind::RFindFuture;
+use rfold::RFoldFuture;
 
 extension_trait! {
     use crate::stream::Stream;
@@ -67,5 +69,16 @@ extension_trait! {
             RFindFuture::new(self, p)
         }
 
+        fn rfold<B, F>(
+            self,
+            accum: B,
+            f: F,
+        ) -> impl Future<Output = Option<B>> [RFoldFuture<Self, F, B>]
+            where
+                Self: Sized,
+                F: FnMut(B, Self::Item) -> B,
+        {
+            RFoldFuture::new(self, accum, f)
+        }
     }
 }

src/stream/double_ended/rfold.rs

@@ -0,0 +1,50 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use pin_project_lite::pin_project;
+
+use crate::stream::DoubleEndedStream;
+
+pin_project! {
+    pub struct RFoldFuture<S, F, B> {
+        #[pin]
+        stream: S,
+        f: F,
+        acc: Option<B>,
+    }
+}
+
+impl<S, F, B> RFoldFuture<S, F, B> {
+    pub(super) fn new(stream: S, init: B, f: F) -> Self {
+        RFoldFuture {
+            stream,
+            f,
+            acc: Some(init),
+        }
+    }
+}
+
+impl<S, F, B> Future for RFoldFuture<S, F, B>
+where
+    S: DoubleEndedStream + Sized,
+    F: FnMut(B, S::Item) -> B,
+{
+    type Output = B;
+
+    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let mut this = self.project();
+        loop {
+            let next = futures_core::ready!(this.stream.as_mut().poll_next_back(cx));
+
+            match next {
+                Some(v) => {
+                    let old = this.acc.take().unwrap();
+                    let new = (this.f)(old, v);
+                    *this.acc = Some(new);
+                }
+                None => return Poll::Ready(this.acc.take().unwrap()),
+            }
+        }
+    }
+}