Bạn có thể cung cấp các đối số cho cú pháp map (&: method) trong Ruby không?

Có thể bạn đã quen thuộc với cách viết tắt của Ruby sau ( alà một mảng):

a.map(&:method)

Ví dụ, hãy thử những điều sau trong irb:

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

Cú pháp a.map(&:class)là cách viết tắt của a.map {|x| x.class}.

Đọc thêm về cú pháp này trong " Bản đồ (&: tên) có nghĩa là gì trong Ruby? ".

Thông qua cú pháp &:class, bạn đang thực hiện một cuộc gọi phương thức classcho mỗi phần tử mảng.

Câu hỏi của tôi là: bạn có thể cung cấp đối số cho phương thức gọi không? Và nếu vậy, làm thế nào?

Ví dụ, làm thế nào để bạn chuyển đổi cú pháp sau

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

với &:cú pháp?

Tôi không gợi ý rằng &:cú pháp tốt hơn. Tôi chỉ quan tâm đến cơ chế sử dụng &:cú pháp với các đối số.

Tôi giả sử bạn biết đó +là một phương thức trên lớp Integer. Bạn có thể thử các cách sau trong irb:

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

Bạn có thể tạo một bản vá đơn giản Symbolnhư sau:

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

Điều này sẽ cho phép bạn không chỉ làm điều này:

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

Nhưng cũng có rất nhiều thứ hay ho khác, như truyền nhiều tham số:

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] 

Và thậm chí làm việc với inject, chuyển hai đối số cho khối:

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

Hoặc điều gì đó cực kỳ thú vị như chuyển các khối [tốc ký] sang khối tốc ký:

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

Đây là cuộc trò chuyện tôi đã có với @ArupRakshit giải thích thêm về nó:
Bạn có thể cung cấp các đối số cho cú pháp map (&: method) trong Ruby không?

Như @amcaplan đã đề xuất trong nhận xét bên dưới , bạn có thể tạo một cú pháp ngắn hơn, nếu bạn đổi tên withphương thức thành call. Trong trường hợp này, ruby ​​đã tích hợp sẵn một phím tắt cho phương pháp đặc biệt này .().

Vì vậy, bạn có thể sử dụng ở trên như thế này:

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

Ví dụ của bạn có thể được thực hiện 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)> 

Đây là cách nó làm việc :-

[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(:+)đưa ra một Methodđối tượng. Sau đó &, trên 2.method(:+)thực tế là một #to_procphương thức gọi , làm cho nó trở thành một Procđối tượng. Sau đó làm theo Bạn gọi toán tử &: trong Ruby là gì? .

Khi bài đăng bạn liên kết để xác nhận, a.map(&:class)không phải là cách viết tắt a.map {|x| x.class}mà cho a.map(&:class.to_proc).

Điều này có nghĩa là nó to_procđược gọi trên bất cứ thứ gì theo sau &toán tử.

Vì vậy, bạn có thể cung cấp trực tiếp cho nó một Proc:

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

Tôi biết rằng hầu hết điều này có thể đánh bại mục đích câu hỏi của bạn nhưng tôi không thể thấy bất kỳ cách nào khác xung quanh nó - không phải là bạn chỉ định phương thức nào sẽ được gọi, bạn chỉ chuyển nó một cái gì đó phản hồi to_proc.

Câu trả lời ngắn gọn: Không.

Sau câu trả lời của @ rkon, bạn cũng có thể làm điều này:

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

Thay vì tự vá các lớp lõi, như trong câu trả lời được chấp nhận, việc sử dụng chức năng của đá quý Facets sẽ ngắn hơn và gọn gàng hơn :

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

Theo ý kiến ​​của tôi, có một tùy chọn gốc khác cho bảng liệt kê mà chỉ phù hợp với hai đối số. lớp Enumerablecó phương thức with_objectsau đó trả về một phương thức khác Enumerable.

Vì vậy, bạn có thể gọi &toán tử cho một phương thức với mỗi mục và đối tượng là các đối số.

Thí dụ:

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

Trong trường hợp bạn muốn có nhiều đối số hơn, bạn nên lặp lại quy trình nhưng theo tôi thì nó xấu:

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

Tôi không chắc về những gì Symbol#withđã được đăng, tôi đã đơn giản hóa nó một chút và nó hoạt động tốt:

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

(cũng sử dụng public_sendthay vì sendđể ngăn việc gọi các phương thức riêng tư, cũng callerđã được sử dụng bởi ruby ​​nên điều này gây nhầm lẫn)