class Memoizer

Memoizer wraps objects to provide cached method calls.

class X
  def initialize ; @tick = 0 ; end
  def tick; @tick + 1; end
  def memo; @memo ||= Memoizer.new(self) ; end
end

x = X.new
x.tick       #=> 1
x.memo.tick  #=> 2
x.tick       #=> 3
x.memo.tick  #=> 2
x.tick       #=> 4
x.memo.tick  #=> 2

You can also use to cache collections of objects to gain code speed ups.

points = points.collect{|point| Memoizer.cache(point)}

After our algorithm has finished using points, we want to get rid of these Memoizer objects. That's easy:

points = points.collect{|point| point.__self__ }

Or if you prefer (it is ever so slightly safer):

points = points.collect{|point| Memoizer.uncache(point)}

Public Class Methods

cache(object) click to toggle source

def self; @self; end

# File lib/more/facets/memoizer.rb, line 55
def self.cache(object)
  new(object)
end
new(object) click to toggle source
# File lib/more/facets/memoizer.rb, line 41
def initialize(object)
  @self  = object
  @cache = {}
end
uncache(cached_object) click to toggle source
# File lib/more/facets/memoizer.rb, line 59
def self.uncache(cached_object)
  cached_object.instance_variable_get('@self')
end

Public Instance Methods

__self__() click to toggle source
# File lib/more/facets/memoizer.rb, line 46
def __self__ ; @self ; end
method_missing(method_name, *args, &block) click to toggle source

Not thread-safe! Speed is important in caches… ;]

# File lib/more/facets/memoizer.rb, line 49
def method_missing(method_name, *args, &block)
  @cache[[method_name, args, block]] ||= @self.__send__(method_name, *args, &block)
end