Re: how about actors implemented in ruby-core itself

On Fri, 21 Sep 2007 07:44:43 +0900, SASADA Koichi <[e-mail]> wrote:
> Hi,
> 
> Wilson Bilkovich wrote:
>> Rubinius has Actor (implemented by MenTaLguY) as a core class. If ruby
>> 1.9.x wanted to add them as well, we would be more than happy to
>> conform to the API that was chosen. Right now we basically just have
>> Actor.spawn, Actor.receive, Actor#send, and Actor.current
> 
> Can I read spec or examples of Actor?

I can give you a very brief summary of the API:

 Actor.current # => actor

   Returns the current actor

 Actor.spawn { ... } # => actor

   Creates a new actor with the given body and returns it; in the
   current implementation, each actor gets its own Ruby thread, but
   this is not necessarily guaranteed.

 Actor#send(message) # => actor
 Actor#<<(message) # => actor

   Posts a message to an actor's mailbox

 Actor.receive # => message

   Retrieves the next available message from the current actor's
   mailbox, or blocks until a message is submitted by another
   actor.

 Actor.receive { |filter| ... } # => obj

   Retrieves the next available message from the current actor's
   mailbox which matches the filter configured in the block,
   or blocks until a matching message is submitted by another
   actor.  filter is a Mailbox::Filter, which is configured
   in the block.  This form of Actor.receive returns the result
   of the action-block associated with the first matching pattern.

 Mailbox::Filter#when(pattern) { |message| ... } # => self

   Adds a receive pattern for a message object; patterns are
   matched with messages using the === case-match operator.
   The action to associate with a pattern is given as a block.

Example:

  Exit = Object.new
  Print = Struct.new :text

  parent = Actor.current

  child = Actor.spawn do
    looping = true
    while looping
      Actor.receive do |filter|
        filter.when Print do |message|
          puts message.text
        end
        filter.when Exit do
          looping = false
          parent << Exit
        end
      end
    end
  end

  child << Print["foo"]
  child << Print["bar"]
  child << Print["hoge"]
  child << Exit

  # await Exit from child
  Actor.receive do |filter|
    filter.when(Exit) {}
  end

-mental