cocoro crate 展示了与 coroutine_trait 功能保护的 std::ops::Coroutine 不同的Rust协程方法。

协程是一个状态机，可以逐个消耗“输入”值，并且每次“产出”一个值或“返回”一个最终值。协程可以任意多次产出，但只能返回一次。

在这个crate中，核心协程特性看起来像这样

pub trait SuspendedVisitor<Y, R, I, N>
where
    N: Coro<Y, R, I>,
{
    type Out;
    fn on_yield(self, y: Y, next: N) -> Self::Out;
    fn on_return(self, r: R) -> Self::Out;
}

pub trait Suspended<Y, R, I> {
    type Next: Coro<Y, R, I>;
    fn visit<X>(
        self,
        visitor: impl SuspendedVisitor<Y, R, I, Self::Next, Out = X>,
    ) -> X;
}

pub trait Coro<Y, R, I = ()>: Sized {
    type Next: Coro<Y, R, I>;
    type Suspend: Suspended<Y, R, I, Next = Self::Next>;
    fn resume(self, input: I) -> Self::Suspend;
}

注意以下与 std::ops::Coroutine 的区别

• resume 方法以值的形式接受 self，而不是以固定独占引用的形式。
• "产出"和"返回"的类型是泛型参数，而不是关联类型。
• resume 方法返回一个包装协程状态的 Suspend 类型，该类型为“访问者”提供一个可以再次恢复的协程句柄。

Suspended 特性可以被视为枚举的抽象。实际上，许多协程实现将使用crate提供的以下枚举

pub enum Suspend<Y, R, N> {
    Yield(Y, N),
    Return(R),
}

Yield 和 Return 变体被导入到crate的根命名空间中，因此它们可以在不使用 Suspend:: 前缀的情况下使用。

此外，Coro 特性提供了一些默认的组合器，这些组合器对于使用 Iterator 的人来说应该很熟悉，例如

• map_yield 使用 FnMut 转换产出的值
• map_return 使用 FnOnce 转换返回值
• flatten 将返回另一个协程的协程简化为单个协程

此crate不尝试使用花哨的宏或代码转换，让您能够像编写过程函数一样编写协程，就像coroutine_trait功能所做的那样。相反，它设计为函数式风格，其中生成的元素和返回的元素通过组合子管道进行转换，强调类型安全。

示例

一个基本的计数器

这是一个产生连续整数且永不返回的协程

use cocoro::{Coro, Suspended, Yielded};

struct Counter(i32);
impl Coro<i32, (), ()> for Counter {
    type Next = Self;
    type Suspend = Yielded<i32, Self>;
    fn resume(self, _: ()) -> Self::Suspend {
        Yielded(self.0, Counter(self.0 + 1))
    }
}

let mut counter = Counter(0);
for _ in 0..10 {
    let Yielded(n, next) = counter.resume(());
    println!("{}", n);
    counter = next;
}

请注意，Counter结构是不可变的，并且通过构造一个新的Counter实例从resume方法返回下一个状态。

因为Next关联类型是Self，所以我们能够就地修改counter变量。然而，在下一个示例中，我们将看到一个产生具有与其自身不同类型的状态的协程。

use cocoro::{yield_with, Coro, Void, Yield};
let mut i = 0;
let _: Option<Void> = yield_with(|()| {
    i += 1;
    i
})
.take(10)
.for_each(|n| {
    println!("{}", n);
});

use cocoro::{Coro, Returned, Suspend, Suspended, Void, Yielded};

struct Three;
struct Two;
struct One;
#[derive(Debug, PartialEq, Eq)]
struct Blastoff;

impl Coro<i32, Blastoff, ()> for Three {
    type Next = Two;
    type Suspend = Yielded<i32, Self::Next>;
    fn resume(self, _: ()) -> Self::Suspend {
        Yielded(3, Two)
    }
}

impl Coro<i32, Blastoff, ()> for Two {
    type Next = One;
    type Suspend = Yielded<i32, Self::Next>;
    fn resume(self, _: ()) -> Self::Suspend {
        Yielded(2, One)
    }
}

impl Coro<i32, Blastoff, ()> for One {
    type Next = Blastoff;
    type Suspend = Yielded<i32, Self::Next>;
    fn resume(self, _: ()) -> Self::Suspend {
        Yielded(1, Blastoff)
    }
}

impl Coro<i32, Blastoff, ()> for Blastoff {
    type Next = Void;
    type Suspend = Returned<Blastoff>;
    fn resume(self, _: ()) -> Self::Suspend {
        Returned(Blastoff)
    }
}

let countdown = Three;
let Yielded(n, countdown) = countdown.resume(());
println!("{}", n);
let Yielded(n, countdown) = countdown.resume(());
println!("{}", n);
let Yielded(n, countdown) = countdown.resume(());
println!("{}", n);
let Returned(blastoff) = countdown.resume(());
println!("{:?}!", blastoff);

use cocoro::{from_fn, Coro, Returned, Suspended, Void, Yielded};
#[derive(Debug, PartialEq, Eq)]
struct Blastoff;
#[rustfmt::skip]
let countdown = from_fn(|_| {
    Yielded(3, from_fn(|_| {
    Yielded(2, from_fn(|_| {
    Yielded(1, from_fn(|_| {
    Returned(Blastoff) })) })) }))
});
let Yielded(n, countdown) = countdown.resume(());
println!("{}", n);
let Yielded(n, countdown) = countdown.resume(());
println!("{}", n);
let Yielded(n, countdown) = countdown.resume(());
println!("{}", n);
let Returned(blastoff) = countdown.resume(());
println!("{:?}!", blastoff);