Przekazywanie metody jako parametru w Ruby

Question

Próbuję trochę pomieszać z Ruby. Dlatego próbuję implementować algorytmy (podane w Pythonie) z książki "Programowanie Kolektywnej Inteligencji" Ruby.

W rozdziale 8 autor podaje metodę a jako parametr. To wydaje się działać w Pythonie, ale nie w Ruby.

Mam tu metoda

def gaussian(dist, sigma=10.0) 
    foo 
end 

i chcesz się połączyć to z innej metody

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

Wszystko co mam to błąd

ArgumentError: wrong number of arguments (0 for 1) 

Answer 1

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

Wystarczy pamiętać, że nie można ustawić domyślny argument w deklaracji bloku takiego. Musisz więc użyć splat i ustawić domyślną wartość w samym kodzie proc.

---

Lub, w zależności od zakresu tego wszystkiego, może być łatwiej podać zamiast nazwy 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ć kompletny fragment kodu. W zależności od tego, jak zorganizować to może trzeba wymienić self.send z object_that_has_the_these_math_methods.send

---

Last but not least, można powiesić zablokować metody.

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 

Wygląda na to, że chciałbyś otrzymać więcej fragmentów kodu wielokrotnego użytku.

Answer 2

Trzeba wywołać metodę "wywołanie" obiektu funkcji:

weight = weightf.call(dist) 

EDYCJA: jak wyjaśniono w komentarzach, podejście to jest niewłaściwe. Będzie działał, jeśli używasz Proc, zamiast normalnych funkcji.

Answer 3

Normalnym sposobem Ruby jest użycie bloku.

Więc byłoby 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 wzór jest szeroko stosowane w Ruby.

Answer 4

Komentarze odnoszące się do bloków i Procs są poprawne, ponieważ są bardziej typowe w Ruby. Ale możesz przekazać metodę, jeśli chcesz.Nazywasz method dostać się sposobu i .call to nazwać:

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

Answer 5

można przekazać metodę jako parametr z method(:function) sposób. Poniżej prosty przykład:

 
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

Polecam używanie ampersand, aby uzyskać dostęp do nazwanych bloków w ramach funkcji. Zgodnie z zaleceniami podanymi w this article można napisać coś takiego (to jest prawdziwy złom 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żna wywołać tę funkcję tak:

@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 

Tyle o mocy bloków rubinu.

Answer 7

Można użyć operatora & na wystąpienie metodę Method do konwertować metodę bloku.

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

Answer 8

można również skorzystać z "eval" i przekazać metodę jako argument łańcuch, a następnie po prostu eval go w inny sposób.