Bisakah Anda memberikan argumen ke sintaks map (&: method) di Ruby?

Anda mungkin sudah familiar dengan singkatan Ruby berikut ( ais an array):

a.map(&:method)

Misalnya, coba yang berikut ini di irb:

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

Sintaksnya a.map(&:class)adalah singkatan dari a.map {|x| x.class}.

Baca lebih lanjut tentang sintaks ini di " Apa arti map (&: name) di Ruby? ".

Melalui sintaks &:class, Anda membuat panggilan metode classuntuk setiap elemen array.

Pertanyaan saya adalah: dapatkah Anda memberikan argumen ke pemanggilan metode? Dan jika ya, bagaimana caranya?

Misalnya, bagaimana Anda mengonversi sintaks berikut

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

ke &:sintaks?

Saya tidak menyarankan bahwa &:sintaksnya lebih baik. Saya hanya tertarik pada mekanisme penggunaan &:sintaks dengan argumen.

Saya berasumsi Anda tahu itu +adalah metode pada kelas Integer. Anda dapat mencoba yang berikut di irb:

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

Anda dapat membuat tambalan sederhana Symbolseperti ini:

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

Yang akan memungkinkan Anda melakukan tidak hanya ini:

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

Tetapi juga banyak hal keren lainnya, seperti meneruskan beberapa parameter:

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] 

Dan bahkan bekerja dengan inject, yang meneruskan dua argumen ke blok:

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

Atau sesuatu yang sangat keren seperti meneruskan blok [singkatan] ke blok singkatan:

[['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]] 

Berikut adalah percakapan saya dengan @ArupRakshit yang menjelaskannya lebih lanjut:
Dapatkah Anda memberikan argumen ke sintaks map (&: method) di Ruby?

Seperti yang disarankan @amcaplan pada komentar di bawah , Anda dapat membuat sintaks yang lebih pendek, jika Anda mengganti nama withmetode menjadi call. Dalam hal ini, ruby ​​memiliki pintasan bawaan untuk metode khusus ini .().

Jadi Anda bisa menggunakan yang di atas seperti ini:

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]] 

Untuk contoh Anda bisa dilakukan 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)> 

Inilah cara kerjanya: -

[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(:+)memberikan sebuah Methodobjek. Kemudian &, pada 2.method(:+), sebenarnya #to_procmetode panggilan , yang membuatnya menjadi Procobjek. Kemudian ikuti Apa yang Anda sebut operator &: di Ruby? .

Seperti yang dikonfirmasi oleh postingan yang Anda tautkan, a.map(&:class)ini bukan singkatan a.map {|x| x.class}tapi untuk a.map(&:class.to_proc).

Ini berarti to_procdipanggil apapun yang mengikuti &operator.

Jadi Anda bisa memberikannya secara langsung sebagai Procgantinya:

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

Saya tahu bahwa kemungkinan besar ini mengalahkan tujuan pertanyaan Anda, tetapi saya tidak dapat melihat jalan lain - bukan karena Anda menentukan metode mana yang akan dipanggil, Anda hanya meneruskan sesuatu yang merespons to_proc.

Jawaban singkatnya: Tidak.

Mengikuti jawaban @ rkon, Anda juga bisa melakukan ini:

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

Alih-alih menambal kelas inti sendiri, seperti dalam jawaban yang diterima, lebih pendek dan lebih bersih untuk menggunakan fungsionalitas permata Facets :

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

Ada opsi asli lain untuk enumerables yang cukup hanya untuk dua argumen menurut saya. kelas Enumerablememiliki metode with_objectyang kemudian mengembalikan yang lain Enumerable.

Jadi Anda bisa memanggil &operator untuk metode dengan setiap item dan objek sebagai argumen.

Contoh:

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

Jika Anda menginginkan lebih banyak argumen, Anda harus mengulangi prosesnya tetapi menurut saya itu jelek:

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

Saya tidak yakin tentang yang Symbol#withsudah diposting, saya menyederhanakannya sedikit dan berfungsi dengan baik:

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

(juga menggunakan public_sendbukan senduntuk mencegah memanggil metode pribadi, juga callersudah digunakan oleh ruby jadi ini membingungkan)