Können Sie Argumente für die Map-Syntax (&: method) in Ruby angeben?

Sie kennen wahrscheinlich die folgende Ruby-Kurzform ( aist ein Array):

a.map(&:method)

Versuchen Sie beispielsweise Folgendes in irb:

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

Die Syntax a.map(&:class)ist eine Abkürzung für a.map {|x| x.class}.

Weitere Informationen zu dieser Syntax finden Sie unter " Was bedeutet map (&: name) in Ruby? ".

Über die Syntax führen &:classSie classfür jedes Array-Element einen Methodenaufruf durch.

Meine Frage ist: Können Sie dem Methodenaufruf Argumente liefern? Und wenn ja, wie?

Wie konvertieren Sie beispielsweise die folgende Syntax?

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

zur &:Syntax?

Ich behaupte nicht, dass die &:Syntax besser ist. Ich interessiere mich nur für die Mechanik der Verwendung der &:Syntax mit Argumenten.

Ich nehme an, Sie wissen, dass dies +eine Methode für die Integer-Klasse ist. Sie können Folgendes in irb versuchen:

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

Sie können einen einfachen Patch Symbolwie folgt erstellen :

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

Damit können Sie nicht nur Folgendes tun:

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

Aber auch viele andere coole Sachen, wie das Übergeben mehrerer 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] 

Und sogar arbeiten mit inject, was zwei Argumente an den Block übergibt:

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

Oder etwas super Cooles wie das Übergeben von [Kurzschrift] -Blöcken an den Kurzschriftblock:

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

Hier ist ein Gespräch mit @ArupRakshit, in dem es näher erläutert wird:
Können Sie der Map-Syntax (&: method) in Ruby Argumente liefern?

Wie @amcaplan im folgenden Kommentar vorgeschlagen hat , können Sie eine kürzere Syntax erstellen, wenn Sie die withMethode in umbenennen call. In diesem Fall verfügt Ruby über eine integrierte Verknüpfung für diese spezielle Methode .().

Sie können also Folgendes wie folgt verwenden:

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

Für Ihr Beispiel kann getan werden 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)> 

So funktioniert es: -

[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(:+)gibt ein MethodObjekt. Dann &, auf 2.method(:+), tatsächlich eine Anruf - #to_procMethode, die es macht ein ProcObjekt. Folgen Sie dann Wie nennt man den Operator &: in Ruby? .

Wie der Beitrag, auf den Sie verlinkt haben, bestätigt, a.map(&:class)ist dies keine Abkürzung für, a.map {|x| x.class}sondern für a.map(&:class.to_proc).

Dies bedeutet, dass to_procalles aufgerufen wird, was dem &Operator folgt .

Sie können es also direkt Proceingeben:

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

Ich weiß, dass dies höchstwahrscheinlich den Zweck Ihrer Frage zunichte macht, aber ich kann keinen anderen Weg sehen - es ist nicht so, dass Sie angeben, welche Methode aufgerufen werden soll, sondern nur etwas übergeben, auf das geantwortet wird to_proc.

Kurze Antwort: Nein.

Nach der Antwort von @ rkon können Sie auch Folgendes tun:

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

Anstatt die Kernklassen wie in der akzeptierten Antwort selbst zu patchen, ist es kürzer und sauberer, die Funktionalität des Facetten-Edelsteins zu verwenden :

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

Es gibt eine andere native Option für Aufzählungen, die meiner Meinung nach nur für zwei Argumente hübsch ist. Die Klasse Enumerablehat die Methode, with_objectdie dann eine andere zurückgibtEnumerable .

Sie können also den &Operator für eine Methode mit jedem Element und dem Objekt als Argumente aufrufen .

Beispiel:

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

Wenn Sie mehr Argumente wollen, sollten Sie den Vorgang wiederholen, aber meiner Meinung nach ist es hässlich:

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

Ich bin mir nicht sicher über das Symbol#withbereits Gepostete, ich habe es ziemlich vereinfacht und es funktioniert gut:

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

(verwendet auch public_sendanstatt sendzu verhindern, dass private Methoden aufgerufen werden, wird auch callerbereits von Ruby verwendet, so dass dies verwirrend war)