如何将Koka的ctl effect控制流转换为外部迭代器？

背景：Koka的ctl effect控制流能力 #

Koka 使用ctl effect 具备出色的控制流建模能力，以下是示例代码（注：代码不够标准，但不影响逻辑理解）：

pub fun main()
    var n := 20
    var sum := 0
    (handler {
        ctl yield(j) {
            println(j)
            sum := sum + j
            n := n - 1
            if n > 0
            then resume(())
        }
    }){
        fibonacci()
    }
    println("sum=" ++ sum.show)

effect yield
    ctl yield(i: int): ()

fun fibonacci() : <div,yield> ()
    var i := 0
    var j := 1
    yield(j)
    while { True }
        val k = i + j
        i := j
        j := k
        yield(j)

需求说明 #

希望实现一个可轮询获取下一个数值的迭代器，定义如下函数：

fun next(iter: iterator): maybe<int> 

核心目标是反转控制流，无需在effect处理器中编写业务逻辑，改为主动调用next来拉取生成器的下一个值。

实现方案 #

通过定义迭代器状态、编写捕获yield的handler，将原有的“推送式”生成器转为“拉取式”迭代器：

1. 定义迭代器类型与状态 #

首先定义迭代器的状态类型，用于保存生成器的执行进度：

// 迭代器状态：已完成 或 保存待继续执行的逻辑
type iterator-state
  | IteratorDone
  | IteratorSuspended((unit) -> <div> unit)

// 迭代器是引用类型，用于动态更新执行状态
type iterator = ref<iterator-state>

2. 重新定义yield effect #

调整yield effect，让生成器在yield后可以继续执行剩余逻辑：

effect yield
  ctl yield(i: int): ()

3. 生成器转迭代器函数 #

将原有的生成器函数包装为迭代器，初始化执行状态：

fun generator-to-iterator(gen: () -> <yield, div> unit): iterator
  ref(IteratorSuspended(gen))

4. 实现next轮询函数 #

编写next函数，驱动迭代器执行到下一个yield或结束，返回对应的值：

fun next(iter: iterator): maybe<int>
  var result: maybe<int> := None
  // 更新迭代器状态，执行到下一个yield或完成
  iter := handler {
    ctl yield(i) {
      result := Some(i)
      // 暂停执行，返回待继续的逻辑
      resume(IteratorSuspended(() => resume(())))
    }
    finally {
      // 生成器执行完毕，标记为已完成
      IteratorDone
    }
  }(!iter match {
    IteratorDone => IteratorDone
    IteratorSuspended(f) => f(); IteratorDone
  })
  result

测试示例 #

用原有的斐波那契生成器测试迭代器功能，主动调用next获取值并处理：

fun fibonacci() : <yield, div> ()
  var i := 0
  var j := 1
  yield(j)
  while { True }
    val k = i + j
    i := j
    j := k
    yield(j)

pub fun main()
  val iter := generator-to-iterator(fibonacci)
  var sum := 0
  var count := 20
  while count > 0
    match next(iter) {
      Some(n) =>
        println(n)
        sum := sum + n
        count := count - 1
      None => break
    }
  println("sum=" ++ sum.show)

这段代码运行后，会输出前20个斐波那契数并打印总和，所有业务逻辑（打印、求和）都在主动调用next的代码中完成，无需在effect处理器内编写。

内容的提问来源于stack exchange，提问作者Mark