Converting method to cached method

module Functional
  def memoize
    cache = {}
    lambda {|*args|
      # calculate value if not cached and cache it
      # remark: nils will be recalculated each time.
      cache[args] ||= self[*args]
    }
  end
end

class Method; include Functional; end

class Proc; include Functional; end

def fib(n)
  if n == 1 || n == 0
    1
  else
    fib(n-1) + fib(n-2)
  end
end

fib(30) # slow

a = method(:fib)

a.memoize.call(30) #still slow, but why?

#  
# we need to change all fib-calls to cached version of :fib 

# Let's see what we can do.

alias :old_fib :fib

def fib(n)
  @cache ||= {}
  @cache[n] ||= old_fib(n)
end

puts fib(100) # It's fast now!

# Let's write general purpose function

def make_cached_method(name)
  not_cached_name = (name.to_s + '_not_cached')
  # eval is not good but works
  eval "
    alias :#{not_cached_name} :#{name}
    def #{name}(*args)
      @cache ||= {}
      @cache[args] ||= #{not_cached_name}(*args)
    end
  "
end

make_cached_method(:fib)

puts fib(100) # It's fast too

# Now we need memoize! for Method
# Can you write the _right_ version of memoize! ?
# (notice, that method :replace is not available for Proc and Method objects)