Rubino: il modo migliore per tornare diversi metodi come procs da un modulo

Question

E 'abbastanza facile per restituire un metodo come un proc da un modulo:

module Foo 
    def self.bar 
    # Method implementation 
    end 

    def self.baz 
    # Method implementation 
    end 

    def self.qux 
    # Method implemenatation 
    end 

    def self.zoo 
    # Method implementation 
    end 
end 

Foo.method(:bar) # Returns a proc object 

Ma cosa succede se voglio tornare più di un (ma non tutti) metodo dallo stesso modulo? Un modo per farlo è: [:bar,:baz].inject([]) {|memo,i| memo << Foo.method(i)}

Esiste un modo migliore, più agile per fare lo stesso?

Answer 1

È sempre possibile utilizzare scimmia patch per far sembrare tuttavia si desidera:

class Object 
    def get_methods(*methods) 
    methods.map { |m| method(m) } 
    end 
end 


module Foo 
    def self.bar 
    # Method implementation 
    end 

    def self.baz 
    # Method implementation 
    end 
end 

Foo.get_methods(:foo, :baz) 

Answer 2

Prova questo:

Foo.methods(false).map {|e| Foo.method(e)} 

Foo.methods(false) torneranno tutti i metodi della classe che sono non ereditata come un array e map sarà iterazioni su ogni elemento.

EDIT

Dopo aver preso in considerazione i commenti qui sotto:

proc_arr = [:bar, :baz].map {|e| Foo.method(e)} 

Answer 3

Non so se c'è un modo migliore, ma forse questo è un po 'più pulita rispetto la vostra soluzione:

proc_methods = [] 
# => [] 
(Foo.methods - Object.methods).each { |m| proc_methods << Foo.method(m) } 
# => [:bar, :baz] 
proc_methods 
# => [#<Method: Foo.bar>, #<Method: Foo.baz>] 

Foo eredita i metodi da Object classe, cioè la cartella predefinita di tutto il rubino ob jects. (http://ruby-doc.org/core-2.2.3/Object.html)

Con Foo.methods - Object.methods si mantengono solo i metodi personalizzati.