RCR Opinion Poll

Ruby
1

Hi all

there is one thing concerning enumerations I really would like to file a
CR
about. But I guess it is necessary to open my ears and listen to your
POVs
before doing so. I believe that similar things are already done in lots
of
extension libraries like e.g. facet.

The most concerning thing is that there will probably be no consensus
about
the magic dot notation, I know this has been discussed before.

Here we go

Potential RCR, opinions wanted

The following is a very common pattern.

an_enum.map{ |ele| ele.a_method }

I believe that it is sufficiently common to be generalized.

There are two idioms I would like to see

an_enum.apply_to_all :a_method
and
an_enum.apply_to_all.a_method

the mutating version should also be available

an_enum.apply_to_all! :a_method
and
an_enum.apply_to_all!.a_method

Reference Implementation:

module Enumerable

def apply_to_all(method = nil)
    return ApplicationProxy.new( self, :modify => false ) unless

method
map { |ele| ele.send method }
end #def apply_to_all(method = nil)

def apply_to_all!(method = nil)
    return ApplicationProxy.new( self, :modify => true ) unless

method
map! { |ele| ele.send method }
end #def apply_to_all(method = nil)

class ApplicationProxy
    def initialize( enumerable, modifications = {} )
        @modify = modifications[ :modify ]
        @target = enumerable
    end
    def method_missing name, *args, &blk
        @modify ?
            @target.map!{ |ele| ele.send( name, *args, &blk ) } :
            @target.map{ |ele| ele.send( name, *args, &blk ) }
    end
end #class ApplicationProxy

end #class Enumeration

Ty in advance

Robert

2

On 1/12/07, Alexandru E. Ungur [email protected] wrote:

There are two idioms I would like to see

an_enum.apply_to_all :a_method

Ok, I’m still a newbie, but why not extend map instead of introducing a
new method? As in:

Sure a possibility, I personally like it - even with the magic dot
notation
(map.capitalize is also a possibility)
if I recall correctly the map extension idea was rather badly seen the
last
time, so I did not think about it anymore.
Thank you for the input.

%w[apples oranges kiwi].map :capitalize  # => ["Apples", "Oranges",
3

Hi –

On Fri, 12 Jan 2007, Robert D. wrote:

Concerning the old RCRs that are not part of the new site (there are only
two RCR if I am not mistaken) is there any way to put them?
Can I help?

You can look at them for reference, but for 2.0 development Matz has
asked that RCRs be resubmitted individually based on the new version
of the site and the process.

David

4

On 1/12/07, [email protected] [email protected] wrote:

being more generalized. & invokes to_proc on its operand; and to_proc

–
Q. What is THE Ruby book for Rails developers?
A. RUBY FOR RAILS by David A. Black (Ruby for Rails)
(See what readers are saying! http://www.rubypal.com/r4rrevs.pdf)
Q. Where can I get Ruby/Rails on-site training, consulting, coaching?
A. Ruby Power and Light, LLC (http://www.rubypal.com)

Matz, David

I knew about the &: kludge - I really hate it - but I did not know about
the
rejected RCR.
That’s why I asked :wink:
ty for your time I will not file a RCR of course :frowning:

Concerning the old RCRs that are not part of the new site (there are
only
two RCR if I am not mistaken) is there any way to put them?
Can I help?

Cheers
Robert

5

Hi,

In message “Re: RCR Opinion Poll”
on Fri, 12 Jan 2007 18:56:08 +0900, “Robert D.”
[email protected] writes:

|The following is a very common pattern.
|
| an_enum.map{ |ele| ele.a_method }
|
|I believe that it is sufficiently common to be generalized.
|
|There are two idioms I would like to see
|
| an_enum.apply_to_all :a_method
|and
| an_enum.apply_to_all.a_method

an_enum.map(&:a_method) works for 1.9.

          matz.
6

Hi –

On Fri, 12 Jan 2007, Alexandru E. Ungur wrote:

an_enum.apply_to_all :a_method

Ok, I’m still a newbie, but why not extend map instead of introducing a
new method? As in:

%w[apples oranges kiwi].map :capitalize # => [“Apples”, “Oranges”, “Kiwi”]

Still feels like the good old “map” and acts like it…

I know it’s sometimes hard to dig up the old RCRs (this one goes back
two incarnations) but that was rejected; see
http://oldrcrs.rubypal.com/rejected.html#rcr50.

The discussion for that RCR included:

  • the suggestion of map(&:meth)
  • using “apply” instead of “map” as the name
  • rejection by Matz :slight_smile:

The reason for rejection was: “It’s too functional so that I’m afraid
it would not work well with OO nature of Ruby. Maybe it’s matter of
notation.”

Ruby 1.9 has the map(&:meth) notation. I’m not its biggest fan
(mostly on aesthetic/visual grounds), but it has the advantage of
being more generalized. & invokes to_proc on its operand; and to_proc
for symbols is defined as:

lambda {|e| e.send(self) }

There’s a lot you have to “just know” to grasp what map(&:meth) is
doing, but basically it does this same thing of distributing a
symbolically-identified method across an enumerable.

David

7

an_enum.apply_to_all :a_method

Ok, I’m still a newbie, but why not extend map instead of introducing a
new method? As in:

%w[apples oranges kiwi].map :capitalize  # => ["Apples", "Oranges",

“Kiwi”]

Still feels like the good old “map” and acts like it…

Here’s my naive implementation, that produced the result above:

class Array
alias :old_map :map

def map(arg = nil, &block)
if block
old_map &block
elsif ! arg.nil?
if arg.is_a?(Symbol)
old_map {|x| x.send(arg)}
else
raise ArgumentError, “Don’t know how to handle #{arg.class}
arguments”
end
else
raise ArgumentError, “No parameter and no block given!”
end
end
end

All the best,
Alex