Ruby'de harita (&: method) sözdizimine argümanlar sağlayabilir misiniz?

Muhtemelen aşağıdaki Ruby kısaltmasına aşinasınız ( abir dizidir):

a.map(&:method)

Örneğin, irb'de şunu deneyin:

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

Sözdizimi a.map(&:class), için bir kısaltmadır a.map {|x| x.class}.

Bu sözdizimi hakkında daha fazlasını " harita (&: ad) Ruby'de ne anlama geliyor? " Bölümünde okuyun .

Sözdizimi aracılığıyla, her dizi öğesi için &:classbir yöntem çağrısı yaparsınız class.

Sorum şu: yöntem çağrısına argümanlar sağlayabilir misiniz? Ve eğer öyleyse, nasıl?

Örneğin, aşağıdaki sözdizimini nasıl dönüştürürsünüz?

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

için &:sözdizimi?

Ben demiyorum &:sözdizimi iyidir. Yalnızca &:sözdizimini argümanlarla kullanmanın mekaniğiyle ilgileniyorum .

Bunun +Integer sınıfında bir yöntem olduğunu bildiğinizi varsayıyorum . Aşağıdakileri irb'de deneyebilirsiniz:

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

Bunun Symbolgibi basit bir yama oluşturabilirsiniz :

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

Bu sadece bunu yapmanıza olanak sağlamaz:

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

Ancak, birden çok parametreyi iletmek gibi diğer pek çok harika şey:

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] 

Ve hatta injectbloğa iki argüman ileten ile çalışın :

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

Veya [steno] blokları stenografi bloğuna geçirmek kadar harika bir şey :

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

İşte @ArupRakshit ile bunu daha ayrıntılı açıklayan bir konuşma
: Ruby'de harita (&: method) sözdizimi için argümanlar sağlayabilir misiniz?

@ Amcaplan'ın aşağıdaki yorumda önerdiği gibi , withyöntemi olarak yeniden adlandırırsanız daha kısa bir sözdizimi oluşturabilirsiniz call. Bu durumda, Ruby'nin bu özel yöntem için yerleşik bir kısayolu vardır .().

Yani yukarıdakileri şu şekilde kullanabilirsiniz:

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

Örneğiniz için yapılabilir 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)> 

Şu şekilde çalışır: -

[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(:+)bir Methodnesne verir . Sonra &, 2.method(:+)aslında #to_proconu bir Procnesne yapan bir çağrı yöntemi . Daha sonra Ruby'de &: operatörüne ne diyorsunuz? .

Bağlandığınız gönderi onayladığı gibi a.map(&:class), bunun için bir kısaltma değil a.map {|x| x.class}ama için a.map(&:class.to_proc).

Bu to_proc, &operatörü izleyen ne olursa olsun çağrıldığı anlamına gelir .

Böylece doğrudan Procyerine verebilirsiniz :

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

Muhtemelen bunun sorunuzun amacını bozduğunu biliyorum, ancak bunun başka bir yolunu göremiyorum - bu, hangi yöntemin çağrılacağını belirlemeniz değil, sadece yanıt veren bir şeyi iletirsiniz to_proc.

Kısa cevap: Hayır.

@ Rkon'un cevabını takiben, bunu da yapabilirsiniz:

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

Bence sadece iki argüman için güzel olan numaralandırılabilir başka bir yerel seçenek var. sınıf Enumerable, with_objectdaha sonra başka bir döndüren yönteme sahiptir Enumerable.

Böylece &, her öğe ve nesnenin bağımsız değişken olduğu bir yöntem için operatörü çağırabilirsiniz .

Misal:

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

Daha fazla argüman istiyorsanız, süreci tekrarlamalısınız ama bence bu çirkin:

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

Kabul edilen yanıtta olduğu gibi çekirdek sınıflarını kendiniz yamamak yerine, Facets geminin işlevselliğini kullanmak daha kısa ve daha temizdir :

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

Symbol#withGönderilenlerden emin değilim , biraz basitleştirdim ve iyi çalışıyor:

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

(ayrıca özel yöntemlerin çağrılmasını önlemek public_sendyerine kullanır send, ayrıca callerRuby tarafından zaten kullanılıyor, bu yüzden bu kafa karıştırıcıydı)