Pasar un método como parámetro en Ruby

Question

Estoy tratando de perder el tiempo con Ruby. Por lo tanto, intento implementar los algoritmos (dados en Python) del libro "Programming Collective Intelligence" Ruby.

En el capítulo 8, el autor pasa un método a como parámetro. Esto parece funcionar en Python pero no en Ruby.

Tengo aquí el método

def gaussian(dist, sigma=10.0) 
    foo 
end 

y quieren llamar a esto con otro método

def weightedknn(data, vec1, k = 5, weightf = gaussian) 
    foo 
    weight = weightf(dist) 
    foo 
end 

Todo lo que tengo es un error

ArgumentError: wrong number of arguments (0 for 1) 

Answer 1

desea que un objeto proc:

gaussian = Proc.new do |dist, *args| 
    sigma = args.first || 10.0 
    ... 
end 

def weightedknn(data, vec1, k = 5, weightf = gaussian) 
    ... 
    weight = weightf.call(dist) 
    ... 
end 

Ten en cuenta que no se puede establecer un argumento predeterminado en una declaración el bloque de esa manera. Entonces necesita usar un splat y configurar el predeterminado en el código de proc mismo.

---

O, dependiendo del alcance de todo esto, puede ser más fácil pasar el nombre de un método en su lugar.

def weightedknn(data, vec1, k = 5, weightf = :gaussian) 
    ... 
    weight = self.send(weightf) 
    ... 
end 

En este caso son sólo llamar a un método que se define en un objeto en lugar de pasar en un trozo de código completa. Dependiendo de cómo se estructura este puede ser necesario reemplazar con self.sendobject_that_has_the_these_math_methods.send

---

Por último, pero no menos importante, se puede colgar un bloque fuera del método.

def weightedknn(data, vec1, k = 5) 
    ... 
    weight = 
    if block_given? 
     yield(dist) 
    else 
     gaussian.call(dist) 
    end 
    end 
    ... 
end 

weightedknn(foo, bar) do |dist| 
    # square the dist 
    dist * dist 
end 

Pero parece que le gustaría obtener más fragmentos de código reutilizables aquí.

Answer 2

Tienes que llamar al método "llamada" del objeto de función:

weight = weightf.call(dist) 

EDITAR: como se explica en los comentarios, este enfoque es incorrecto. Funcionaría si está utilizando Procs en lugar de funciones normales.

Answer 3

La forma normal de Ruby para hacer esto es usar un bloque.

Por lo tanto, sería algo así como:

def weightedknn(data, vec1, k = 5) 
    foo 
    weight = yield(dist) 
    foo 
end 

y usados ​​como:

weightenknn(data, vec1) { |dist| gaussian(dist) } 

Este patrón se utiliza ampliamente en Ruby.

Answer 4

Los comentarios referentes a bloques y Procs son correctos porque son más comunes en Ruby. Pero puede pasar un método si lo desea.Se llama a method para obtener el método y .call llamarlo:

def weightedknn(data, vec1, k = 5, weightf = method(:gaussian)) 
    ... 
    weight = weightf.call(dist) 
    ... 
end 

Answer 5

se puede pasar un método como parámetro con method(:function) manera. A continuación un ejemplo muy simple:

 
def double(a) 
    return a * 2 
end 
=> nil 

def method_with_function_as_param(callback, number) 
    callback.call(number) 
end 
=> nil 

method_with_function_as_param(method(:double) , 10) 
=> 20 

Answer 6

Recomendaría usar el signo & para tener acceso a los bloques con nombre dentro de una función. Siguiendo las recomendaciones dadas en this article se puede escribir algo como esto (esto es un verdadero pedazo de mi programa de trabajo):

# Returns a valid hash for html form select element, combined of all entities 
    # for the given +model+, where only id and name attributes are taken as 
    # values and keys correspondingly. Provide block returning boolean if you 
    # need to select only specific entities. 
    # 
    # * *Args* : 
    # - +model+ -> ORM interface for specific entities' 
    # - +&cond+ -> block {|x| boolean}, filtering entities upon iterations 
    # * *Returns* : 
    # - hash of {entity.id => entity.name} 
    # 
    def make_select_list(model, &cond) 
    cond ||= proc { true } # cond defaults to proc { true } 
    # Entities filtered by cond, followed by filtration by (id, name) 
    model.all.map do |x| 
     cond.(x) ? { x.id => x.name } : {} 
    end.reduce Hash.new do |memo, e| memo.merge(e) end 
    end 

Afterwerds, puede llamar a esta función como esta:

@contests = make_select_list Contest do |contest| 
    logged_admin? or contest.organizer == @current_user 
end 

Si no es necesario filtrar su selección, simplemente omite el bloque:

@categories = make_select_list(Category) # selects all categories 

Esto en cuanto a la potencia de ruby ​​bloques.

Answer 7

Usted puede utilizar el operador & en el Method instancia de su método para convertir el método a un bloque.

Ejemplo:

def foo(arg) 
    p arg 
end 

def bar(&block) 
    p 'bar' 
    block.call('foo') 
end 

bar(&method(:foo)) 

Más detalles en http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html

Answer 8

también se puede utilizar "eval", y aprobar el método como un argumento de cadena, y luego simplemente Eval en el otro método.