I've been trying to figure out how delimited continuations in Scala work, from a users' perspective, although pretty much all the examples have been written by people who have been working for ages with functional languages. For example, this is the description from wikipedia on delimited continuations:
In programming languages, a delimited continuation, composable continuation or partial continuation, is a "slice" of a continuation frame that has been reified into a function. Unlike regular continuations, delimited continuations return a value, and thus may be reused and composed.
I'm sure it makes sense to someone well versed in functional programming, but to someone coming from a pure, nonfunctional background, it makes no sense at all.
]]>
shift { k: (Int=>Int) =>
k(7)
}
This is the archetypical continuation example; it simply returns 7. So far so good, right?
reset {
shift { k: (Int=>Int) =>
k(7)
} + 1
} * 2
This second example returns 16. It still makes sense; (7 + 1) * 2 does indeed equal 16.
reset {
shift { k: (Int=>Int) =>
k(k(k(7)))
} + 1
} * 2
Now this one is a bit funkier, it returns 20. The way to look at it is that you get (7 + 1 + 1 + 1) * 2, which does equal 20. So that would mean that for each "invocation" of k, it does add a "+1" to the equation, which would be the code in the reset block.
def foo() = {
1 + shift(k => k(k(k(7))))
}
def bar() = {
foo() * 2
}
def baz() = {
reset(bar())
}
baz()
Lastly, we get this one, which is equal to 70. If we look at it, we can't simply do (7 + 1 + 1 + 1) * 2, it's obviously not equal to 70. So what's happening here?
It turns out that to understand continuations, you have to flip the computation inside out; the code that gets executed is the shift block, and the definition of "k" is the code in the reset block.
This would mean that the code is equivalent to
def k(i:Int):Int = {
(i + 1) * 2
}
k(k(k(7)))
I'm still trying to wrap my head at this point around this one though:
type Monadic[+U, CC[_]] = {
def flatMap[V](f: U => CC[V]): CC[V]
}
class Reflective[+A, C[_]](xs: Monadic[A,C]) {
def reflect[B](): A @cps[C[B], C[B]] = {
shift { k:(A => C[B]) =>
xs.flatMap(k)
}
}
}
reset {
val left = List("x","y","z")
val right = List(4,5,6)
List(left.reflect[Any] -> right.reflect[Any])
}
This one should return "List[(String, Int)] = List((x,4), (x,5), (x,6), (y,4), (y,5), (y,6), (z,4), (z,5), (z,6)," by the way. Any clues?
]]>
