Pouvez-vous fournir des arguments à la syntaxe de la carte (méthode &:) dans Ruby?

Vous êtes probablement familier avec le raccourci Ruby suivant ( aest un tableau):

a.map(&:method)

Par exemple, essayez ce qui suit dans irb:

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

La syntaxe a.map(&:class)est un raccourci pour a.map {|x| x.class}.

En savoir plus sur cette syntaxe dans " Que signifie map (&: name) dans Ruby? ".

Grâce à la syntaxe &:class, vous effectuez un appel de méthode classpour chaque élément du tableau.

Ma question est: pouvez-vous fournir des arguments à l'appel de méthode? Et si oui, comment?

Par exemple, comment convertir la syntaxe suivante

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

à la &:syntaxe?

Je ne suggère pas que la &:syntaxe est meilleure. Je suis simplement intéressé par les mécanismes d'utilisation de la &:syntaxe avec des arguments.

Je suppose que vous savez que +c'est une méthode sur la classe Integer. Vous pouvez essayer ce qui suit dans irb:

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

Vous pouvez créer un patch simple Symbolcomme ceci:

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

Ce qui vous permettra de faire non seulement ceci:

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

Mais aussi beaucoup d'autres trucs sympas, comme passer plusieurs paramètres:

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] 

Et même travailler avec inject, qui passe deux arguments au bloc:

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

Ou quelque chose de super cool comme passer des blocs [sténographie] au bloc sténographique:

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

Voici une conversation que j'ai eue avec @ArupRakshit pour l'expliquer plus en détail:
Pouvez-vous fournir des arguments à la syntaxe de la carte (&: méthode) dans Ruby?

Comme @amcaplan l'a suggéré dans le commentaire ci - dessous , vous pouvez créer une syntaxe plus courte si vous renommez la withméthode en call. Dans ce cas, ruby ​​a un raccourci intégré pour cette méthode spéciale .().

Vous pouvez donc utiliser ce qui précède comme ceci:

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

Pour votre exemple peut être fait 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)> 

Voici comment cela fonctionne: -

[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(:+)donne un Methodobjet. Ensuite &, en 2.method(:+)fait, une #to_procméthode d' appel , qui en fait un Procobjet. Puis suivez Comment appelez-vous l'opérateur &: dans Ruby? .

Comme le message auquel vous avez lié le confirme, ce a.map(&:class)n'est pas un raccourci pour a.map {|x| x.class}mais pour a.map(&:class.to_proc).

Cela signifie qu'il to_procest appelé sur tout ce qui suit l' &opérateur.

Vous pouvez donc lui donner directement un à la Procplace:

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

Je sais que très probablement cela va à l'encontre du but de votre question, mais je ne vois pas d'autre solution - ce n'est pas que vous spécifiez la méthode à appeler, vous lui passez simplement quelque chose qui répond to_proc.

Réponse courte: Non.

Suite à la réponse de @ rkon, vous pouvez également faire ceci:

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

Au lieu de patcher vous-même les classes principales, comme dans la réponse acceptée, il est plus court et plus propre d'utiliser la fonctionnalité du gem Facets :

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

Il existe une autre option native pour les énumérables qui n'est jolie que pour deux arguments à mon avis. la classe Enumerablea la méthode with_objectqui en retourne une autre Enumerable.

Vous pouvez donc appeler l' &opérateur d'une méthode avec chaque élément et l'objet comme arguments.

Exemple:

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

Dans le cas où vous voudriez plus d'arguments, vous devriez répéter le processus mais c'est moche à mon avis:

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

Je ne suis pas sûr du Symbol#withdéjà posté, je l'ai un peu simplifié et ça marche bien:

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

(utilise également public_sendau lieu de sendpour empêcher d'appeler des méthodes privées, callerest également déjà utilisé par ruby, donc c'était déroutant)