Can you deal with Ruby's method like functional programming, such as memoizing a function?

You can alias the original method and add a simple caching to original implementation.

class Fib def fib(n) case when n < 0 then 0 when n == 0 then 1 else fib(n-1) + fib(n-2) end end end puts Benchmark.measure { p Fib.new.fib(35) } class Fib alias_method :fib_ori, :fib def fib(n) (@fib_cache ||= {})[n] ||= fib_ori(n) end end puts Benchmark.measure { p Fib.new.fib(35) } 

Similar to sschmeck's solution, but via inheritance:

class Fibonacci def at(n) return 0 if n < 0 return 1 if n == 0 return at(n - 1) + at(n - 2) end end class MemoizedFibonacci < Fibonacci def initialize @memo = {} end def at(n) @memo[n] ||= super end end 

Module#prepend was added in Ruby 2+ specifically in because it can (among other things) act as a method combinator/decorator similar to CLOS or Python. In that way, you don't actually need to get access to the method itself, you can just override it.

class Module def memoize(meth) prepend(Module.new do memo = {} define_method(meth) do |*args, &blk| memo[[self, *args, blk]] ||= super(*args, &blk) end end) end end class Integer memoize def fib raise ArgumentError if self < 0 return self if self < 2 pred.fib + pred.pred.fib end end require 'benchmark' puts Benchmark.measure { p 42.fib } 

In older versions of Ruby (1.9 or older), you would have to do something like this:

class Module def memoize(meth) memo = {} old_meth = instance_method(meth) define_method(meth) do |*args, &blk| memo[[self, *args, blk]] ||= old_meth.bind(self).(*args, &blk) end end end 

Also, def evaluating to a Symbol denoting the name of the method being defined was added in Ruby 2.2, so, in older versions, you have to do this instead:

class Integer def fib raise ArgumentError if self < 0 return self if self < 2 pred.fib + pred.pred.fib end memoize :fib end 

We could use a trick such as the one Rake uses for its desc method, though, to make it memoize the next method being defined:

class Module def memoize(meth=nil) return @__memoize_next_method__ = true unless meth memo = {} old_meth = instance_method(meth) define_method(meth) do |*args, &blk| memo[[self, *args, blk]] ||= old_meth.bind(self).(*args, &blk) end end def method_added(meth) return if @__recursing__ @__recursing__ = true # protect against infinite recursion if @__memoize_next_method__ memoize(meth) @__memoize_next_method__ = nil end @recursing = nil end end class Integer memoize def fib raise ArgumentError if self < 0 return self if self < 2 pred.fib + pred.pred.fib end end