编译报错

async-stream = "=0.3.6"
futures = "0.3"
tokio = { version = "=1.54.1", features = ["full"] }

use async_stream::stream;
use futures::StreamExt;

#[tokio::main]
async fn main() {
  let mut s = stream! {
    yield 1;
    yield 2;
  };
  while let Some(v) = s.next().await {
    println!("{v}");
  }
}

error[E0277]: `{async block@lib.rs:193:9}` cannot be unpinned
    --> src/bin/unpin.rs:10:25
     |
  10 |   while let Some(v) = s.next().await {
     |                         ^^^^ within `__Origin<'_, {integer}, {async block@lib.rs:193:9}>`, the trait `Unpin` is not implemented for `{async block@lib.rs:193:9}`
     |
     = note: consider using the `pin!` macro
             consider using `Box::pin` if you need to access the pinned value outside of the current scope
...
     = note: required for `AsyncStream<{integer}, {async block@lib.rs:193:9}>` to implement `Unpin`
note: required by a bound in `futures::StreamExt::next`
...
 275 |         Self: Unpin,
     |               ^^^^^ required by this bound in `StreamExt::next`

// 写法一：pin 在栈上
let mut s = pin!(stream! {
  yield 1;
  yield 2;
});
while let Some(v) = s.next().await {
  println!("pin!: {v}");
}
// 写法二：装箱，可以存进结构体、跨函数返回
let mut b = Box::pin(stream! {
  yield 3;
});
while let Some(v) = b.next().await {
  println!("Box::pin: {v}");
}
// 写法三：消费方式自己会 pin
let all: Vec<i32> = stream! { yield 4; yield 5; }.collect().await;
println!("collect: {all:?}");

pin!: 1
pin!: 2
Box::pin: 3
collect: [4, 5]

let s = stream! {
  (0..3).for_each(|i| {
    yield i;
  });
};
let items: Vec<i32> = s.collect().await;

error[E0658]: yield syntax is experimental
 --> src/bin/closure_yield.rs:8:7
  |
8 |       yield i;
  |       ^^^^^^^
  |
  = note: see issue #43122 <https://github.com/rust-lang/rust/issues/43122> for more information
error: `yield` can only be used in `#[coroutine]` closures, or `gen` blocks
 --> src/bin/closure_yield.rs:8:7
  |
8 |       yield i;
  |       ^^^^^^^
  |
help: use `#[coroutine]` to make this closure a coroutine
  |
7 |     (0..3).for_each(#[coroutine] |i| {
  |                     ++++++++++++
error[E0277]: expected an `FnMut({integer})` closure, found `{coroutine@src/bin/closure_yield.rs:7:21: 7:24}`
...
error[E0277]: the trait bound `Vec<i32>: Extend<()>` is not satisfied

use std::time::Duration;

use async_stream::stream;
use futures::StreamExt;
use tokio::time::sleep;

#[tokio::main]
async fn main() {
  // 想让两路并发执行、各自 yield
  let s = stream! {
    tokio::join!(
      async {
        sleep(Duration::from_millis(1)).await;
        yield "a";
      },
      async {
        yield "b";
      },
    );
  };
  let items: Vec<&str> = s.collect().await;
  println!("{items:?}");
}

error[E0767]: use of unreachable label `'__async_stream_private_check_scope`
  --> src/bin/join_yield.rs:10:11
   |
10 |     let s = stream! {
   |  ___________^
11 | |     tokio::join!(
12 | |       async {
13 | |         sleep(Duration::from_millis(1)).await;
...  |
19 | |     );
20 | |   };
   | |   ^
   | |   |
   | |___unreachable label `'__async_stream_private_check_scope`
   |     unreachable label defined here
   |
   = note: labels are unreachable through functions, closures, async blocks and modules

error[E0267]: `break` inside `async` block
  --> src/bin/join_yield.rs:10:11
...
   | |       async {
   | |       ----- enclosing `async` block

let s = stream! {
  let (a, b) = tokio::join!(
    async {
      sleep(Duration::from_millis(1)).await;
      "a"
    },
    async { "b" },
  );
  yield a;
  yield b;
};

["a", "b"]

use async_stream::try_stream;
use futures::StreamExt;

fn parse(s: &str) -> Result<i32, std::num::ParseIntError> {
  s.parse()
}

#[tokio::main]
async fn main() {
  let s = try_stream! {
    let v = parse("1")?;
    yield v;
  };
  let items: Vec<_> = s.collect().await;
  println!("{items:?}");
}

error[E0282]: type annotations needed for `AsyncStream<Result<i32, _>, {async block@lib.rs:229:9}>`
  --> src/bin/infer.rs:10:7
   |
10 |   let s = try_stream! {
   |       ^
...
14 |   let items: Vec<_> = s.collect().await;
   |                       - type must be known at this point
   |
help: consider giving `s` an explicit type, where the placeholders `_` are specified
   |
10 |   let s: async_stream::__private::AsyncStream<Result<_, _>, {async block@.../async-stream-0.3.6/src/lib.rs:229:9: 229:63}> = try_stream! {

// 返回类型把错误类型钉死，`?` 里的 e.into() 就有了目标
fn numbers(input: Vec<&'static str>) -> impl Stream<Item = Result<i32, ParseIntError>> {
  try_stream! {
    for t in input {
      let v = parse(t)?;
      yield v;
    }
  }
}

#[tokio::main]
async fn main() {
  let items: Vec<_> = numbers(vec!["1", "2"]).collect().await;
  println!("fn 返回类型: {items:?}");
  // 不想单独写函数时，给变量标类型也行
  let s: std::pin::Pin<Box<dyn Stream<Item = Result<i32, ParseIntError>>>> = Box::pin(try_stream! {
    let v = parse("3")?;
    yield v;
  });
  let items: Vec<_> = s.collect().await;
  println!("变量标注: {items:?}");
}

fn 返回类型: [Ok(1), Ok(2)]
变量标注: [Ok(3)]