Meneruskan metode sebagai parameter di Ruby

Saya mencoba mengotak-atik Ruby. Untuk itu saya mencoba mengimplementasikan algoritma (diberikan dengan Python) dari buku "Programming Collective Intelligence" Ruby.

Dalam bab 8, penulis menggunakan metode a sebagai parameter. Ini sepertinya bekerja dengan Python tetapi tidak di Ruby.

Saya memiliki metode di sini

def gaussian(dist, sigma=10.0)
  foo
end

dan ingin menyebutnya dengan metode lain

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

Yang saya dapatkan hanyalah kesalahan

ArgumentError: wrong number of arguments (0 for 1)

Anda menginginkan objek 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

Perhatikan saja bahwa Anda tidak dapat menyetel argumen default dalam deklarasi blok seperti itu. Jadi Anda perlu menggunakan percikan dan mengatur default di kode proc itu sendiri.

Atau, bergantung pada cakupan semua ini, mungkin lebih mudah untuk meneruskan nama metode sebagai gantinya.

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

Dalam hal ini Anda hanya memanggil metode yang didefinisikan pada sebuah objek daripada mengirimkan potongan kode lengkap. Tergantung pada bagaimana Anda menyusun ini, Anda mungkin perlu mengganti self.senddenganobject_that_has_the_these_math_methods.send

Last but not least, Anda dapat menggantung satu blok dari metode ini.

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

Tapi sepertinya Anda ingin potongan kode yang lebih dapat digunakan kembali di sini.

Komentar yang merujuk pada blok dan Procs benar karena lebih umum di Ruby. Tapi Anda bisa melewatkan metode jika Anda mau. Anda memanggil methoduntuk mendapatkan metode dan .callmenyebutnya:

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

Anda bisa melewatkan metode sebagai parameter dengan method(:function)cara. Di bawah ini adalah contoh yang sangat sederhana:

def ganda (a)
  mengembalikan * 2 
akhir
=> nihil

def method_with_function_as_param (panggilan balik, angka) 
  callback.call (nomor) 
akhir 
=> nihil

method_with_function_as_param (metode (: ganda), 10) 
=> 20

Cara biasa Ruby untuk melakukan ini adalah dengan menggunakan blok.

Jadi itu akan menjadi seperti ini:

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

Dan digunakan seperti:

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

Pola ini digunakan secara luas di Ruby.

Anda dapat menggunakan &operator pada Methodcontoh metode Anda untuk mengubah metode menjadi blok .

Contoh:

def foo(arg)
  p arg
end

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

bar(&method(:foo))

Detail lebih lanjut di http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html

Anda harus memanggil metode "panggilan" dari objek fungsi:

weight = weightf.call( dist )

EDIT: seperti yang dijelaskan di komentar, pendekatan ini salah. Ini akan berfungsi jika Anda menggunakan Procs daripada fungsi normal.

Saya akan merekomendasikan untuk menggunakan ampersand untuk memiliki akses ke blok bernama dalam suatu fungsi. Mengikuti rekomendasi yang diberikan dalam artikel ini Anda dapat menulis sesuatu seperti ini (ini adalah potongan nyata dari program kerja saya):

  # 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

Selanjutnya, Anda dapat memanggil fungsi ini seperti ini:

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

Jika Anda tidak perlu memfilter pilihan Anda, Anda cukup menghilangkan pencekalan:

@categories = make_select_list( Category ) # selects all categories

Begitu hebatnya kekuatan blok Ruby.

Anda juga bisa menggunakan "eval", dan meneruskan metode sebagai argumen string, lalu cukup evaluasi di metode lain.