Чи можете ви надати аргументи до синтаксису map (&: method) у Ruby?

Ви, напевно, знайомі з такою стенограмою 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}.

Детальніше про цей синтаксис читайте у " Що означає карта (&: name) у Ruby? ".

Через синтаксис &: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" 

Або щось супер круто, як передача [стенограми] блоків до блоку скорочень:

[['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, пояснюючи це далі:
Чи можете ви надати аргументи до синтаксису map (&: method) у Ruby?

Як @amcaplan запропонував у коментарі нижче , ви можете створити коротший синтаксис, якщо перейменувати withметод на call. У цьому випадку рубін має вбудований ярлик для цього спеціального методу .().

Таким чином, ви можете використовувати вищезазначене так:

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 :

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, тому це було заплутано)