add support for immovable coroutine (self referenced)

Author: viruscamp

src/gen_iter.rs

@@ -5,6 +5,26 @@ use core::pin::Pin;
 
 /// an iterator that holds an internal coroutine representing
 /// the iteration state
+/// 
+/// # Example
+/// pin a self-referenced coroutine in heap, then use it as `Iterator`
+/// ```
+/// #![feature(coroutines)]
+///
+/// use gen_iter::GenIter;
+/// use std::boxed::Box;
+///
+/// let arr = [1, 2];
+/// let c = Box::pin(#[coroutine] static move || {
+///     let arr = &arr;
+///     for i in 0..arr.len() {
+///        yield arr[i];
+///     }
+/// });
+/// let mut g = GenIter(c);
+///
+/// assert_eq!(g.collect::<Vec<i32>>(), [1, 2]);
+/// ```
 #[derive(Copy, Clone, Debug)]
 pub struct GenIter<T>(pub T)
 where
@@ -38,6 +58,7 @@ where
 
 /// macro to simplify iterator - via - coroutine construction
 ///
+/// - movable coroutine as `Iterator`
 /// ```
 /// #![feature(coroutines)]
 ///
@@ -48,10 +69,24 @@ where
 ///     yield 2;
 /// });
 ///
-/// assert_eq!(g.next(), Some(1));
-/// assert_eq!(g.next(), Some(2));
-/// assert_eq!(g.next(), None);
+/// assert_eq!(g.collect::<Vec<i32>>(), [1, 2]);
+/// ```
+/// 
+/// - immovable coroutine (self referenced) as `Iterator`
+/// ```
+/// #![feature(coroutines)]
+///
+/// use gen_iter::gen_iter;
+///
+/// let arr = [1, 2];
+/// let mut g = gen_iter!(static move {
+///     let arr = &arr;
+///     for i in 0..arr.len() {
+///        yield arr[i];
+///     }
+/// });
 ///
+/// assert_eq!(g.collect::<Vec<i32>>(), [1, 2]);
 /// ```
 #[macro_export]
 macro_rules! gen_iter {
@@ -60,7 +95,14 @@ macro_rules! gen_iter {
     };
     (move $block: block) => {
         $crate::GenIter(#[coroutine] move || $block)
-    }
+    };
+
+    (static $block: block) => {
+        $crate::GenIter { 0: ::core::pin::pin!(#[coroutine] static || $block) }
+    };
+    (static move $block: block) => {
+        $crate::GenIter { 0: ::core::pin::pin!(#[coroutine] static move || $block) }
+    };
 }
 
 
@@ -106,4 +148,50 @@ mod tests {
         assert_eq!(g.next(), Some(2));
         assert_eq!(g.next(), None);
     }
+
+    #[test]
+    fn self_ref_coroutine_in_stack() {
+        let c = ::core::pin::pin!(#[coroutine] static || {
+            let v1 = [1, 2];
+            let v = &v1;
+            for i in 0..v.len() {
+                yield v[i];
+            }
+        });
+        let mut g = GenIter(c);
+        
+        assert_eq!(g.next(), Some(1));
+        assert_eq!(g.next(), Some(2));
+        assert_eq!(g.next(), None);
+    }
+
+    #[test]
+    fn gen_iter_macro_static() {
+        let mut g = gen_iter!(static {
+            let v1 = [1, 2];
+            let v = &v1;
+            for i in 0..v.len() {
+                yield v[i];
+            }
+        });
+        
+        assert_eq!(g.next(), Some(1));
+        assert_eq!(g.next(), Some(2));
+        assert_eq!(g.next(), None);
+    }
+
+    #[test]
+    fn gen_iter_macro_static_move() {
+        let v1 = [1, 2];
+        let mut g = gen_iter!(static move {
+            let v = &v1;
+            for i in 0..v.len() {
+                yield v[i];
+            }
+        });
+        
+        assert_eq!(g.next(), Some(1));
+        assert_eq!(g.next(), Some(2));
+        assert_eq!(g.next(), None);
+    }
 }

src/gen_iter_return.rs

@@ -11,7 +11,10 @@ use core::pin::Pin;
 /// 2. safe to call `next()` after coroutine is done without panic
 /// 3. maybe less efficient than `GenIter<G>`
 #[derive(Copy, Clone, Debug)]
-pub struct GenIterReturn<G: Coroutine + Unpin>(Result<G::Return, G>);
+pub struct GenIterReturn<G: Coroutine + Unpin>(
+    #[doc(hidden)]
+    pub Result<G::Return, G>
+);
 
 impl<G: Coroutine + Unpin> GenIterReturn<G> {
     #[inline]
@@ -72,6 +75,7 @@ impl<G: Coroutine + Unpin> From<G> for GenIterReturn<G> {
 }
 
 /// macro to simplify iterator - via - coroutine with return value construction
+/// - movable coroutine as `Iterator`
 /// ```
 /// #![feature(coroutines)]
 ///
@@ -88,6 +92,26 @@ impl<G: Coroutine + Unpin> From<G> for GenIterReturn<G> {
 /// assert_eq!((&mut g).next(), None); // safe to call `next()` after done
 /// assert_eq!(g.return_or_self().ok(), Some("done")); // get return value of the coroutine
 /// ```
+/// 
+/// - immovable coroutine (self referenced) as `Iterator`
+/// ```
+/// #![feature(coroutines)]
+///
+/// use gen_iter::gen_iter_return;
+///
+/// let arr = [1, 2];
+/// let mut g = gen_iter_return!(static move {
+///     let v = &arr;
+///     for i in 0..v.len() {
+///        yield v[i];
+///     }
+///     return v.len();
+/// });
+///
+/// assert_eq!((&mut g).collect::<Vec<i32>>(), [1, 2]);
+/// assert_eq!(g.is_done(), true);
+/// assert_eq!(g.return_or_self().ok(), Some(2));
+/// ```
 #[macro_export]
 macro_rules! gen_iter_return {
     ($block: block) => {
@@ -96,6 +120,21 @@ macro_rules! gen_iter_return {
     (move $block: block) => {
         $crate::GenIterReturn::new(#[coroutine] move || $block)
     };
+
+    (static $block: block) => {
+        $crate::GenIterReturn {
+            0: ::core::result::Result::Err {
+                0: ::core::pin::pin!(#[coroutine] static || $block)
+            }
+        }
+    };
+    (static move $block: block) => {
+        $crate::GenIterReturn {
+            0: ::core::result::Result::Err {
+                0: ::core::pin::pin!(#[coroutine] static move || $block)
+            }
+        }
+    };
 }
 
 #[cfg(test)]
@@ -149,7 +188,7 @@ mod tests {
 
     /// normal usage using macro `gen_iter_return`
     #[test]
-    fn macro_usage() {
+    fn macro_gen_iter_return() {
         let mut g = gen_iter_return!(move {
             yield 1;
             yield 2;
@@ -166,4 +205,27 @@ mod tests {
         assert_eq!(g.is_done(), true);
         assert_eq!(g.return_or_self().ok(), Some("done"));
     }
+
+    /// use macro `gen_iter_return` to make a immovable coroutine
+    #[test]
+    fn macro_gen_iter_return_static_move() {
+        let arr = [1, 2];
+        let mut g = gen_iter_return!(static move {
+            let v = &arr;
+            for i in 0..v.len() {
+                yield v[i];
+            }
+            return v.len();
+        });
+
+        let (mut sum, mut count) = (0, 0);
+        for y in &mut g {
+            sum += y;
+            count += 1;
+        }
+        assert_eq!((sum, count), (3, 2));
+
+        assert_eq!(g.is_done(), true);
+        assert_eq!(g.return_or_self().ok(), Some(2));
+    }
 }

src/lib.rs

@@ -60,6 +60,23 @@
 //! println!("coroutine is_done={}", g.is_done()); // true
 //! println!("coroutine returns {}", g.return_or_self().ok().unwrap()); // "done"
 //! ```
+//! 
+//! ## support immovable coroutine (self referenced)
+//! ```
+//! #![feature(coroutines)]
+//!
+//! use gen_iter::gen_iter;
+//!
+//! let arr = [1, 2];
+//! let mut g = gen_iter!(static move {
+//!     let v = &arr;
+//!     for i in 0..v.len() {
+//!         yield v[i];
+//!     }
+//! });
+//!
+//! assert_eq!(g.collect::<Vec<i32>>(), [1, 2]);
+//! ```
 
 #![no_std]
 #![feature(coroutines, coroutine_trait)]