Pasando un método como parámetro en Ruby

Estoy tratando de jugar un poco con Ruby. Por eso trato de implementar los algoritmos (dados en Python) del libro "Programación de la inteligencia colectiva" 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 aqui el metodo

def gaussian(dist, sigma=10.0)
  foo
end

y quiero 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)

Quieres 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

Solo tenga en cuenta que no puede establecer un argumento predeterminado en una declaración de bloque como esa. Por lo tanto, debe usar un símbolo y configurar el valor predeterminado en el código de proceso.

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

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

En este caso, solo está llamando a un método que está definido en un objeto en lugar de pasar un fragmento completo de código. Dependiendo de cómo lo estructura, es posible que deba reemplazarlo self.sendconobject_that_has_the_these_math_methods.send

Por último, pero no menos importante, puede colgar un bloque 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 tener más fragmentos de código reutilizables aquí.

Los comentarios referentes a bloques y Procs son correctos en que son más habituales en Ruby. Pero puedes pasar un método si quieres. Llamas methodpara obtener el método y .callllamarlo:

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

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

def doble (a)
  devuelve un * 2 
final
=> nada

def method_with_function_as_param (devolución de llamada, número) 
  callback.call (número) 
final 
=> nada

método_con_función_como_param (método (: doble), 10) 
=> 20

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

Entonces sería algo como:

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

Y usado como:

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

Este patrón se usa ampliamente en Ruby.

Puede utilizar el &operador en la Methodinstancia de su método para convertir el método en 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

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 utiliza Procs en lugar de funciones normales.

Recomendaría usar ampersand para tener acceso a bloques con nombre dentro de una función. Siguiendo las recomendaciones dadas en este artículo , puede escribir algo como esto (esto es un fragmento real 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 así:

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

Si no necesita filtrar su selección, simplemente omita el bloque:

@categories = make_select_list( Category ) # selects all categories

Hasta aquí el poder de los bloques Ruby.

también puede usar "eval" y pasar el método como un argumento de cadena, y luego simplemente evaluarlo en el otro método.