Ruby: Why does this way of using map throw an error?

Question

I tried to shorten

values.map { |value| value.gsub!("\n", ' ') }

with

values.map(&:gsub!("\n", ' '))

but it gives me an:

SyntaxError:
...csv_creator.rb:40: syntax error, unexpected '(', expecting ')'
     values.map(&:gsub!("\n", ' '))

Anyone know what's going on?

Answer 1

&:method notation is using #to_proc method, which is capable of converting symbol to Proc object. It can't be used as a shortcut if you need to provide additional arguments to called method.

Longer explanation about #to_proc can be found in separate answer: What does to_proc method mean?

Answer 2

&:foo may erroneously be seen as &: plus foo (terms like "pretzel colon" reinforce this mistaken view). But no method foo is being called here. &:foo is actually & plus :foo, the latter being a plain symbol.

When calling a method, &object (without :) invokes object.to_proc (which is supposed to return a Proc) and passes the returned proc as a block argument to the method.

object often happens to be a symbol and Symbol#to_proc's implementation would look somehow like this in Ruby: (it's actually written in C)

class Symbol
  def to_proc
    proc { |object, *args| object.public_send(self, *args) }
  end
end

So this:

method(&:symbol)

effectively becomes this:

method { |object, *args| object.public_send(:symbol, *args) }

or, if method doesn't yield multiple values (like map), it's simply:

method { |object| object.public_send(:symbol) }

Obviously, you can't pass additional arguments via a symbol.

But ... object doesn't have to be a symbol. You could use another class with a custom to_proc implementation. Let's abuse Array for demonstration purposes:

class Array
  def to_proc
    method, *args = self
    proc { |obj| obj.public_send(method, *args) }
  end
end

This hack would allow you to write:

["foo\nbar", "baz\nqux"].map(&[:gsub, "\n", '-'])
#=> ["foo-bar", "baz-qux"]

Answer 3

Alternatives

String#methods

Just to show what could be done : you could define String methods without arguments.

class String
  def replace_newlines!(replace = ' ')
    gsub!("\n", replace)
  end

  def replace_newlines(replace = ' ')
    gsub("\n", replace)
  end
end

p new_values = values.map(&:replace_newlines)
#=> ["1 2", "a b"]

p values.each(&:replace_newlines!)
#=> ["1 2", "a b"]

Sadly, refinements wouldn't work with to_proc.

Proc

Another possibility would be to define a new Proc, without monkey-patching String :

my_gsub = proc { |string| string.gsub("\n", ' ') }
p new_values = values.map(&my_gsub)
#=> ["1 2", "a b"]

each/map/gsub/gsub!

Note that map doesn't make much sense when used with ! methods. You should either :

• use map with gsub
• or use each with gsub!