Passando um método como parâmetro em Ruby

Estou tentando mexer um pouco com Ruby. Para tanto procuro implementar os algoritmos (dados em Python) do livro "Programming Collective Intelligence" Ruby.

No capítulo 8 o autor passa um método a como parâmetro. Isso parece funcionar em Python, mas não em Ruby.

Eu tenho aqui o método

def gaussian(dist, sigma=10.0)
  foo
end

e deseja chamar isso com outro método

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

Tudo que eu tenho é um erro

ArgumentError: wrong number of arguments (0 for 1)

Você quer um 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

Apenas observe que você não pode definir um argumento padrão em uma declaração de bloco como essa. Portanto, você precisa usar um splat e configurar o padrão no próprio código proc.

Ou, dependendo do escopo de tudo isso, pode ser mais fácil passar um nome de método.

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

Nesse caso, você está apenas chamando um método definido em um objeto, em vez de passar um pedaço completo de código. Dependendo de como você estrutura isso, você pode precisar substituir self.sendporobject_that_has_the_these_math_methods.send

Por último, mas não menos importante, você pode suspender um bloco do 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

Mas parece que você gostaria de pedaços de código mais reutilizáveis ​​aqui.

Os comentários referentes a blocos e Procs estão corretos por serem mais usuais em Ruby. Mas você pode passar um método, se quiser. Você chama methodpara obter o método e .callchamá-lo:

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

Você pode passar um método como parâmetro com method(:function)way. Abaixo está um exemplo muito simples:

def double (a)
  retornar a * 2 
fim
=> nulo

def method_with_function_as_param (callback, número) 
  callback.call (número) 
fim 
=> nulo

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

A maneira normal do Ruby de fazer isso é usar um bloco.

Então, seria algo como:

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

E usado como:

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

Este padrão é usado extensivamente em Ruby.

Você pode usar o &operador na Methodinstância do seu método para converter o método em um bloco .

Exemplo:

def foo(arg)
  p arg
end

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

bar(&method(:foo))

Mais detalhes em http://weblog.raganwald.com/2008/06/what-does-do-when-used-as-unary.html

Você deve chamar o método "call" do objeto de função:

weight = weightf.call( dist )

EDITAR: conforme explicado nos comentários, essa abordagem está errada. Funcionaria se você estiver usando Procs em vez de funções normais.

Eu recomendaria usar o e comercial para ter acesso a blocos nomeados dentro de uma função. Seguindo as recomendações fornecidas neste artigo, você pode escrever algo assim (este é um recado real do meu programa de trabalho):

  # 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

Depois de responder, você pode chamar essa função assim:

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

Se você não precisa filtrar sua seleção, simplesmente omite o bloco:

@categories = make_select_list( Category ) # selects all categories

Tanto para o poder dos blocos Ruby.

você também pode usar "eval" e passar o método como um argumento de string e, em seguida, simplesmente evalá-lo no outro método.