From: "alexeymuranov (Alexey Muranov)" <redmine@...>
Date: 2013-11-10T04:25:12+09:00
Subject: [ruby-core:58238] [ruby-trunk - Feature #9095] Allow	`Symbol#to_proc` to take arguments


Issue #9095 has been updated by alexeymuranov (Alexey Muranov).


=begin
  Hanmac (Hans Mackowiak) wrote:
  > i did something similar to that there:
  > https://bugs.ruby-lang.org/issues/9076#note-9

Hans, your proposal does not look good to me.  IMO, it is strange to make symbols callable and it is strange to add to the responsibilities of (({Symbol})) to maintain some (({SymbolHelper})), which looks to me more like a (({ProcBuilder})).  Also, using (({method_missing})) is always a bit scary to me.

You seem to propose, instead of

  [1, 10, 100].map{|x| x.to_s.length.to_f } # => [1.0, 2.0, 3.0]

to write

  [1, 10, 100].map &:to_s.call.length.to_f  # => [1.0, 2.0, 3.0]

At least i would have called this method (({#to_symbol_helper})) instead of (({#call})).

As (({#method_missing})) will not catch call of (({#to_proc})), there will be inevitably exceptions to the general rule:

  [1, 2, 3].map{|i| i.method(:**).to_proc.call(2) } # => [1, 4, 9]
  [1, 2, 3].map &:method.(:**).to_proc.call(2)      # => [2, 4, 8]

If we did not care about such ambiguities, i might have proposed something like this:

  class ProcFromCallsBuilder < BasicObject
    def initialize(&block)
      @proc = block
    end

    def call(*a, &b)
      @proc[*a, &b]
    end

    alias [] call

    def to_proc
      @proc
    end

    def method_missing(m, *args, &block)
      if @proc.nil?
        ::Module.nesting.first.new do |x|
          x.public_send(m, *args, &block)
        end
      else
        ::Module.nesting.first.new do |x|
          @proc[x].public_send(m, *args, &block)
        end
      end
    end
  end

  A = ProcFromCallsBuilder.new

  p [1, 10, 100].map &A.to_s.length.to_f # => [1.0, 2.0, 3.0]
=end
----------------------------------------
Feature #9095: Allow `Symbol#to_proc` to take arguments
https://bugs.ruby-lang.org/issues/9095#change-42828

Author: alexeymuranov (Alexey Muranov)
Status: Open
Priority: Normal
Assignee: 
Category: 
Target version: 


=begin
After discussing #9076, i've decided to propose this:

  class Symbol
    def to_proc(*args)
      proc do |x|
        x.public_send(self, *args)
      end
    end
  end

  p = :+.to_proc(1)

  p[2] # => 3

  [1, 2, 3, 4].map &:to_s.to_proc(2) #=> ["1", "10", "11", "100"]

This would allow constructing more kinds of procs without using literal blocks.
=end


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