您可以在Ruby中为map（＆：method）语法提供参数吗？

您可能熟悉以下Ruby速记（a是一个数组）：

a.map(&:method)

例如，在irb中尝试以下操作：

>> a=[:a, 'a', 1, 1.0]
=> [:a, "a", 1, 1.0]
>> a.map(&:class)
=> [Symbol, String, Fixnum, Float]

语法a.map(&:class)是的简写a.map {|x| x.class}。

在“ Ruby中的map（＆：name）意味着什么？ ”中阅读有关此语法的更多信息。

通过语法&:class，您可以class对每个数组元素进行方法调用。

我的问题是：您可以为方法调用提供参数吗？如果是这样，怎么办？

例如，如何转换以下语法

a = [1,3,5,7,9]
a.map {|x| x + 2}

在&:语法？

我并不是说&:语法更好。我只对将&:语法与参数结合使用的机制感兴趣。

我假设您知道这+是Integer类上的方法。您可以在irb中尝试以下操作：

>> a=1
=> 1
>> a+(1)
=> 2
>> a.send(:+, 1)
=> 2

您可以Symbol像这样创建一个简单的补丁：

class Symbol
  def with(*args, &block)
    ->(caller, *rest) { caller.send(self, *rest, *args, &block) }
  end
end

这不仅使您能够做到这一点：

a = [1,3,5,7,9]
a.map(&:+.with(2))
# => [3, 5, 7, 9, 11] 

还有很多其他很酷的东西，例如传递多个参数：

arr = ["abc", "babc", "great", "fruit"]
arr.map(&:center.with(20, '*'))
# => ["********abc*********", "********babc********", "*******great********", "*******fruit********"]
arr.map(&:[].with(1, 3))
# => ["bc", "abc", "rea", "rui"]
arr.map(&:[].with(/a(.*)/))
# => ["abc", "abc", "at", nil] 
arr.map(&:[].with(/a(.*)/, 1))
# => ["bc", "bc", "t", nil] 

甚至可以使用inject，它将两个参数传递给该块：

%w(abecd ab cd).inject(&:gsub.with('cde'))
# => "cdeeecde" 

或将[shorthand]块传递给速记块，这很酷：

[['0', '1'], ['2', '3']].map(&:map.with(&:to_i))
# => [[0, 1], [2, 3]]
[%w(a b), %w(c d)].map(&:inject.with(&:+))
# => ["ab", "cd"] 
[(1..5), (6..10)].map(&:map.with(&:*.with(2)))
# => [[2, 4, 6, 8, 10], [12, 14, 16, 18, 20]] 

这是我与@ArupRakshit进行的一次对话，进一步说明了这一点：
能否在Ruby中为map（＆：method）语法提供参数？

如@amcaplan在下面的注释中建议的那样，如果将with方法重命名为，则可以创建较短的语法call。在这种情况下，ruby对此特殊方法具有内置的快捷方式.()。

因此，您可以像这样使用上面的代码：

class Symbol
  def call(*args, &block)
    ->(caller, *rest) { caller.send(self, *rest, *args, &block) }
  end
end

a = [1,3,5,7,9]
a.map(&:+.(2))
# => [3, 5, 7, 9, 11] 

[(1..5), (6..10)].map(&:map.(&:*.(2)))
# => [[2, 4, 6, 8, 10], [12, 14, 16, 18, 20]] 

为您的例子可以做到a.map(&2.method(:+))。

Arup-iMac:$ pry
[1] pry(main)> a = [1,3,5,7,9]
=> [1, 3, 5, 7, 9]
[2] pry(main)> a.map(&2.method(:+))
=> [3, 5, 7, 9, 11]
[3] pry(main)> 

下面是它的工作原理 ：-

[3] pry(main)> 2.method(:+)
=> #<Method: Fixnum#+>
[4] pry(main)> 2.method(:+).to_proc
=> #<Proc:0x000001030cb990 (lambda)>
[5] pry(main)> 2.method(:+).to_proc.call(1)
=> 3

2.method(:+)给一个Method对象。然后 &，在上2.method(:+)，实际上是一个调用#to_proc方法，该方法使它成为一个Proc对象。然后遵循您在Ruby中如何称呼＆：运算符？。

正如您链接到的帖子所确认的那样，a.map(&:class)不是的简写，a.map {|x| x.class}而是的简写a.map(&:class.to_proc)。

这意味着将to_proc在&运算符后面的任何位置调用。

因此，您可以直接给它一个Proc：

a.map(&(Proc.new {|x| x+2}))

我知道这很可能违反了您的问题的目的，但是我看不到其他解决方法-不是您指定要调用的方法，而是将响应的内容传递给它to_proc。

简短答案：不可以。

按照@rkon的回答，您也可以执行以下操作：

a = [1,3,5,7,9]
a.map &->(_) { _ + 2 } # => [3, 5, 7, 9, 11]

不用像在公认的答案中那样自己修补核心类，而是使用Facets gem的功能更短，更简洁：

require 'facets'
a = [1,3,5,7,9]
a.map &:+.(2)

在我看来，可枚举还有另一个本机选项，仅适用于两个参数。该类Enumerable具有方法with_object，该方法然后返回另一个Enumerable。

因此，您可以&为每个项目和对象作为参数的方法调用运算符。

例：

a = [1,3,5,7,9]
a.to_enum.with_object(2).map(&:+) # => [3, 5, 7, 9, 11]

如果您想要更多参数，则应重复此过程，但我认为这很丑陋：

a = [1,3,5,7,9]
a.to_enum.with_object(2).map(&:+).to_enum.with_object(5).map(&:+) # => [8, 10, 12, 14, 16]

我不确定Symbol#with已经发布的内容，我对其进行了简化，并且效果很好：

class Symbol
  def with(*args, &block)
    lambda { |object| object.public_send(self, *args, &block) }
  end
end

（也用于public_send代替send防止调用私有方法，也caller已被ruby使用，因此令人困惑）