Ok, and the reason you need to have this lambda is that callcc is a
function that takes one argument: a function which itself takes one
argument, the CC. Because my-fun requries more than one argument,
you need the lambda, right?
Correct. You need to wrap it in an anonymous function to pass along the arguments.
So it looks like Ruby is trying to look like the scheme implementation.
Sometimes trying to mimic the way things look in a functional language
when programming in an imperative language makes for convoluted code.
There may be some subtlety I’m missing, but it seems like you aught to
be able to have a “returncc” function in scheme that takes no arguments
and returns a continuation context thingo, then use it like:(my_fun (returncc) arg1 arg2 arg3 …)
It could probably even be implemented as
(lambda (cc) cc)
Though, my scheme is weak to nonexistent so I’m not 100% sure I
have the syntax right.I’m just not sure exactly where things end up if you call that
continuation context… though I suppose you’d just end up right in the
middle of assigning arguments to a method call, followed by
actually calling the method.If that’s possible, this should work in Ruby:
my_fun(Continuation.new, arg1, arg2, arg3, …)
Or, more clear to me:
cc = Continuation.new
my_fun(cc, arg1, arg2, arg3, …)Am I out to lunch, or does any of this make sense?
Ben
Well, as people have said, continuations are really related to function calls, so in essence, if you do:
cc = Continuation.new
…
cc.call(blah)
Then after that point, cc would contain blah, since calling a continuation returns from the call that created the continuation. That’s why you can’t just do:
cc = callcc { |cc| cc }
Which is essentially equivalent to your Continuation.new. To keep cc valid, you need to do something like:
cc, else = callcc { |cc| cc, nil }
…
cc.call(cc, return_stuff)
Now, you could eliminate the need for passing a block and being able to call functions directly, like:
val = callcc(method(:func), arg1, arg2, …)
Because in Ruby callcc could do:
def callcc(func, *args)
# create continuation somehow
func[cc, *args]
end
Which automatically passes extra arguments along. However, given that you can’t pass methods in a first-class manner without an explicit call to method(), this looks a little ugly to me.
I suppose you could make continuations with a Continuation.new semantic, but you’d lose some of the functionality of callcc unless you wrote it yourself. Otherwise continuations would be like labels and goto that have the added ability to jump between functions.
I hope this has made some sense. I’m no expert in continuations by any means.
- Dan
P.S.: If you wanted to implement the callcc for functions directly, you can do it easily with the current callcc:
def func_callcc(func, *args)
callcc { |cc|
func[cc, *args]
}
end
Likewise, you might be able to implement your continuation paradigm like so (I think):
class MyContinuation
def initialize
callcc { |@cc| }
end
def call(*args)
@cc.call(*args)
end
end
(Note: I haven’t tested this, and won’t be able to until this evening)
I think doing:
mcc = MyContinuation.new
…
mcc.call
Goes back to the line “mcc = MyContinuation.new” Note that any arguments to mcc.call will effectively be ignored, because it’s a constructor (I think). This means that if you used this paradigm for all continuations, returning something with a cc.call would require Continuation.new to create a continuation of the call to the enclosing function, instead of a continuation of the constructor (or something like that), which may or may not be possible, since I don’t know how Ruby implements continuations (it would probably require Ruby using CPS, which is of debatable value). But, this post script has gone on far too long.