README
test/supplement.rb
test/wildcard.rb
@@ -2,71 +2,103 @@ 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
\ No newline at end of file
lib/functor.rb
@@ -68,4 +68,4 @@ ManyArgs.new "functor method" do
end
end
-ManyArgs.compare_instances( 16, 32)
\ No newline at end of file
+ManyArgs.compare_instances( 4, 64)
\ No newline at end of file
metrics/many_args.rb
@@ -2,6 +2,8 @@ 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 }
@@ -24,30 +26,36 @@ class Native
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 "native method" do
- before do
- @n = Native.new
+OneArg.new "functor method" do
+ before_sample do
+ @a = A.new
end
measure do
- 200.times do
- [ 1, 2, 3, 1.0, 2.0, 3.0, "1", "2", "3", :uno, :dos, :tres, "one"].each { |item| @n.foo item }
- end
+ @args.each { |item| @a.foo item }
+ end
+
+ after_sample do
+ puts A.functor_cache["foo"].map{ |c| c.size }.inspect
end
end
-OneArg.new "functor method" do
- before do
- @a = A.new
+OneArg.new "native method" do
+ before_sample do
+ @n = Native.new
end
measure do
- 200.times do
- [ 1, 2, 1.0, 2.0, "1", "2", :uno, :dos, "one"].each { |item| @a.foo item }
- end
+ @args.each { |item| @n.foo item }
end
end
-
-OneArg.compare_instances( 16, 32)
\ No newline at end of file
+OneArg.compare_instances( 4, 96)
\ No newline at end of file
metrics/one_arg.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
test/fib.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
test/functor.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|
test/guards.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
test/inheritance.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
test/matchers.rb
@@ -1,18 +1,18 @@
require "#{File.dirname(__FILE__)}/helpers"
-class A
+class Reopening
include Functor::Method
functor( :foo, Integer ) { |x| 1 }
end
-class A
+class Reopening
functor( :foo, Integer ) { |x| 2 }
end
describe "Functor methods should support reopening" do
specify "by allowing reopening of a class to override an implementation" do
- A.new.foo( 5 ).should == 2
+ Reopening.new.foo( 5 ).should == 2
end
end
test/reopening.rb
@@ -1,21 +1,26 @@
require "#{File.dirname(__FILE__)}/helpers"
-class A
+class WithSelf
attr_accessor :bar
include Functor::Method
def initialize( x ) ; @bar = x ; end
functor_with_self( :foo, self, Integer ) { |x| x }
functor_with_self( :foo, lambda{ |x| x.bar == true }, Integer ) { |s| 'bar' }
+ functor_with_self( :foo, lambda{ |x| x.bar.is_a? String }, Integer ) { |s| 'I be string' }
end
describe "Functor methods should support allow matching on self" do
specify "by allowing functor_with_self to provide a guard on self" do
- A.new( true ).foo( 5 ).should == 'bar'
+ WithSelf.new( true ).foo( 5 ).should == 'bar'
end
specify "or by simply providing self as an argument" do
- A.new( false ).foo( 5 ).should == 5
+ WithSelf.new( false ).foo( 5 ).should == 5
+ end
+
+ specify "another guard example, for those who need it" do
+ WithSelf.new( "me" ).foo( 87 ).should == "I be string"
end
end
test/with_self.rb
doc/README
test.rb
6c24edafe3b4ad4125b84b974a15df07331cc7ce
Matthew King
automatthew@gmail.com
http://github.com/dyoder/functor/commit/cb65702d7fc0ef089b14f89933f06547e83a01ab
cb65702d7fc0ef089b14f89933f06547e83a01ab
2009-02-06T15:03:41-08:00
2009-02-06T15:00:15-08:00
Reworked Functor to recursively redefine its method
Fixed minor problems for compatibility with Ruby 1.9
Also added a caching system that provides a substantial speed increase
e6e4323c66cdf44a88fe35bd268f05a38f832aac
Matthew King
automatthew@gmail.com