dyoder-functor 0.2 → 0.3.1

data/doc/HISTORY

@@ -1,2 +1,4 @@
 0.1 - Initial implemention of Functor class.
-0.2 - Added method dispatch, to_proc support, tests.
+0.2 - Added method dispatch, to_proc support, tests.
+0.3 - Added support for guards and redefinition.
+0.3.1 - Made thread-safe and added ability to call base class functors.

data/doc/README

@@ -11,9 +11,11 @@ Functor provides pattern-based function and method dispatch for Ruby. To use it
   r.times = 5
   r.repeat( 5 )   # => 25
   r.repeat( "-" ) # => "- - - - -"
-  r.repeat( 7.3 ) # => RuntimeError!
+  r.repeat( 7.3 ) # => ArgumentError!
 
-Warning: This defines a class instance variable @functors behind the scenes as a side-effect. Also, functors won't inherit properly at this point.
+Warning: This defines a class instance variable @__functors behind the scenes as a side-effect. Also, although inheritance works within a functor method, super does not. To call the parent method, you need to call it explicitly using the #functors class method, like this:
+
+  A.functors[ :foo ].apply( self, 'bar' )
 
 You can also define Functor objects directly:
 
@@ -27,10 +29,17 @@ You can use functors directly with functions taking a block like this:
 
   [ *0..10 ].map( &fib )  # => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
   
-You can explicitly bind self using #bind:
+You can call a functor as a method using #apply:
 
-  fun.bind( obj )
+  fun.apply( obj, 7 )
   
 which is actually how the method dispatch is implemented.
 
-Arguments are matched first using === and then ==, so anything that supports these methods can be matched against.
+Arguments are matched first using === and then ==, so anything that supports these methods can be matched against. In addition, you may pass "guards," any object that responds to #call and which take and object (the argument) and return true or false. This allows you to do things like this:
+
+  stripe ||= Functor.new do
+    given( lambda { |x| x % 2 == 0 } ) { 'white' }
+    given( lambda { |x| x % 2 == 1 } ) { 'silver' }
+  end
+
+which will return "white" and "silver" alternately for a sequence of numbers.

data/lib/functor.rb

@@ -2,24 +2,16 @@ require 'lib/object'
 
 class Functor
   
-  def self.precedence
-    lambda do |pattern|
-      case pattern ; when Class then 0 ; when Proc then 1 ; when Regexp then 2 ; else 3 ; end
-    end
-  end
-
   module Method
     def self.included( k )
+      def k.functors ; @__functors ||= {} ; end
       def k.functor( name, *args, &block )
-        functors = module_eval { @__functors ||= {} }
         unless functors[ name ]
           functors[ name ] = Functor.new
-          klass = self.name
-          module_eval <<-CODE
+          klass = self.name ; module_eval <<-CODE
             def #{name}( *args, &block ) 
               begin
-                functors = #{klass}.module_eval { @__functors }
-                functors[ :#{name} ].bind( self ).call( *args, &block ) 
+                #{klass}.functors[ :#{name} ].apply( self, *args, &block ) 
               rescue ArgumentError => e
                 begin
                   super
@@ -35,26 +27,35 @@ class Functor
     end
   end
   
-  def initialize( &block ) @patterns = {}; instance_eval( &block ) if block_given? ; end
+  def initialize( &block ) 
+    @rules = [] ; instance_eval( &block ) if block_given?
+  end
   
-  def given( *pattern, &action ) ; @patterns[ pattern ] = action ; end
+  def given( *pattern, &action )
+    @rules.delete_if { |p,a| p == pattern }
+    @rules << [ pattern, action ]
+  end
   
-  def bind( object ) ; @object = object ; self ; end
+  def apply( object, *args, &block )
+    object.instance_exec( *args, &match( *args, &block ) )
+  end
   
   def call( *args, &block )
     args.push( block ) if block_given?
-    candidates = @patterns.keys.select { |pattern| match?( args, pattern ) }
-    raise ArgumentError.new( "argument mismatch for argument(s): #{args.inspect}." ) if candidates.empty?
-    action = @patterns[ candidates.sort( &Functor.precedence ).first ]
-    @object ? @object.instance_exec( *args, &action ) : action.call( *args )
+    match( *args, &block ).call( *args )
   end
   
-  def to_proc
-    lambda { |*args| self.call(*args) }
-  end
+  def to_proc ; lambda { |*args| self.call( *args ) } ; end
   
   private
   
+  def match( *args, &block )
+    args.push( block ) if block_given? 
+    pattern, action = @rules.find { | pattern, action | match?( args, pattern ) }
+    raise ArgumentError.new( "argument mismatch for argument(s): #{args.inspect}." ) unless action
+    return action
+  end
+  
   def match?( args, pattern )
     pattern.zip(args).all? { |x,y| x === y or x == y or 
         ( x.respond_to?(:call) && x.call( y ) ) } if pattern.length == args.length

data/test/fib.rb

@@ -3,13 +3,13 @@ require "#{File.dirname(__FILE__)}/helpers"
 fib ||= Functor.new do
   given( 0 ) { 0 }
   given( 1 ) { 1 }
-  given( Integer ) { |n| self.call( n - 1 ) + self.call( n - 2 ) }
+  given( Integer ) { | n | self.call( n - 1 ) + self.call( n - 2 ) }
 end
 
 describe "Dispatch on a functor object should" do
   
   specify "be able to implement the Fibonacci function" do
-    [*0..10].map( &fib ).should == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+    [*0..10].map( &fib ).should == [ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 ]
   end
   
 end

data/test/functor.rb

@@ -22,7 +22,7 @@ describe "Dispatch on instance method should" do
   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(ArgumentError)
   end
 end
 

data/test/guards.rb

@@ -0,0 +1,15 @@
+require 'test/helpers'
+
+stripe ||= Functor.new do
+  given( lambda { |x| x % 2 == 0 } ) { 'white' }
+  given( lambda { |x| x % 2 == 1 } ) { 'silver' }
+end
+
+describe "Dipatch should support guards" do
+  
+  specify "allowing you to use odd or even numbers as a dispatcher" do
+    [*0..9].map( &stripe ).should == %w( white silver ) * 5
+  end
+  
+end
+  

data/test/inheritance.rb

@@ -2,30 +2,27 @@ require "#{File.dirname(__FILE__)}/helpers"
 
 class A
   include Functor::Method
-  functor( :smurf, Integer ) { |x| "A: Integer" }
-  functor( :smurf, String ) { |s| "A: String" }
-  functor( :smurf, Symbol ) { |s| smurf( "boo" ) }
-  functor( :smurf, Hash ) { |h| "A: Hash" }
+  functor( :foo, Integer ) { |x| [ A, Integer ] }
+  functor( :foo, String ) { |s| [ A, String ] }
+  functor( :foo, Float ) { |h| [ A, Float ] }
 end
 
 class B < A
-  functor( :smurf, String ) { |s| "B: String" }
-  functor( :smurf, Hash ) { |h| "#{super} and B: Hash" }
+  functor( :foo, String ) { |s| [ B, String ] }
+  functor( :foo, Float ) { |f| [ B, *A.functors[:foo].apply( self, f ) ] }
 end
 
 describe "Functor methods should support inheritance" do
   
   specify "by inheriting base class implementations" do
-    B.new.smurf( 5 ).should == "A: Integer"
+    B.new.foo( 5 ).should == [ A, Integer ]
   end
   
   specify "by allowing derived classes to override an implementation" do
-    B.new.smurf( "foo" ).should == "B: String"
-    A.new.smurf( :foo ).should == "A: String"
-    B.new.smurf( :foo ).should == "B: String"
+    B.new.foo( "bar" ).should == [ B, String ]
   end
   
-  specify "by allowing to call the implementation of an overriden method on super" do
-    B.new.smurf( {} ).should == "A: Hash and B: Hash"
+  specify "by allowing you to call base class functors using #functors" do
+    B.new.foo( 1.0 ).should == [ B, A, Float ]
   end
 end

data/test/matchers.rb

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

data/test/reopening.rb

@@ -0,0 +1,18 @@
+require "#{File.dirname(__FILE__)}/helpers"
+
+class A
+  include Functor::Method
+  functor( :foo, Integer ) { |x| 1 }
+end
+
+class A
+  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
+  end
+
+end

metadata

@@ -1,15 +1,17 @@
 --- !ruby/object:Gem::Specification 
 name: dyoder-functor
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: 0.3.1
 platform: ruby
 authors: 
 - Dan Yoder
+- Matthew King
+- Lawrence Pit
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-06-09 00:00:00 -07:00
+date: 2008-06-15 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -28,8 +30,11 @@ files:
 - lib/object.rb
 - test/fib.rb
 - test/functor.rb
+- test/guards.rb
 - test/helpers.rb
 - test/inheritance.rb
+- test/matchers.rb
+- test/reopening.rb
 has_rdoc: true
 homepage: http://dev.zeraweb.com/
 post_install_message: