[ruby-core:22772] Continuation#thread method

Every Continuation object's implementation must contain a reference to the
thread that will be continued when it is called.

However...
If one calls a generic Continuation, one of two things happen:
If it is of the current thread, control jumps to the point after the callcc
{} block.
If it is of another thread, a RuntimeError "continuation called across
threads" is raised.

There is no way to determine what thread will be continued given an
arbitrary Continuation object without trying to call it.

This proposal is to add the method

Continuation#thread

to return the thread that would be continued if on self.call, without any
side effects.

The method is currently implemented only in the MBARI patches available at:

http://sites.google.com/site/brentsrubypatches/

Here's an implementation for Continue#thread excerpted from the patched
eval.c:
/*
 *  call-seq:
 *     cont.thread
 *  
 *  Returns the thread on which this continuation can be called
 *  or nil if that thread has died
 *
 *     t = Thread.new {callcc{|c| $x=c}; sleep 5}
 *     sleep 1
 *     $x.thread                             #=> t
 *     sleep 10
 *     $x.thread                             #=> nil
 *
 */
static VALUE
rb_cont_thread(cont)
  VALUE cont;
{
  rb_thread_t th = THREAD_DATA(cont);
  cc_purge(th);  /* frees th's stack and nils th->thread if th is dead */
  return th->thread;
}

=======

Note:  I'm posting this on ruby-core because the RCR site indicates that it
is no longer being maintained.
Let me know if there's a better venue than this one.

- brent

-- 
View this message in context: http://www.nabble.com/Continuation-thread-method-tp22407166p22407166.html
Sent from the ruby-core mailing list archive at Nabble.com.