[ruby-talk:00673] Re: How do I use `callcc'

On 17 Aug, Yukihiro Matsumoto wrote:
> Hi,
> 
> In message "[ruby-talk:00667] How do I use `callcc'"
>     on 99/08/15, Clemens Hintze <[e-mail]> writes:
> 

[...]

> 
> Continuations are say dynamic labels;  you can't alter them.  But
> using it, you can emulate coroutines.  Here's something similar.

[...]

Thanks for the example. Now some things are a lot more clear to me! :-)

> 
> By the way, why don't you use thread, instead of emulating coroutine
> by yourself.

Sometimes a coroutine can be of more use than a thread. With coroutines
I can emulate threading with an own scheduler adapted to my needs. So
perhaps Ruby could also have threading even on MSDOS? ;-)))

Furthermore I have not pay too much attention to synchronize issues
with coroutines... Often coroutines are better for RT tasks than
threads, etc. pp. :-)

> 
> |I have thougth, the execution would go back till after (1), so that the
> |calculation will be performed, and then the result would be returned.
> |But it seems also to influence the global execution. Because it goes
> |not only back to (1) but back to (2).
> 
> As I said before continuations are labels.  calling Continuation#call
> jumps into the place where the continuation created.

I have understood that! But not with all consequences. The surprising
fact for me was, that this `dynamic label' would also influence the
state of the level that called the method, that use `callcc 

	def crea_cont
	   callcc {|c| return c}     # 1
	   1
	end

	f = crea_cont                # 2
	p f
=> #<Continuation:0x3b738>
	f.call
        p f
=> 1

That means `f.call' was returning to (#1) but after leaving of method
`crea_cont' I was suddenly on (#2), so that `f' was reassigned. That
has astonished me. :-)))))
	

> 
>                                                         matz.

\cle