Add iter macro (movable generator)

Author: oli-obk

Diff for: library/core/src/iter/mod.rs

@@ -420,6 +420,8 @@ pub use self::adapters::{Intersperse, IntersperseWith};
     issue = "42168"
 )]
 pub use self::range::Step;
+#[unstable(feature = "iter_macro", issue = "none", reason = "generators are unstable")]
+pub use self::sources::iter;
 #[stable(feature = "iter_empty", since = "1.2.0")]
 pub use self::sources::{Empty, empty};
 #[unstable(

Diff for: library/core/src/iter/sources.rs

@@ -1,6 +1,7 @@
 mod empty;
 mod from_coroutine;
 mod from_fn;
+mod generator;
 mod once;
 mod once_with;
 mod repeat;
@@ -18,6 +19,8 @@ pub use self::empty::{Empty, empty};
 pub use self::from_coroutine::{FromCoroutine, from_coroutine};
 #[stable(feature = "iter_from_fn", since = "1.34.0")]
 pub use self::from_fn::{FromFn, from_fn};
+#[unstable(feature = "iter_macro", issue = "none", reason = "generators are unstable")]
+pub use self::generator::iter;
 #[stable(feature = "iter_once", since = "1.2.0")]
 pub use self::once::{Once, once};
 #[stable(feature = "iter_once_with", since = "1.43.0")]

Diff for: library/core/src/iter/sources/generator.rs

@@ -0,0 +1,25 @@
+/// Creates a new closure that returns an iterator where each iteration steps the given
+/// generator to the next `yield` statement.
+///
+/// Similar to [`iter::from_fn`], but allows arbitrary control flow.
+///
+/// [`iter::from_fn`]: crate::iter::from_fn
+///
+/// # Examples
+///
+/// ```
+/// #![feature(iter_macro, coroutines)]
+///
+/// let it = std::iter::iter!{
+///     yield 1;
+///     yield 2;
+///     yield 3;
+/// };
+/// let v: Vec<_> = it.collect();
+/// assert_eq!(v, [1, 2, 3]);
+/// ```
+#[unstable(feature = "iter_macro", issue = "none", reason = "generators are unstable")]
+#[allow_internal_unstable(coroutines, iter_from_coroutine)]
+pub macro iter($($t:tt)*) {
+    || $crate::iter::from_coroutine(#[coroutine] || { $($t)* })
+}

Diff for: tests/ui/iterators/generator.rs

@@ -0,0 +1,28 @@
+//@ run-pass
+
+#![feature(iter_macro)]
+// FIXME(iter_macro): make `yield` within it legal
+#![feature(coroutines)]
+
+use std::iter::iter;
+
+fn main() {
+    let i = iter! {
+        yield 0;
+        for x in 5..10 {
+            yield x * 2;
+        }
+    };
+    let mut i = i();
+    assert_eq!(i.next(), Some(0));
+    assert_eq!(i.next(), Some(10));
+    assert_eq!(i.next(), Some(12));
+    assert_eq!(i.next(), Some(14));
+    assert_eq!(i.next(), Some(16));
+    assert_eq!(i.next(), Some(18));
+    assert_eq!(i.next(), None);
+    // FIXME(iter_macro): desugar to `gen` instead of coroutines,
+    // as the latter panic after resuming iteration.
+    //assert_eq!(i.next(), None);
+    //assert_eq!(i.next(), None);
+}