Przekazywanie metody jako parametru w Rubim

Próbuję trochę pomieszać z Rubim. Dlatego staram się zaimplementować algorytmy (podane w Pythonie) z książki „Programming Collective Intelligence” Ruby.

W rozdziale 8 autor przekazuje metodę a jako parametr. Wydaje się, że działa to w Pythonie, ale nie w Rubim.

Mam tutaj metodę

def gaussian(dist, sigma=10.0)
  foo
end

i chcę to wywołać inną metodą

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

Mam tylko błąd

ArgumentError: wrong number of arguments (0 for 1)

Chcesz obiekt 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

Zwróć uwagę, że nie możesz ustawić domyślnego argumentu w takiej deklaracji bloku. Musisz więc użyć ikony i ustawić wartość domyślną w samym kodzie proc.

Lub, w zależności od zakresu tego wszystkiego, łatwiej będzie zamiast tego przekazać nazwę metody.

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

W tym przypadku po prostu wywołujesz metodę, która jest zdefiniowana na obiekcie, zamiast przekazywać cały fragment kodu. W zależności od tego, jak zorganizować to może trzeba wymienić self.sendzobject_that_has_the_these_math_methods.send

Wreszcie, możesz zawiesić blok na metodzie.

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

Ale wygląda na to, że chciałbyś mieć więcej fragmentów kodu wielokrotnego użytku tutaj.

Komentarze odnoszące się do bloków i procesów są poprawne, ponieważ występują częściej w Rubim. Ale możesz przekazać metodę, jeśli chcesz. Wołasz, methodaby pobrać metodę i .callwywołać ją:

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

Możesz przekazać metodę jako parametr ze method(:function)sposobem. Poniżej bardzo prosty przykład:

def podwójna (a)
  powrót a * 2 
koniec
=> zero

def metoda_with_function_as_param (oddzwonienie, numer) 
  callback.call (numer) 
koniec 
=> zero

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

Normalnym sposobem w Rubim jest użycie bloku.

Więc byłoby to coś takiego:

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

I używane jak:

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

Ten wzorzec jest szeroko stosowany w Rubim.

Możesz użyć &operatora w Methodwystąpieniu swojej metody, aby przekonwertować metodę na blok .

Przykład:

def foo(arg)
  p arg
end

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

bar(&method(:foo))

Więcej szczegółów na http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html

Musisz wywołać metodę „call” obiektu funkcji:

weight = weightf.call( dist )

EDYCJA: jak wyjaśniono w komentarzach, to podejście jest błędne. To zadziała, jeśli używasz Procs zamiast normalnych funkcji.

Zalecałbym użycie znaku ampersand, aby mieć dostęp do nazwanych bloków w ramach funkcji. Postępując zgodnie z zaleceniami podanymi w tym artykule możesz napisać coś takiego (to jest prawdziwa notka z mojego programu roboczego):

  # 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, możesz wywołać tę funkcję w ten sposób:

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

Jeśli nie musisz filtrować swojego wyboru, po prostu pomiń blok:

@categories = make_select_list( Category ) # selects all categories

To tyle, jeśli chodzi o moc bloków Ruby.

możesz także użyć "eval" i przekazać metodę jako argument typu string, a następnie po prostu evalować ją w innej metodzie.