[ruby-core:39888] [Ruby 1.9 - Feature #5394][Open] Anonymous Symbols, Anonymous Methods

Issue #5394 has been reported by Kurt  Stephens.

----------------------------------------
Feature #5394: Anonymous Symbols, Anonymous Methods
http://redmine.ruby-lang.org/issues/5394

Author: Kurt  Stephens
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


Proposal for Anonymous Symbols and Anonymous Methods

Anonymous Methods (AnonMeths) can be used for complex orthogonal behaviors that dispatch by receiver class without patching core or other sensitive classes in a globally visible manner.
AnonMeths are located by Anonymous Symbols (AnonSyms).  
AnonSyms do not have parseable names, and can only be referenced by value, limiting namespace problems and promoting encapsulation.  
AnonMeths are GCed once the AnonSym bound to them are GCed.  
AnonMeths would not appear in Object#methods, thus will not confuse introspection.

Assume:

<pre><code class="ruby">
  Symbol.new() => #<Symbol:123412> # an AnonSymbol than can never be parsed in ruby code.
  anon_sym = Symbol.new() # an AnonSym in a variable that can be closed-over or passed by value.
</code></pre>

Optional Supporting Syntax:

<pre><code class="ruby">
  a.*anon_sym(args...) # equiv. to a.send(anon_sym, args...)
  class A
    def *anon_sym(args...); body...; end
  end
</code></pre>

equiv. to:

<pre><code class="ruby">
  class A
    define_method(anon_sym) {| args... | body... }
  end
</code></pre>

AnonSyms are not added directly to a Module's internal symbol-to-method table.
Instead, each AnonSym has an internal module-to-method table that is GCed when the AnonSym is GCed.  

<pre><code class="ruby">
  rcvr.send(anon_sym, ...) 
</code></pre>

will use anon_sym's module-to-method table to locate a method based on usual the receiver's module lookup chain.

Example Application:

Typical visitor pattern that pollutes Array and Object method namespaces:

<pre><code class="ruby">
  class Array;  def visit(visitor); each { | elem | elem.visit(visitor); } end; end
  class Object; def visit(visitor); visitor.something(self);               end; end
</code></pre>

Functional alternative using "case ...; when ...":

<pre><code class="ruby">
  def visit(obj, visitor)
    case obj
    when Array
      obj.each { | elem | visit(elem, visitor) }
    else
      visitor.something(obj)
    end
  end
</code></pre>

AnonMeth version:

<pre><code class="ruby">
  def visit(obj, visitor)
    sel = Symbol.new
    class Array;   def *sel(visitor); each { | elem | elem.*sel(visitor) }; end; end
    class Object;  def *sel(visitor); visitor.something(self);              end; end
    obj.*sel(visitor)
  end
</code></pre>

Imagine that visit() needs dynamic hooks to visit different types:

<pre><code class="ruby">
  def visit(obj, visitor)
    sel = Symbol.new
    class Array;   def *sel(visitor); each { | elem | elem.*sel(visitor) }; end; end
    class Object;  def *sel(visitor); visitor.something(self);              end; end
    add_visit_methods!(sel)
    obj.*sel(visitor)
  end
  def add_visit_methods!(sel)
    class Hash;    def *sel(visitor); each { | k, v | v.*sel(visitor);      end; end
    ...
  end
</code></pre>

The AnonSym send "rcvr.*sel(...)" dispatches, like a normal method send, directly to the appropriate AnonMeth for "*sel".
visit() can be extended dynamically by adding more AnonMeths bound to "*sel".  
The functional "case ...; when..." version is difficult to extend and maintain and is likely to not perform as well as anon messages.
This is similar in style to Scheme letrecs, but is object-oriented.

This idea could be extended to Anonymous Ivars to resolve other namespacing and encapsulation issues for mixins that require state.

-- Kurt Stephens




-- 
http://redmine.ruby-lang.org