ko1 / atdot.net wrote:
> Issue #13618 has been updated by ko1 (Koichi Sasada).
> 
> 
> We discussed about naming.
> 
> ```
> X IoThread.new{}
> X GreenThread.new{}
> X Thread::Green.new{}  #124 “most likely candidates”(vote: hsbt)
> X Thread.green{}           #124 “most likely candidates”
> X Thread.create(scheduler: …, args: ...) #124 “most likely candidates”
> Thread::Coop.new{}
> Thread::Cooperative.new{} # (usa)
> Thread::Nonpreemptive.new{} # (usa; these 2 names are very long, then they are good ^^)

Huh?  Why is a long name good?  Long names waste screen space
and increase typo errors.

> X NonpreemptiveThread.new {} # (mrkn)
> X NPThread.new {} # (mrkn)
> X Thread::Light (ko1)

Another option:  Thread::Coro.new {}

> ```
> 
> X: rejected.
> 
> Discussion is follow:

> * (1) At first, "green" is rejected because "green" is how to
> implement and there are several "green threads" can support
> preemption (such as Ruby 1.8).

I am thinking of adding preemption support to this feature for
compatibility with 1.8

> * (2) New toplevel name is rejected because is should be under `Thread` naming.

OK.  Otherwise, I would push for "Threadlet" name.

> * (3)`Thread.create` is rejected because it seems to make
> `Thread` class object and auto-fiber should be different
> class.

OK

> * (4) Cooperative is rejected because it is also ambiguous.

I don't think it's ambiguous, but too long.

> * (5) Nonpreemptive is considerable because it is different
> from what the application programmers (users) want.

Right; and again, I think preemptible can be an option.

> * (6) Thread::Light is rejected because this name does not
> make sense what the class is.

Probably, yes.

> I think auto-fibers are Threads which have special attribute (scheduler).
> auto-fibers should have same methods in `Thread`.
> I'm not sure why Matz does not like this idea, though.

Agreed, I want to maximize compatibility with code written for
Ruby 1.8, but cost too much memory to run with Ruby 1.9/2.x

> There are several similar examples:
> 
> * Proc (proc and lambda)
> * Fiber (semi-coroutine and coroutine (after `Fiber#transfer`)

So this made me think of "Thread::Coro"

Other ideas:  Thread::CSP or Thread::Sequential (probably too long)

https://en.wikipedia.org/wiki/Coroutine
https://en.wikipedia.org/wiki/Communicating_sequential_processes

> Weak examples:
> * Hash (compare_by_identity)
> * Struct (keyword_init)
> * Enumerator (support size or not)

Maybe "Thread.sequential {}" is OK.

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>