operator - operador ternario ruby

¿Cómo funciona el operador.() De Ruby?

Question

Hace poco encontré un código usando una llamada a método que consiste en el object.(arg1, arg2) formato object.(arg1, arg2) sin ver una buena explicación de cómo funciona. Vea este código de muestra:

class TestServiceObject
  def call
    ''method''
  end
end

TestServiceObject.new.()
# => ''method''

¿Cuál es el término para este tipo de taquigrafía?

Answer 1

La notación punto-paréntesis es una forma abreviada de pasar argumentos al método de call implícita en un objeto Ruby:

foo = lambda {|bar| puts bar}

foo.call(''baz'')
#=> baz
foo.(''baz'')

foo.call(''baz'') === foo.(''baz'')
#=> true

También tenga en cuenta que las siguientes notaciones también son válidas (y equivalentes) invocaciones del método de call :

foo[''baz'']
#=> baz
foo::(''baz'')
#=> baz

En su ejemplo, está anulando explícitamente el método de call en la clase TestServiceObject modo que devuelva la cadena ''method'' cuando se TestServiceObject . En consecuencia, puede anular explícitamente el método de call para aceptar argumentos:

class TestServiceObject
  def call(foo=nil)
    foo || ''method''
  end
end

TestServiceObject.new.()
#=> method
TestServicesObject.new.(''bar'')
#=> bar

ACTUALIZAR :

Tal @LoganSerman señala el comentarista @LoganSerman , el operador de taquigrafía parece trabajar en cualquier cosa que responda a la call , lo que se valida en parte con el siguiente ejemplo:

m = 12.method("+")

m.call(3)
#=> 15
m.(3)
#=> 15

ACTUALIZACIÓN 2 :

Como comenta el comentarista @Stefan también de la documentación en Proc#call :

prc. () invoca prc.call () con los parámetros dados. Es un azúcar de sintaxis para ocultar "llamada".

Answer 2

obj.(args) es solo una característica proporcionada a través del analizador. No es técnicamente un alias, pero simplemente tiene el mismo efecto que invocar obj.call(args) en un objeto que define el método de call .

Answer 3

foo.(bar, baz)

se interpreta como

foo.call(bar, baz)

al igual que

foo + bar

se interpreta como

foo.+(bar)

o

foo[bar, baz] = quux

se interpreta como

foo.[]=(bar, baz, quux)

La intención es hacer que los objetos similares a funciones de llamada se vean similares a los métodos de llamada:

foo.(bar, baz) # function
foo(bar, baz)  # method

A pesar de las afirmaciones en otras respuestas a esta pregunta, no tiene nada que ver con un "método de call implícita" (Ruby ni siquiera tiene métodos implícitos, solo Scala lo hace) o el operador de indexación.

El operador de indexación se traduce en una llamada a método diferente ( [] ) y no en una llamada a call :

o = Object.new

def o.call(*args); "`call` called with #{args.join('', '')}" end

o.(42)
# => "`call` called with 42"

o[42]
# NoMethodError: undefined method `[]'' for #<Object:0xdeadbeefc0ffee>

def o.[](*args);   "`[]` called with #{args.join('', '')}"   end

o[42]
# => "`[]` called with 42"