rename Generator to Coroutine

CHANGELOG.md

@@ -1,3 +1,10 @@
+# version 0.4.1
+* add support for immovable coroutine (self-referenced)
+* change the varialble name `gen` as it will be a keyword in edition2024
+
+# version 0.4.0
+* follow [rename Generator to Coroutine](https://github.com/rust-lang/rust/pull/116958) and fix #10
+
 # version 0.3
 * made the crate no_std compatible (#5)
 * added struct GenIterReturn and macro gen_iter_return! to iterate over a generator and get the return value (#6)

Cargo.toml

@@ -1,9 +1,10 @@
 [package]
 name = "gen-iter"
-version = "0.2.1"
+version = "0.4.1"
+edition = "2021"
 authors = ["tinaun <tinagma@gmail.com>"]
-keywords = ["generator", "iterator"]
-description = "temporary util for creating iterators using generators"
+keywords = ["coroutine", "generator", "iterator"]
+description = "temporary util for creating iterators using coroutines"
 
 documentation = "https://docs.rs/gen-iter"
 repository = "https://github.com/tinaun/gen-iter"

README.md

@@ -1,4 +1,4 @@
-# gen_iter - iterators using generators.
+# gen_iter - iterators using coroutines/generators.
 
 see [the docs](https://docs.rs/gen-iter) for examples and usage.
 

src/gen_iter.rs

@@ -1,45 +1,66 @@
-use core::ops::{Generator, GeneratorState};
 use core::iter::Iterator;
 use core::marker::Unpin;
+use core::ops::{Coroutine, CoroutineState};
 use core::pin::Pin;
 
-/// an iterator that holds an internal generator representing
+/// 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
-    T: Generator<Return = ()> + Unpin;
+    T: Coroutine<Return = ()> + Unpin;
 
 impl<T> Iterator for GenIter<T>
 where
-    T: Generator<Return = ()> + Unpin,
+    T: Coroutine<Return = ()> + Unpin,
 {
     type Item = T::Yield;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         match Pin::new(&mut self.0).resume(()) {
-            GeneratorState::Yielded(n) => Some(n),
-            GeneratorState::Complete(()) => None,
+            CoroutineState::Yielded(n) => Some(n),
+            CoroutineState::Complete(()) => None,
         }
     }
 }
 
 impl<G> From<G> for GenIter<G>
 where
-    G: Generator<Return = ()> + Unpin,
+    G: Coroutine<Return = ()> + Unpin,
 {
     #[inline]
-    fn from(gen: G) -> Self {
-        GenIter(gen)
+    fn from(g: G) -> Self {
+        GenIter(g)
     }
 }
 
 
-/// macro to simplify iterator - via - generator construction
+/// macro to simplify iterator - via - coroutine construction
 ///
+/// - create a movable coroutine as `Iterator`
 /// ```
-/// #![feature(generators)]
+/// #![feature(coroutines)]
 ///
 /// use gen_iter::gen_iter;
 ///
@@ -48,19 +69,40 @@ 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]);
+/// ```
+/// 
+/// - create an immovable coroutine (self-referenced) pinned in stack 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 {
     ($block: block) => {
-        $crate::GenIter(|| $block)
+        $crate::GenIter(#[coroutine] || $block)
     };
     (move $block: block) => {
-        $crate::GenIter(move || $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) }
+    };
 }
 
 
@@ -82,10 +124,13 @@ mod tests {
 
     #[test]
     fn into_gen_iter() {
-        let mut g: GenIter<_> = (|| {
-            yield 1;
-            yield 2;
-        }).into();
+        let mut g: GenIter<_> = (
+            #[coroutine]
+            || {
+                yield 1;
+                yield 2;
+            }
+        ).into();
 
         assert_eq!(g.next(), Some(1));
         assert_eq!(g.next(), Some(2));
@@ -103,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);
+    }
 }