functor 0.4.2 → 0.5.1

data/lib/functor.rb

@@ -3,67 +3,70 @@ require "#{File.dirname(__FILE__)}/object"
 class Functor
   
   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 ||= {} ; end
+      def k.functors
+        @__functors ||= superclass.respond_to?( :functors ) ? 
+          Functor::Method.copy_functors( superclass.functors ) : {}
+      end
       def k.functor( name, *args, &block )
-        unless functors[ name ]
-          functors[ name ] = Functor.new
-          klass = self.name ; module_eval <<-CODE
-            def #{name}( *args, &block ) 
-              begin
-                #{klass}.functors[ :#{name} ].apply( self, *args, &block ) 
-              rescue ArgumentError => e
-                begin
-                  super
-                rescue NoMethodError => f
-                  raise e
-                end
-              end
-            end
-          CODE
-        end
-        functors[ name ].given( *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 ) ) } 
+      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 ) ) } 
       end
     end
   end
   
-  def initialize( &block ) 
-    @rules = [] ; instance_eval( &block ) if block_given?
+  
+  def initialize( &block )
+    @rules = [] ; yield( self ) if block_given?
+  end
+  
+  def initialize_copy( from )
+    @rules = from.instance_eval { @rules.clone }
   end
   
   def given( *pattern, &action )
-    @rules.delete_if { |p,a| p == pattern }
     @rules << [ pattern, action ]
   end
   
-  def apply( object, *args, &block )
-    object.instance_exec( *args, &match( args, &block ) )
+  def call( *args, &block )
+    match( *args, &block ).call( *args )
   end
   
-  def call( *args, &block )
-    match( args, &block ).call( *args )
+  def []( *args, &block )
+    call( *args, &block )
   end
   
   def to_proc ; lambda { |*args| self.call( *args ) } ; end
-  
-  private
-  
-  def match( args, &block )
+    
+  def match( *args, &block )
     args << block if block_given?
-    pattern, action = @rules.find { | p, a | match?( args, p ) }
-    action or raise argument_error( args )
+    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.is_a?( Proc ) and rule.call( arg ) ) or rule === arg or rule == arg
-  end
-  
-  def argument_error( args )
-    ArgumentError.new( "argument mismatch for argument(s): #{ args.map{ |arg| arg.inspect }.join(', ') }." )
+    ( rule.respond_to? :call and rule.call( arg ) ) or rule === arg
   end
-  
+    
 end

data/test/fib.rb

@@ -1,9 +1,9 @@
 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 ) }
+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
 
 describe "Dispatch on a functor object should" do

data/test/guards.rb

@@ -1,16 +1,16 @@
-require 'test/helpers'
+require "#{File.dirname(__FILE__)}/helpers"
 
 describe "Dispatch should support guards" do
   
   before do
-    @stripe = Functor.new do
-      given( lambda { |x| x % 2 == 0 } ) { 'white' }
-      given( lambda { |x| x % 2 == 1 } ) { 'silver' }
+    @stripe = Functor.new do |f|
+      f.given( lambda { |x| x % 2 == 1 } ) { 'silver' }
+      f.given( lambda { |x| x % 2 == 0 } ) { 'white' }
     end
 
-    @safe_divide = Functor.new do
-      given( lambda { |x| x == 0 }, Integer ) { |x,y| false }
-      given( Integer, Integer ) { |x,y| ( y / ( x * 1.0 )) }
+    @safe_divide = Functor.new do |f|
+      f.given( Integer, Integer ) { |x,y| ( y / ( x * 1.0 )) }
+      f.given( lambda { |x| x == 0 }, Integer ) { |x,y| false }
     end
   end
   

data/test/inheritance.rb

@@ -9,7 +9,6 @@ end
 
 class B < A
   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
@@ -22,7 +21,4 @@ describe "Functor methods should support inheritance" do
     B.new.foo( "bar" ).should == [ B, String ]
   end
   
-  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

@@ -2,8 +2,8 @@ require "#{File.dirname(__FILE__)}/helpers"
 
 class C
   include Functor::Method
-  functor( :foo, 1 ) { |a| "==" }
   functor( :foo, Integer ) { |a| "===" }
+  functor( :foo, 1 ) { |a| "==" }
   functor( :foo, lambda { |a| a == "boo" } ) { |v| "Lambda: #{v}" }
 end
 

data/test/with_self.rb

@@ -0,0 +1,21 @@
+require "#{File.dirname(__FILE__)}/helpers"
+
+class A
+  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' }
+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'
+  end
+  
+  specify "or by simply providing self as an argument" do
+    A.new( false ).foo( 5 ).should == 5
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: functor
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: 0.5.1
 platform: ruby
 authors: 
 - Dan Yoder
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-07-11 00:00:00 -07:00
+date: 2008-10-08 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -64,6 +64,7 @@ files:
 - test/inheritance.rb
 - test/matchers.rb
 - test/reopening.rb
+- test/with_self.rb
 has_rdoc: true
 homepage: http://dev.zeraweb.com/
 post_install_message: 
@@ -86,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: functor
-rubygems_version: 1.0.1
+rubygems_version: 1.2.0
 signing_key: 
 specification_version: 2
 summary: Pattern-based dispatch for Ruby, inspired by Topher Cyll's multi.