Question

我基本上遵循Scala API page for delimited continuations给出的例子。下面的代码工作正常：

import scala.util.continuations._
import scala.collection.mutable.HashMap

val sessions = new HashMap[Int, Int=>Unit]
def ask(prompt: String): Int @cps[Unit] = shift {
  ret: (Int => Unit) => {
    val id = sessions.size
    printf("%s\nrespond with: submit(0x%x, ...)\n", prompt, id)
    sessions += id -> ret
  }
}

def submit(id: Int, addend: Int): Unit = {
  sessions.get(id) match {
    case Some(continueWith) => continueWith(addend)
  }
}

def go = reset {
  println("Welcome!")
  val first = ask("Please give me a number")
  val second = ask("Please enter another number")
  printf("The sum of your numbers is: %d\n", first + second)
}

但是，当我将go修改为以下内容时：

def go = reset {
  println("Welcome!")
  List("First?","Second?").map[Int @cps[Unit]](ask)
}

我收到此错误：

error: wrong number of type parameters for method map: [B, That](f: String => B)
(implicit bf: scala.collection.generic.CanBuildFrom[List[String],B,That])That
             List("First?","Second?").map[Int @cps[Unit]](ask)
                                         ^

添加Any作为第二个类型参数没有帮助。知道我应该提供什么类型吗？

Answer 1

原因是如果不在map上创建CPS转换的List方法，这是不可能的：CPS注释使编译器将您的方法“由内向外”以传递延续回到需要的地方，标准List.map不遵守转换后的合同。如果你想让你的思想包裹在Klein瓶中一段时间，你可以查看从你的来源产生的类文件，特别是方法签名。

这是CPS插件永远不会成为这个问题的完整通用解决方案的主要原因，这不是由于缺陷而是由于“直接”代码和延续传递风格之间固有的不匹配造成的。

Answer 2

您需要为隐含的CanBuildFrom提供正确的参数：

List("First?","Second?").map[Int @cps[Unit], List[Int @cps[Unit]](ask)

但你真的需要明确关于类型吗？也许只是.map(ask)会起作用。

Answer 3

这是我能够解决的最接近的事情。它使用shiftR来表示延续而不是重置它，使用foldRight来构造悬浮的连续链，使用shift / reset块来获得暂停后的延续，以及一个“animate”方法来启动暂停的延续。 / p>

import scala.collection.mutable.HashMap
import scala.util.continuations._

val sessions = new HashMap[Int, (Unit=>Unit, Int)]
val map = new HashMap[Int, Int]

def ask(pair:(String, Int)) = pair match { 
  case (prompt, index) => shiftR { (ret: Unit => Unit) => {
    val id = sessions.size
    printf("%s\nrespond with: submit(0x%x, ...)\n", prompt, id)
    sessions += id -> (ret, index)
    ()
  }}
}

def submit(id: Int, addend: Int): Unit = {
  sessions.get(id) match {
    case Some((continue, index)) => { map.put(index, addend); continue() }
  }
}

def sum(m:HashMap[Int,Int]) : Int = {
  m.fold[(Int, Int)]((0, 0))((a, b) => (0, {a._2+b._2}))._2
}

type Suspended = ControlContext[Unit,Unit,Unit]

class AnimateList(l:List[Suspended]) {
  def suspend(k: => Unit) = (c: Unit) => k
  def animate(k:Unit => Unit): Unit = {
    l.foldRight(k)(
      (elem: Suspended, acc: Unit => Unit) => suspend(elem.fun(acc, ex => ())))()
  }
}

implicit def listToAnimateList(l:List[Suspended]) = new AnimateList(l)

reset { 
  val conts = List("First?","Second?","Third?").zipWithIndex.map(ask)
  shift { conts.animate }
  println(sum(map))
}

我应该使用什么类型的参数来使List.map使用分隔的延续？

3 个答案: