Fun with Symbol#to

(This is a snapshot of my old weblog. New posts and selected republished essays can be found at raganwald.com.)

Tuesday, November 27, 2007

If you want a golden rule that will fit everything, this is it: Have nothing in your houses that you do not know to be useful or believe to be beautiful.

—William Morris

Most people love Symbol#to_proc sugar in Ruby:


%w[dsf fgdg fg].map(&:capitalize)
    → ["Dsf", "Fgdg", "Fg"]

And Googling around, all of the examples I could find were for unary methods like this. But what about binary methods like :merge? If Symbol#to_proc supported binary methods, you could do things like:


(1..5).inject &:+
    → 15

Or:


[{ :foo => 1 }, { :bar => 2 }, { :blitz => 3 }].inject &:merge
    → {:foo=>1, :bar=>2, :blitz=>3}

That would be brilliant.¹ And the implementation can’t be that hard in a language like Ruby, can it? Let’s have a look at the source code (I don’t have the Ruby 1.9 source, but I do have Symbol.rb from the Rails Core Extensions):


class Symbol
  # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
  #
  #   # The same as people.collect { |p| p.name }
  #   people.collect(&:name)
  #
  #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
  #   people.select(&:manager?).collect(&:salary)
  def to_proc
    Proc.new { |*args| args.shift.__send__(self, *args) }
  end
end

Would you look at that, Symbol#to_proc already handles methods with arguments. And indeed, the examples above work right out of the box in Rails. I expect them to work in Ruby 1.9 as well.

You still can’t do some of String#to_proc’s other point-free tricks like collection.map(&'*2'), but quite frankly this is a really nice feature that deserves more publicity. So… don’t forget that Symbol#to_proc handles your unary and binary methods.

Cheers!

I know what you’re thinking, but try to remember that the other meaning of the word “brilliant” is shiny and sparkling.

p.s. You’re wondering where I get the time to think up stuff like this? Actually, I’m lucky enough use stuff like this for a living. I needed to fold a collection of hashes together, and my first thought was that I’d like to write .inject(&:merge) to do it. This is the principle of least astonishment in action…

Labels: ruby

¶ 8:52 PM

Comments on “Fun with Symbol#to_proc”:

In Ruby 1.8.6 a second set of parentheses is needed:
(1..5).inject(&:+)
at least in the rails console.

And in irb none of your examples work...

I guess active support is helping you out here.

# posted by

InternetFred : 3:20 AM

Oh, you said rails core extensions. Still, my rails console is apparently different from yours.

My rails version is 1.2.4.

# posted by

InternetFred : 3:23 AM

In plain ruby 1.8.5 (1..5).inject &:+ works in a script but irb needs (1..5).inject(&:+). Guess irb parses differently.

# posted by

Magnus : 6:57 AM

<< Home