Maneira mais natural de chamar Proc em Ruby 1.9

Question

Como sabemos, existem várias maneiras de chamar Proc em 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]

Estou curioso, qual é a maneira mais 'natural' de chamar Proc?'Natural', provavelmente, significa mais como a Ciência da Computação.

Answer 1

A segunda opção é de longe a mais utilizada.

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

Isso o torna mais semelhante a um método padrão.Além disso, algumas bibliotecas realmente dependem da digitação duck ao validar argumentos, verificando a disponibilidade do #call método.Neste caso, usando #call garante que você possa fornecer um lambda ou qualquer outro objeto (incluindo uma classe) que responda a #call.

Rack middlewares são um ótimo exemplo dessa convenção.O middleware básico pode ser um lambda ou você pode fornecer uma lógica mais complexa usando classes.

Answer 2

Eu sempre uso a opção 3.Considerando as ambiguidades sintáticas de poder chamar métodos sem parênteses, este é o mais próximo que você pode chegar da sintaxe real de chamada de método.

Answer 3

Eu vi a primeira maneira usada em Prateleira Código fonte.Isso me confundiu há muito tempo.É escolhido de lib/rack/builder.rb (versão:1.6.0.alfa)

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