functor 0.5.1 → 0.6.0

data/lib/functor.rb

@@ -1,72 +1,102 @@
-require "#{File.dirname(__FILE__)}/object"
-
 class Functor
   
+  class NoMatch < ArgumentError; end
+  
+  def self.cache_config(options={})
+    (@cache_config ||= { :size => 4_096, :base => 8 }).merge!(options)
+  end
+  
   module Method
-    def self.copy_functors( functors )
-      r = {} ; functors.each do | name, functor |
-        r[ name ] = functor.clone
-      end
-      return r
-    end
+    
     def self.included( k )
-      def k.functors
-        @__functors ||= superclass.respond_to?( :functors ) ? 
-          Functor::Method.copy_functors( superclass.functors ) : {}
+            
+      def k.functor_cache
+        @functor_cache ||= Hash.new { |hash, key| hash[key] = [ {},{},{},{} ] }
+      end
+      
+      def k.functor_cache_config(options={})
+        @functor_cache_config = ( @functor_cache_config || Functor.cache_config ).merge(options)
+      end
+      
+      def k.functor( name, *pattern, &action )
+        _functor( name, false, *pattern, &action)
       end
-      def k.functor( name, *args, &block )
-        name = name.to_sym
-        ( f = ( functors[ name ] or 
-          ( functors[ name ] = Functor.new ) ) ).given( *args, &block )
-        define_method( name ) { | *args | instance_exec( *args, &f.match( *args ) ) } 
+      
+      def k.functor_with_self( name, *pattern, &action )
+        _functor( name, true, *pattern, &action)
       end
-      def k.functor_with_self( name, *args, &block )
-        name = name.to_sym
-        ( f = ( functors[ name ] or 
-          ( functors[ name ] = Functor.new ) ) ).given( *args, &block )
-        define_method( name ) { | *args | instance_exec( *args, &f.match( self, *args ) ) } 
+      
+      # undefined methods beginning with '_' can be used as wildcards in Functor patterns
+      def k.method_missing(name, *args)
+        args.empty? && name.to_s =~ /^_/  ?  lambda { |args| true }  :  super
       end
+      
+      private
+      
+      def k._functor( name, with_self=false, *pattern, &action)
+        name = name.to_s
+        mc = functor_cache[name]  # grab the cache tiers for The Method
+        cache_size, cache_base = functor_cache_config[:size], functor_cache_config[:base]
+        c0_size, c1_size, c2_size, c3_size = cache_size * 4, cache_size * 3, cache_size * 2, cache_size
+        c1_thresh,c2_thresh,c3_thresh = cache_base.to_i, (cache_base ** 2).to_i, (cache_base ** 3).to_i
+        old_method = instance_method(name) if method_defined?( name ) # grab The Method's current incarnation        
+        define_method( name, action ) # redefine The Method
+        newest = instance_method(name) # grab newly redefined The Method
+        
+        # Recursively redefine The Method using the newest and previous incarnations
+        define_method( name ) do | *args |
+          match_args = with_self ? [self] + args : args
+          sig = match_args.hash
+          if meth = mc[3][sig]  # check caches from top down
+            meth[0].bind(self).call(*args)
+          elsif meth = mc[2][sig]
+            meth[1] += 1  # increment hit count
+            mc[3][sig] = mc[2].delete(sig) if meth[1] > c3_thresh # promote sig if it has enough hits
+            (mc[0], mc[1], mc[2], mc[3] = mc[1], mc[2], mc[3], {}) if mc[3].size >= c3_size # cascade if c3 is full
+            meth[0].bind(self).call(*args)
+          elsif meth = mc[1][sig]
+            meth[1] += 1
+            mc[2][sig] = mc[1].delete(sig) if meth[1] > c2_thresh
+            mc[0], mc[1], mc[2] = mc[1], mc[2], {} if mc[2].size >= c2_size
+            meth[0].bind(self).call(*args)
+          elsif meth = mc[0][sig]
+            meth[1] += 1
+            mc[1][sig] = mc[0].delete(sig) if meth[1] > c1_thresh 
+            mc[0], mc[1] = mc[1], {} if mc[1].size >= c1_size
+            meth[0].bind(self).call(*args)
+          elsif Functor.match?(match_args, pattern) # not cached?  Try newest meth/pat.
+            (mc[0], mc[1], mc[2], mc[3] = mc[1], mc[2], mc[3], {})  if mc[3].size >= c3_size
+            mc[3][sig] = [newest, 0]  # methods are cached as [ method, counter ]
+            newest.bind(self).call(*args)
+          elsif old_method  # or call the previous incarnation of The Method
+            old_method.bind(self).call(*args)
+          else  # and if there are no older incarnations, whine about it
+            raise NoMatch.new( "No functor matches the given arguments for method :#{name}." )
+          end
+        end 
+      end
+      
     end
   end
   
-  
   def initialize( &block )
-    @rules = [] ; yield( self ) if block_given?
-  end
-  
-  def initialize_copy( from )
-    @rules = from.instance_eval { @rules.clone }
+    class << self; include Functor::Method; end
+    yield( self ) if block_given?
   end
   
   def given( *pattern, &action )
-    @rules << [ pattern, action ]
+    (class << self; self; end)._functor( "call", false, *pattern, &action)
   end
   
-  def call( *args, &block )
-    match( *args, &block ).call( *args )
-  end
-  
-  def []( *args, &block )
-    call( *args, &block )
-  end
+  def []( *args, &block ); call( *args, &block ); end
   
-  def to_proc ; lambda { |*args| self.call( *args ) } ; end
+  def to_proc ; lambda { |*args| call( *args ) } ; end
     
-  def match( *args, &block )
-    args << block if block_given?
-    pattern, action = @rules.reverse.find { | p, a | match?( args, p ) }
-    action or 
-      raise ArgumentError.new( "Argument error: no functor matches the given arguments." )
-  end
-  
-  private
-  
-  def match?( args, pattern )
-    args.zip( pattern ).all? { | arg, rule | pair?( arg, rule ) } if args.length == pattern.length
-  end
-  
-  def pair?( arg, rule )
-    ( rule.respond_to? :call and rule.call( arg ) ) or rule === arg
+  def self.match?( args, pattern )
+    args.all? do |arg|
+      pat = pattern[args.index(arg)]
+      pat === arg || ( pat.respond_to?(:call) && pat.call(arg))
+    end if args.length == pattern.length
   end
     
 end

data/metrics/benchmark.rb

@@ -0,0 +1,39 @@
+require 'rubygems'
+
+$:.unshift "#{here = File.dirname(__FILE__)}/stevedore/lib"
+$:.unshift "#{here}/../lib"
+require 'stevedore'
+require 'functor'
+
+
+class FuncFib < Steve
+  
+  subject "Fibonacci using Functor"
+  
+  # power 0.8
+  # sig_level 0.05
+  delta 0.01
+  
+  before do
+    @fib ||= Functor.new do |f|
+      f.given( Integer ) { | n | f.call( n - 1 ) + f.call( n - 2 ) }
+      f.given( 0 ) { 0 }
+      f.given( 1 ) { 1 }
+    end
+  end
+end
+
+fib_8 = FuncFib.new "f(8)" do  
+  measure do
+    64.times { @fib.call(8) }
+  end
+end
+
+fib_16 = FuncFib.new "f(16)" do  
+  measure do
+    2.times { @fib.call(16)  }
+  end
+end
+
+# FuncFib.recommend_test_size( 8, 16)
+FuncFib.compare_instances( 8, 128)

data/metrics/helpers.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+
+$:.unshift "#{here = File.dirname(__FILE__)}/stevedore/lib"
+$:.unshift "#{here}/../lib"
+require 'stevedore'
+require 'functor'

data/metrics/many_args.rb

@@ -0,0 +1,71 @@
+require "#{here = File.dirname(__FILE__)}/helpers"
+
+class A
+  include Functor::Method
+  functor( :foo, 1, 2, 3, 4, 5, 6, 7 )                { |*x| "ints" }
+  functor( :foo, :a, :b, :c, :d, :e, :f, :g )         { |*x| "symbols" }
+  functor( :foo, *%w{ a b c d e f g } )               { |*x| "strings" }
+  functor( :foo, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 )  { |*x| "floats" }
+  functor( :foo, *Array.new(7, "one") )               { |*x| "ones" }
+end
+
+class Native
+  def foo(*args)
+    case args
+    when [1, 2, 3, 4, 5, 6, 7]
+      "ints"
+    when [:a, :b, :c, :d, :e, :f, :g]
+      "symbols"
+    when %w{ a b c d e f g }
+      "strings"
+    when [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0]
+      "floats"
+    when Array.new(7, "one")
+      "ones"
+    else
+      raise ArgumentError
+    end
+  end
+end
+
+class ManyArgs < Steve
+end
+
+ManyArgs.new "native method" do
+  before do
+    @args = [
+      [1, 2, 3, 4, 5, 6, 7],
+      [:a, :b, :c, :d, :e, :f, :g],
+      %w{ a b c d e f g },
+      [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0],
+      Array.new(7, "one")
+      ]
+    @n = Native.new
+  end
+  measure do
+    400.times do
+      @args.each { |args| @n.foo *args }
+    end
+  end
+end
+
+
+ManyArgs.new "functor method" do
+  before do
+    @args = [
+      [1, 2, 3, 4, 5, 6, 7],
+      [:a, :b, :c, :d, :e, :f, :g],
+      %w{ a b c d e f g },
+      [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0],
+      Array.new(7, "one")
+      ]
+    @a = A.new
+  end
+  measure do
+    400.times do
+      @args.each { |args| @a.foo *args }
+    end
+  end
+end
+
+ManyArgs.compare_instances( 4, 64)

data/metrics/one_arg.rb

@@ -0,0 +1,61 @@
+require "#{here = File.dirname(__FILE__)}/helpers"
+
+class A
+  include Functor::Method
+  functor_cache_config :size => 700, :base => 6
+  
+  functor( :foo, Integer ) { |x| :integer }
+  functor( :foo, String )  { |x| :string }
+  functor( :foo, Float )   { |x| :float }
+  functor( :foo, Symbol )  { |x| :symbol }
+  functor( :foo, "one"  )  { |x| :one }
+end
+
+class Native
+  def foo(x)
+    case x
+    when Integer then :integer
+    when String then :string
+    when Float then :float
+    when Symbol then :symbol
+    when "one" then :one
+    else
+      raise ArgumentError
+    end
+  end
+end
+
+class OneArg < Steve
+  before do
+    nums = (1..200).to_a
+    alphas = ("a".."gr").to_a
+    @args_set = nums + nums.map { |i| i.to_f } + alphas + alphas.map { |i| i.to_sym } + Array.new(200, "one")
+    @args = []
+    srand(46)
+    9000.times { @args << @args_set[rand(@args_set.size)] }
+  end
+end
+
+OneArg.new "functor method" do
+  before_sample do
+    @a = A.new    
+  end
+  measure do
+    @args.each { |item| @a.foo item }
+  end
+  
+  after_sample do
+    puts A.functor_cache["foo"].map{ |c| c.size }.inspect
+  end
+end
+
+OneArg.new "native method" do
+  before_sample do
+    @n = Native.new
+  end
+  measure do
+    @args.each { |item| @n.foo item }
+  end
+end
+
+OneArg.compare_instances( 4, 96)

data/test/fib.rb

@@ -2,8 +2,8 @@ require "#{File.dirname(__FILE__)}/helpers"
 
 fib ||= Functor.new do |f|
   f.given( Integer ) { | n | f.call( n - 1 ) + f.call( n - 2 ) }
-  f.given( 0 ) { 0 }
-  f.given( 1 ) { 1 }
+  f.given( 0 ) { |x| 0 }
+  f.given( 1 ) { |x| 1 }
 end
 
 describe "Dispatch on a functor object should" do

data/test/functor.rb

@@ -6,23 +6,25 @@ class Repeater
   functor( :repeat, Integer ) { |x| x * @times }
   functor( :repeat, String ) { |s| [].fill( s, 0, @times ).join(' ') }
   functor( :repeat ) { nil }
+  functor( :distraction, Integer ) { |x| "Boo!" }
 end
 
 describe "Dispatch on instance method should" do
   
   before do
     @r = Repeater.new
-    @r.times = 5
+    @r.times = 3
   end
   
   specify "invoke different methods with object scope based on arguments" do
-    @r.repeat( 5 ).should == 25
-    @r.repeat( "-" ).should == '- - - - -'
+    @r.distraction( 5 )
+    @r.repeat( 5 ).should == 15
+    @r.repeat( "-" ).should == '- - -'
     @r.repeat.should == nil
   end
   
   specify "raise an exception if there is no matching value" do
-    lambda { @r.repeat( 7.3 ) }.should.raise(ArgumentError)
+    lambda { @r.repeat( 7.3 ) }.should.raise(Functor::NoMatch)
   end
 end
 

data/test/guards.rb

@@ -4,8 +4,8 @@ describe "Dispatch should support guards" do
   
   before do
     @stripe = Functor.new do |f|
-      f.given( lambda { |x| x % 2 == 1 } ) { 'silver' }
-      f.given( lambda { |x| x % 2 == 0 } ) { 'white' }
+      f.given( lambda { |x| x % 2 == 1 } ) { |x| 'silver' }
+      f.given( lambda { |x| x % 2 == 0 } ) { |x| 'white' }
     end
 
     @safe_divide = Functor.new do |f|

data/test/inheritance.rb

@@ -1,24 +1,29 @@
 require "#{File.dirname(__FILE__)}/helpers"
 
-class A
+class Parent
   include Functor::Method
-  functor( :foo, Integer ) { |x| [ A, Integer ] }
-  functor( :foo, String ) { |s| [ A, String ] }
-  functor( :foo, Float ) { |h| [ A, Float ] }
+  functor( :foo, Integer ) { |x| [ Parent, Integer ] }
+  functor( :foo, String ) { |s| [ Parent, String ] }
+  functor( :foo, Float ) { |h| [ Parent, Float ] }
 end
 
-class B < A
-  functor( :foo, String ) { |s| [ B, String ] }
+class Child < Parent
+  functor( :foo, String ) { |s| [ Child, String ] }
+  functor( :foo, Float ) { |x| super(x).reverse }
 end
 
 describe "Functor methods should support inheritance" do
   
   specify "by inheriting base class implementations" do
-    B.new.foo( 5 ).should == [ A, Integer ]
+    Child.new.foo( 5 ).should == [ Parent, Integer ]
   end
   
   specify "by allowing derived classes to override an implementation" do
-    B.new.foo( "bar" ).should == [ B, String ]
+    Child.new.foo( "bar" ).should == [ Child, String ]
+  end
+  
+  specify "by allowing #super" do
+    Child.new.foo(3.0).should == [ Float, Parent]
   end
   
 end

data/test/matchers.rb

@@ -1,6 +1,6 @@
 require "#{File.dirname(__FILE__)}/helpers"
 
-class C
+class Matchers
   include Functor::Method
   functor( :foo, Integer ) { |a| "===" }
   functor( :foo, 1 ) { |a| "==" }
@@ -10,15 +10,15 @@ end
 describe "Functors match" do
 
   specify "using ==" do
-    C.new.foo( 1 ).should == "=="
+    Matchers.new.foo( 1 ).should == "=="
   end
   
   specify "using ===" do
-    C.new.foo( 2 ).should == "==="
+    Matchers.new.foo( 2 ).should == "==="
   end
 
   specify "using #call" do
-    C.new.foo( "boo" ).should == "Lambda: boo"
+    Matchers.new.foo( "boo" ).should == "Lambda: boo"
   end
 
 end