Ruby to_proc hack con enlace

Question

Estoy tratando de crear un pequeño hacha de Ruby para hacer algo así como el reverso del Symbol # to_proc hack. Mientras que el hack símbolo # to_proc lo hace posible:

some_array.each(&:some_method) 

es lo mismo que

some_array.each { |obj| obj.some_method } 

Quiero que esto sea posible:

some_array.each(&[:some_method]) 

sería el mismo que

some_array.each { |obj| some_method(obj) } 

El problema es que a menos que some_method es un método kernel, lo que realmente significaría es:

some_array.each { |obj| self.some_method(obj) } 

Cuando un bloque se pasa de forma explícita, se ha creado dentro de la unión donde se escribe esta línea, por lo que la auto accesos correctamente las obras objeto y todo actuales multa. Sin embargo, si el bloque se crea en el método to_proc de la matriz, el self está dentro del enlace Array (y se refiere a la matriz en sí). Tal vez no sea posible hacer lo que estoy tratando de hacer, pero me encantaría algunas ideas de la comunidad.

Aquí está mi truco hasta el momento. Esto funciona siempre y cuando el método es un método de núcleo, y está disponible dentro de la agrupación:

class Array 
    def to_proc 
    lambda {|i| send(self.first, i)} 
    end 
end 

Con este truco, funciona de esta línea, y pone las tres símbolos:

[:foo, :bar, :bas].each(&[:puts]) 

Es útil para mí ya, porque a menudo me encuentro queriendo inspeccionar una variedad de objetos ActiveRecord dentro de la consola y me ahorra tipear {| i | pone i}. Pero sería aún más útil poder usarlo dentro de los objetos para que se llame a algún método dentro del objeto con cada elemento de la matriz pasado como parámetro.

¿Alguna idea de cómo hacer que funcione el enlace?

Por favor, no responda con "no quiere hacer esto porque hará que las cosas funcionen más despacio" o "no está guardando tantos caracteres escribiendo, pero hace que el código sea menos legible" - - Ya sé estas cosas. :) Esto es más una especie de hack de alimentación de mi curiosidad. Me pregunto si es posible.

Answer 1

Usted está buscando el método llamado method :)

class Example 
    def some(arg) 
    p arg.size # just as a demo 
    end 
end 

obj = Example.new 
%w{the quick brown fox jumps over the lazy dog}.each(&obj.method(:some)) 

produce

3 
5 
5 
3 
5 
4 
3 
4 
3 

Answer 2

Aquí hay otra forma de hacerlo sin utilizar el método method() :). Utiliza un bloque para capturar el enlace y luego invoca el método relevante en el self del enlace.

class Object 
    def apply &block 
     b = eval('self', block.binding) 
     lambda { |param| b.send block.call, param } 
    end 
end 


# use like this: 
[1, 2, 3, 4].each &apply { :puts } 

output: 1 
     2 
     3 
     4 

Answer 3

Aunque Adrian tiene la idea correcta allí con el uso del método method, puede simplificar esto una paso más allá:

# Works on any generic method 
%w{the quick brown fox jumps over the lazy dog}.each(&method(:foo)) 

def foo(arg) 
    p arg.size 
end 

# Works on user-defined methods, too 
%w{the quick brown fox jumps over the lazy dog}.each(&method(:puts)) 

En lugar de crear una semántica incómoda con la introducción de Array # to_proc, ¿por qué no simplemente escribir sus propios métodos Enumerables que le hacen la vida más fácil? Tal vez algo como esto:

module Enumerable 
    def pass_each(method_name) 
    each(&method(method_name.to_sym)) 
    end 
end 

%w{the quick brown fox jumps over the lazy dog}.pass_each(:puts)