Passaggio di un metodo come parametro in Ruby

Sto cercando di scherzare un po 'con Ruby. Per questo cerco di implementare gli algoritmi (forniti in Python) dal libro "Programming Collective Intelligence" Ruby.

Nel capitolo 8 l'autore passa un metodo a come parametro. Sembra funzionare in Python ma non in Ruby.

Ho qui il metodo

def gaussian(dist, sigma=10.0)
  foo
end

e vuoi chiamarlo con un altro metodo

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

Tutto quello che ho è un errore

ArgumentError: wrong number of arguments (0 for 1)

Vuoi un oggetto 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

Tieni presente che non puoi impostare un argomento predefinito in una dichiarazione di blocco come quella. Quindi è necessario utilizzare uno splat e impostare il valore predefinito nel codice proc stesso.

Oppure, a seconda della portata di tutto ciò, potrebbe essere più semplice passare invece un nome di metodo.

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

In questo caso stai solo chiamando un metodo definito su un oggetto invece di passare una porzione completa di codice. A seconda di come lo strutturi potresti dover sostituire self.sendconobject_that_has_the_these_math_methods.send

Ultimo ma non meno importante, puoi appendere un blocco al metodo.

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

Ma sembra che tu voglia più blocchi di codice riutilizzabili qui.

I commenti che si riferiscono a blocchi e Proc sono corretti in quanto sono più usuali in Ruby. Ma puoi passare un metodo se vuoi. Chiami methodper ottenere il metodo e .callper chiamarlo:

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

Puoi passare un metodo come parametro con method(:function)way. Di seguito è riportato un esempio molto semplice:

def double (a)
  restituire a * 2 
fine
=> zero

def method_with_function_as_param (callback, number) 
  callback.call (numero) 
fine 
=> zero

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

Il modo normale per fare ciò in Ruby è usare un blocco.

Quindi sarebbe qualcosa del tipo:

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

E usato come:

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

Questo modello è ampiamente utilizzato in Ruby.

È possibile utilizzare l' &operatore Methodsull'istanza del metodo per convertire il metodo in un blocco .

Esempio:

def foo(arg)
  p arg
end

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

bar(&method(:foo))

Maggiori dettagli su http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html

Devi chiamare il metodo "call" dell'oggetto funzione:

weight = weightf.call( dist )

EDIT: come spiegato nei commenti, questo approccio è sbagliato. Funzionerebbe se stai usando Procs invece delle normali funzioni.

Consiglierei di usare la e commerciale per avere accesso ai blocchi denominati all'interno di una funzione. Seguendo i consigli forniti in questo articolo puoi scrivere qualcosa del genere (questo è un vero frammento del mio programma di lavoro):

  # 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, puoi chiamare questa funzione in questo modo:

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

Se non è necessario filtrare la selezione, ometti semplicemente il blocco:

@categories = make_select_list( Category ) # selects all categories

Questo per quanto riguarda la potenza dei blocchi Ruby.

puoi anche usare "eval" e passare il metodo come argomento stringa, quindi semplicemente eval nell'altro metodo.