diff --git a/Cargo.toml b/Cargo.toml index c0070a7..3df8c1a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "gen-iter" -version = "0.2.1" +version = "0.4.0" authors = ["tinaun "] keywords = ["generator", "iterator"] description = "temporary util for creating iterators using generators" diff --git a/rust-toolchain b/rust-toolchain new file mode 100644 index 0000000..07ade69 --- /dev/null +++ b/rust-toolchain @@ -0,0 +1 @@ +nightly \ No newline at end of file diff --git a/src/gen_iter.rs b/src/gen_iter.rs index 37fa916..288ec7e 100644 --- a/src/gen_iter.rs +++ b/src/gen_iter.rs @@ -1,6 +1,6 @@ -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 @@ -8,26 +8,26 @@ use core::pin::Pin; #[derive(Copy, Clone, Debug)] pub struct GenIter(pub T) where - T: Generator + Unpin; + T: Coroutine + Unpin; impl Iterator for GenIter where - T: Generator + Unpin, + T: Coroutine + Unpin, { type Item = T::Yield; #[inline] fn next(&mut self) -> Option { match Pin::new(&mut self.0).resume(()) { - GeneratorState::Yielded(n) => Some(n), - GeneratorState::Complete(()) => None, + CoroutineState::Yielded(n) => Some(n), + CoroutineState::Complete(()) => None, } } } impl From for GenIter where - G: Generator + Unpin, + G: Coroutine + Unpin, { #[inline] fn from(gen: G) -> Self { @@ -35,11 +35,10 @@ where } } - /// macro to simplify iterator - via - generator construction /// /// ``` -/// #![feature(generators)] +/// #![feature(coroutines)] /// /// use gen_iter::gen_iter; /// @@ -60,10 +59,9 @@ macro_rules! gen_iter { }; (move $block: block) => { $crate::GenIter(move || $block) - } + }; } - #[cfg(test)] mod tests { use super::GenIter; @@ -85,7 +83,8 @@ mod tests { let mut g: GenIter<_> = (|| { yield 1; yield 2; - }).into(); + }) + .into(); assert_eq!(g.next(), Some(1)); assert_eq!(g.next(), Some(2)); diff --git a/src/gen_iter_return.rs b/src/gen_iter_return.rs index 9ad2bc3..beee7ae 100644 --- a/src/gen_iter_return.rs +++ b/src/gen_iter_return.rs @@ -1,19 +1,19 @@ -use core::ops::{Generator, GeneratorState}; -use core::iter::{Iterator, FusedIterator}; +use core::iter::{FusedIterator, Iterator}; use core::marker::Unpin; +use core::ops::{Coroutine, CoroutineState}; use core::pin::Pin; /// `GenIterReturn` holds a generator `G` or the return value of `G`, /// `&mut GenIterReturn` acts as an iterator. -/// +/// /// Differences with `GenIter`: /// 1. able to get return value of a generator /// 2. safe to call `next()` after generator is done without panic /// 3. maybe less efficient than `GenIter` #[derive(Copy, Clone, Debug)] -pub struct GenIterReturn(Result); +pub struct GenIterReturn(Result); -impl GenIterReturn { +impl GenIterReturn { #[inline] pub fn new(g: G) -> Self { GenIterReturn(Err(g)) @@ -37,13 +37,13 @@ impl GenIterReturn { /// in which return value cannot be got. /// ```compile_fail /// // !!INVALID CODE!! -/// # #![feature(generators)] +/// # #![feature(coroutines)] /// # use gen_iter::gen_iter_return; /// let mut g = gen_iter_return!({ yield 1; return "done"; }); /// for v in g {} // invalid, because `GenIterReturn` is not `Iterator` /// let ret = g.return_or_self(); // g is dropped after for loop /// ``` -impl Iterator for &mut GenIterReturn { +impl Iterator for &mut GenIterReturn { type Item = G::Yield; #[inline] @@ -51,20 +51,20 @@ impl Iterator for &mut GenIterReturn { match self.0 { Ok(_) => None, Err(ref mut g) => match Pin::new(g).resume(()) { - GeneratorState::Yielded(y) => Some(y), - GeneratorState::Complete(r) => { + CoroutineState::Yielded(y) => Some(y), + CoroutineState::Complete(r) => { self.0 = Ok(r); None - }, - } + } + }, } } } /// `GenIterReturn` satisfies the trait `FusedIterator` -impl FusedIterator for &mut GenIterReturn {} +impl FusedIterator for &mut GenIterReturn {} -impl From for GenIterReturn { +impl From for GenIterReturn { #[inline] fn from(g: G) -> Self { GenIterReturn::new(g) @@ -73,7 +73,7 @@ impl From for GenIterReturn { /// macro to simplify iterator - via - generator with return value construction /// ``` -/// #![feature(generators)] +/// #![feature(coroutines)] /// /// use gen_iter::gen_iter_return; /// @@ -95,7 +95,7 @@ macro_rules! gen_iter_return { }; (move $block: block) => { $crate::GenIterReturn::new(move || $block) - } + }; } #[cfg(test)] @@ -116,7 +116,7 @@ mod tests { g = match g.return_or_self() { Ok(_) => panic!("generator is done but should not"), - Err(g) => g + Err(g) => g, }; assert_eq!((&mut g).next(), None); diff --git a/src/lib.rs b/src/lib.rs index ee9c5a4..e9cab8b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -3,11 +3,11 @@ //! ## [`GenIter`] and [`gen_iter!`] //! [`GenIter`] converts a [`Generator<(), Return=()>`](core::ops::Generator) into an iterator over the //! yielded type of the generator. The return type of the generator needs to be `()`. -//! +//! //! [`gen_iter!`] helps to create a [`GenIter`] //! //! ``` -//! #![feature(generators)] +//! #![feature(coroutines)] //! //! use gen_iter::gen_iter; //! @@ -30,16 +30,16 @@ //! println!("{}", elem); //! } //! ``` -//! +//! //! ## [`GenIterReturn`] and [`gen_iter_return!`] //! [`GenIterReturn`] can be converted from a [`Generator<()>`](core::ops::Generator), //! `&mut GenIterReturn` can be used as iterator. //! The return value of the generator can be got after the iterator is exhausted. -//! +//! //! [`gen_iter_return!`] helps to create a [`GenIterReturn`]. -//! +//! //! ``` -//! #![feature(generators)] +//! #![feature(coroutines)] //! //! use gen_iter::gen_iter_return; //! @@ -48,7 +48,7 @@ //! yield 2; //! return "done"; //! }); -//! +//! //! for y in &mut g { //! println!("yield {}", y); //! } @@ -57,7 +57,7 @@ //! ``` #![no_std] -#![feature(generators, generator_trait)] +#![feature(coroutines, coroutine_trait)] mod gen_iter; pub use gen_iter::*;