Manière plus naturelle d'appeler Proc dans Ruby 1.9

Question

Comme nous le savons, il existe plusieurs façons d'appeler Proc dans Ruby 1.9

 f =->n {[:hello, n]}
 p f[:ruby]       # => [:hello, :ruby]
 p f.call(:ruby)  # => [:hello, :ruby]
 p f.(:ruby)      # => [:hello, :ruby]
 p f === :ruby    # => [:hello, :ruby]

Je suis curieux de savoir quelle est la manière la plus « naturelle » d'appeler Proc ?« Naturel » signifie probablement davantage d'une manière semblable à celle de l'informatique.

Answer 1

La deuxième option est de loin la plus utilisée.

p f.call(:ruby)  # => [:hello, :ruby]

Cela la rend plus similaire à une méthode standard.De plus, certaines bibliothèques s'appuient en fait sur le typage duck lors de la validation des arguments vérifiant la disponibilité du #call méthode.Dans ce cas, en utilisant #call garantit que vous pouvez fournir un lambda ou tout autre objet (y compris une classe) qui répond à #call.

Rack les middlewares sont un excellent exemple de cette convention.Le middleware de base peut être un lambda, ou vous pouvez fournir une logique plus complexe en utilisant des classes.

Answer 2

J'utilise toujours l'option 3. Considérant les ambiguïtés syntaxiques de pouvoir appeler des méthodes sans parenthèses, c'est le plus proche que vous puissiez accéder à la syntaxe d'appel de méthode réelle.

Answer 3

J'ai vu la première voie utilisée dans CASS DE RACK CODE SOURCE.Cela m'a confondu depuis longtemps.Il est cueilli de lib / rack / builder.rb ( version: 1.6.0.alpha )

module Rack
  class Builder
    ...

    def to_app
      app = @map ? generate_map(@run, @map) : @run
      fail "missing run or map statement" unless app

      # This is the first option calling a proc
      # @use is a array of procs (rack middleware)
      @use.reverse.inject(app) { |a,e| e[a] }
    end

    ...
  end
end