Forum: Ruby RCR Opinion Poll

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2007-01-19 16:31
(Received via mailing list)
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
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2007-09-25 22:33
(Received via mailing list)
On 1/12/07, Alexandru E. Ungur <alexandru@globalterrasoft.ro> 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",
1fba4539b6cafe2e60a2916fa184fc2f?d=identicon&s=25 unknown (Guest)
on 2007-09-25 22:34
(Received via mailing list)
Hi --

On Fri, 12 Jan 2007, Robert Dober 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
703fbc991fd63e0e1db54dca9ea31b53?d=identicon&s=25 Robert Dober (Guest)
on 2007-09-25 22:39
(Received via mailing list)
On 1/12/07, dblack@wobblini.net <dblack@wobblini.net> 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 (http://www.manning.com/black)
>     (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 ;)
ty for your time I will not file a RCR of course :(

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
1fba4539b6cafe2e60a2916fa184fc2f?d=identicon&s=25 unknown (Guest)
on 2007-09-25 22:41
(Received via mailing list)
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 :-)

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
0ec4920185b657a03edf01fff96b4e9b?d=identicon&s=25 Yukihiro Matsumoto (Guest)
on 2007-09-25 22:46
(Received via mailing list)
Hi,

In message "Re: RCR Opinion Poll"
    on Fri, 12 Jan 2007 18:56:08 +0900, "Robert Dober"
<robert.dober@gmail.com> 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.
245cfab887781bdf3f53178b794c42dc?d=identicon&s=25 Alexandru E. Ungur (Guest)
on 2007-09-25 22:46
(Received via mailing list)
>
>   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
This topic is locked and can not be replied to.