Kiselyov拉链的惯用斯卡拉翻译？

时间：2013-04-11 03:52:33

标签： scala haskell monads continuations zipper

Oleg Kiselyov showed how to make a zipper from any traversable使用分隔的延续。他的Haskell代码非常简短：

module ZipperTraversable where 

import qualified Data.Traversable as T
import qualified Data.Map as M


-- In the variant Z a k, a is the current, focused value
-- evaluate (k Nothing) to move forward
-- evaluate (k v)       to replace the current value with v and move forward.

data Zipper t a = ZDone (t a) 
                | Z a (Maybe a -> Zipper t a)

make_zipper :: T.Traversable t => t a -> Zipper t a
make_zipper t = reset $ T.mapM f t >>= return . ZDone
 where
 f a = shift (\k -> return $ Z a (k . maybe a id))

-- The Cont monad for delimited continuations, implemented here to avoid
-- importing conflicting monad transformer libraries

newtype Cont r a = Cont{runCont :: (a -> r) -> r}

instance Monad (Cont r) where
    return x = Cont $ \k -> k x
    m >>= f  = Cont $ \k -> runCont m (\v -> runCont (f v) k)

-- Two delimited control operators,
-- without answer-type polymorphism or modification
-- These features are not needed for the application at hand

reset :: Cont r r -> r
reset m = runCont m id

shift :: ((a -> r) -> Cont r r) -> Cont r a
shift e = Cont (\k -> reset (e k))

我在尝试在Scala中实现它时遇到了一些问题。我开始尝试使用Scala的分隔延续包，但即使使用Rompf的richIterable概念推广到@cps [X]而不是@suspendable，也不可能让提供的函数返回与提供的函数不同的类型重置。

我尝试按照Kiselyov的定义实现continuation monad，但Scala使得很难对类型参数进行调整，我无法弄清楚如何以scalaz的遍历方法满意的方式将Cont [R]转换为monad。

我是Haskell和Scala的初学者，非常感谢这方面的帮助。

1 个答案:

答案 0 :(得分：13)

您可以使用continuations插件。在插件执行其翻译后，它与Cont monad以及Oleg的shift和reset具有相似性。棘手的部分是找出类型。所以这是我的翻译：

import util.continuations._
import collection.mutable.ListBuffer

sealed trait Zipper[A] { def zipUp: Seq[A] }
case class ZDone[A](val zipUp: Seq[A]) extends Zipper[A]
case class Z[A](current: A, forward: Option[A] => Zipper[A]) extends Zipper[A] {
  def zipUp = forward(None).zipUp
}

object Zipper {
  def apply[A](seq: Seq[A]): Zipper[A] = reset[Zipper[A], Zipper[A]] {
    val coll = ListBuffer[A]()
    val iter = seq.iterator
    while (iter.hasNext) {
      val a = iter.next()
      coll += shift { (k: A=>Zipper[A]) =>
        Z(a, (a1: Option[A]) => k(a1.getOrElse(a)))
      }
    }
    ZDone(coll.toList)
  }
}

continuation插件支持while循环，但不支持map或flatMap，因此我选择使用while和可变{{1}捕获可能更新的元素。 ListBuffer函数已转换为随附的make_zipper - 用于创建新对象或集合的典型Scala位置。数据类型被转换为密封特征，其中两个案例类扩展了它。我已经将zip_up函数作为Zipper.apply的方法，为每个案例类提供了不同的实现。也很典型。

这是在行动：

Zipper

我如何确定object ZipperTest extends App { val sample = for (v <- 1 to 5) yield (v, (1 to v).reduceLeft(_ * _)) println(sample) // Vector((1,1), (2,2), (3,6), (4,24), (5,120)) def extract134[A](seq: Seq[A]) = { val Z(a1, k1) = Zipper(seq) val Z(a2, k2) = k1(None) val Z(a3, k3) = k2(None) val Z(a4, k4) = k3(None) List(a1, a3, a4) } println(extract134(sample)) // List((1,1), (3,6), (4,24)) val updated34 = { val Z(a1, k1) = Zipper(sample) val Z(a2, k2) = k1(None) val Z(a3, k3) = k2(None) val Z(a4, k4) = k3(Some(42 -> 42)) val z = k4(Some(88 -> 22)) z.zipUp } println(updated34) // List((1,1), (2,2), (42,42), (88,22), (5,120)) } ，shift和k的类型或如何翻译reset？

我看了T.mapM，我知道这会让我得到一个mapM，但我不确定Cont内部是什么，因为它取决于转变。所以我从班次开始。忽略haskell Cont以构建return，shift会返回Cont。我还猜我需要在我的集合中添加Zipper类型的元素来构建。因此，移位将位于“洞”中，其中A类型的元素是预期的，因此A将是k函数。我们假设这个。在我不太确定的类型之后我会加上问号。所以我开始：

A=>?

接下来，我（{硬}）看了shift { (k: A?=>?) => Z(a, ?) } 。函数(k . maybe a id)将返回maybe a id，因此与A作为参数的内容一致。它相当于k。另外因为我需要填写a1.getOrElse(a)，我需要弄清楚如何从选项到Zipper获取函数。最简单的方法是假设Z(a, ?)返回k。另外，看看如何使用拉链Zipper或k1(None)，我知道我必须为用户提供一种方法来选择性地替换元素，这是k1(Some(a))函数的作用。 继续原始forward或更新a。它开始有意义了。所以现在我有：

a

接下来我再次看shift { (k: A=>Zipper[A]) => Z(a, (a1: Option[A]) => k(a1.getOrElse(a))) } 。我看到它由mapM组成。再次忽略return . ZDone（因为它仅适用于return monad），我看到Cont将获取生成的集合。所以这是完美的，我只需要将ZDone放入其中，当程序到达那里时，它将具有更新的元素。此外，coll内的表达式类型现在与reset的{​​{1}}的返回类型一致。

最后我填写了编译器可以推断出的重置类型，但是当我猜对了，它给了我一种（错误的）置信感，我知道发生了什么。

我的翻译不像Haskell那样普遍或漂亮，因为它不保留集合中的类型并使用变异，但希望它更容易理解。

编辑：以下是保留该类型并使用不可变列表的版本，以便k：

Zipper[A]

顺便说一句，这里是scala中continuation monad的其他资源：

相关问题
最新问题