multi_dispatch 0.1dev

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDM5YjUyM2QxODYxMTY1YWJiM2VlMTQ1M2UwYTVjNjIxYWQ3ODY3MQ==
+  data.tar.gz: !binary |-
+    OTU1OTY5YmQ5MmZiMzNmNmQ5M2M5MjMyOGUwOGY3ZTQ3ZGRjODhlMA==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    Zjk5NTlhMTRlYzRlYTI0YzIxYTQxZjIxY2FlNjU0MTJiY2MwNmEzMmJiMTlh
+    Y2RmMTE5YjAzMGI3ODNiM2NkOTVkYjNkYWQ3MmYwOWJkZWYwNDlhYWM0Y2Vl
+    MGQzMDhiN2YzZmUxZjU5MTdlNDAyZTAxZjhiNDg3ZGU0YTZmOWY=
+  data.tar.gz: !binary |-
+    MzUzNWM2NjBhOGE0ZGM5YzgzNDQ2ZTJhZDE3NDE1MmQ1MjY2ZDEyZjEwYTZj
+    ZTFhNzY2MjIzMDE4ZTczNGMzOGI3NWJhYzFkNGVjZjFmZmMyNGI0OWU3MmQ4
+    MjY2MmQwNTc4YTJhNDk3MjMyZGQxYWVmNDk5M2EyNTAxM2ZhMjI=

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.kpf
+*.rbc
+*.sw?
+*.un~
+.DS_Store
+.buildpath
+.bundle
+.config
+.project
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Robert Pozoga
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+MultiDispatch
+====================
+
+multiple-dispatch is a library extending Ruby objects with multiple dispatch generic functions.
+
+Look for examples in the examples/ directory and in test cases test/. Here are simple examples:
+
+Functional style
+----------------
+
+```ruby
+require_relative '../lib/multi_dispatch.rb'
+
+# reverse for Array
+MultiDispatch::def_multi :reverse, [] { [] }
+MultiDispatch::def_multi :reverse, Array do |list| 
+  [list.pop] + reverse(list) 
+end
+
+# map for Array
+MultiDispatch::def_multi :map, [], Proc do ; [] end
+MultiDispatch::def_multi :map, Array, Proc do |list, func|
+  [func.call(list.first)] + map(list[1..-1], func)
+end
+
+# foldl for Array (equivalent to haskell implementation in Data.List module)
+MultiDispatch::def_multi :foldl, Proc, Object, [] do |f, init, l|
+  init
+end
+MultiDispatch::def_multi :foldl, Proc, Object, Array do |f, init, l|
+  foldl(f, f.call(init, l.first), l.drop(1)) 
+end
+```
+
+
+Pattern Matching
+----------------
+
+It allows to do hacky pattern matching using annonymous functions for defining parameters. The example below shows equivalent Ruby code for Racket examples of list pattern matching:
+
+
+```ruby
+# (match '(1 2 3)
+#    [(list a b c) (list c b a)]) => '(3 2 1)
+#
+def_multi :ex1, lambda { |l| l.size == 3 } do |list|
+  a,b,c = list
+  [c, b, a]
+end
+
+# (match '(1 2 3)
+#    [(list 1 a ...) a]) => '(2 3)
+#
+def_multi :ex2, lambda { |l| l.first == 1 } do |list|
+  list[1..-1]
+end
+
+# (match '(1 (2) (2) (2) 5)
+#    [(list 1 (list a) ..3 5) a]
+#    [_ 'else]) => '(2 2 2)
+#
+ptr = lambda do |list|
+  list.first == 1 && list.size == 5 && list.last == 5 &&
+  list[1..-2].all? { |e| e.size == 1}
+end
+def_multi :ex5, ptr do |list|
+  list[1..3].map(&:first)
+end
+
+# (match '(1 2 3)
+#   [(list-no-order 3 2 x) x]) => 1
+#
+ptr = lambda do |list|
+  list.size == 3 && list.include?(2) && list.include?(3)
+end
+def_multi :ex6, ptr do |list|
+  list.delete_if { |x| [2,3].include? x }.first
+end
+
+# (match '(1 (2 3) 4)
+#   [(list _ (and a (list _ ...)) _) a]) => '(2 3)
+#
+ptr = lambda do |list|
+  list.size == 3 && list[1].size >= 1
+end
+def_multi :ex7, ptr do |list|
+  list[1]
+end
+```
+
+Method Ambiguities
+------------------
+
+It is possible to define a set of methods such that there is no unique most specific method applicable to some combinations of arguments:
+
+```ruby
+def_multi :arg, 1, Numeric do |*a|
+  a.first 
+end
+def_multi :arg, Numeric, 2 do |*a|
+  a.last
+end
+
+# is_one?(1) matches to the method with argument defined by value
+def_multi :is_one?, 1 do 
+  true
+end
+def_multi :is_one?, lambda { |x| x == 1 } do
+  true
+end
+
+1.9.3-p374 :001 > arg(1,2)
+2
+
+1.9.3-p374 :001 > arg(1, 1337)
+1
+
+1.9.3-p374 :001 > arg(1337, 2)
+2
+
+```
+
+
+

data/Rakefile

@@ -0,0 +1,7 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['tests/*.rb']
+  t.verbose = true
+end

data/TODO.md

@@ -0,0 +1,7 @@
+* more documentation
+
+* comments
+
+* more examples
+
+* add inspection for arguments defined by lambda conditions (ruby2ruby)

data/examples/functional_style.rb

@@ -0,0 +1,30 @@
+require_relative '../lib/multi_dispatch.rb'
+
+
+# reverse for Array
+MultiDispatch::def_multi :reverse, [] { [] }
+MultiDispatch::def_multi :reverse, Array do |list| 
+  [list.pop] + reverse(list) 
+end
+
+p reverse [1,2,3,4,5]
+
+# map for Array
+MultiDispatch::def_multi :map, [], Proc do ; [] end
+MultiDispatch::def_multi :map, Array, Proc do |list, func|
+  [func.call(list.first)] + map(list[1..-1], func)
+end
+
+p map [1,2,3], lambda { |x| x**2 }
+
+# foldl for Array (equivalent to haskell Data.List implementation)
+MultiDispatch::def_multi :foldl, Proc, Object, [] do |f, init, l|
+  init
+end
+MultiDispatch::def_multi :foldl, Proc, Object, Array do |f, init, l|
+  foldl(f, f.call(init, l.first), l.drop(1)) 
+end
+
+p foldl(lambda { |x, y| x+y }, 0, [1,2,3,4,5])
+
+

data/examples/lambda_calc.rb

@@ -0,0 +1,162 @@
+require_relative '../lib/multi_dispatch.rb'
+
+class Interpreter
+  include MultiDispatch
+
+  def initialize
+    @env = Env.new
+  end
+
+  class Env < Hash
+  end
+  
+  class Expression 
+
+  end
+
+  class Var < Expression
+    attr_accessor :name
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  class Num < Expression
+    attr_accessor :value
+    def initialize(value) ; @value = value end
+  end
+
+  class Bool < Expression
+    attr_accessor :value
+    def initialize(value) ; @value = value end
+  end
+
+  class Plus < Expression 
+    attr_accessor :left, :right
+    def initialize(left, right)
+      @left, @right = left, right
+    end
+  end
+  
+  class Minus < Expression 
+    attr_accessor :left, :right
+    def initialize(left, right)
+      @left, @right = left, right
+    end
+  end
+
+  class Func < Expression
+    attr_accessor :var_name, :body
+    def initialize(var_name, body)
+      @var_name, @body = var_name, body
+    end
+  end 
+
+  class Closure
+    attr_accessor :var_name, :body
+    def initialize(var_name, body)
+      @var_name, @body = var_name, body
+    end
+  end
+
+  class Call < Expression
+    attr_accessor :func, :param
+    def initialize(func, param)
+      @func, @param = func, param 
+    end
+  end
+
+  class LetDirect
+    attr_accessor :var, :expr, :body
+    def initialize(var, expr, body)
+      @var, @expr, @body = var, expr, body
+    end
+  end
+  
+  class LetByFunc
+    attr_accessor :var, :expr, :body
+    def initialize(var, expr, body)
+      @var, @expr, @body = var, expr, body
+    end
+  end
+
+  class If
+    attr_accessor :cond, :if_true, :if_false
+    def initialize(cond, if_true, if_false)
+      @cond, @if_true, @if_false = cond, if_true, if_false
+    end
+  end
+
+  def_multi :evaluate, Num do |num|
+    num.value
+  end
+
+  def_multi :evaluate, Plus do |plus|
+    evaluate(plus.left) + evaluate(plus.right)
+  end
+
+  def_multi :evaluate, Minus do |minus|
+    evaluate(minus.left) - evaluate(minus.right)
+  end
+
+  def_multi :evaluate, Bool do |bool|
+    bool.value
+  end
+
+  def_multi :evaluate, Var do |var|
+    @env[var.name]
+  end
+
+  def_multi :evaluate, Func do |func|
+    Closure.new(func.var_name, func.body)
+  end
+
+  def_multi :evaluate, Call do |call|
+    closure = evaluate(call.func)
+    @env[closure.var_name] = evaluate(call.param)
+    evaluate(closure.body)
+  end
+
+  def_multi :evaluate, If do |stat|
+    evaluate(stat.cond) ? evaluate(stat.if_true) : evaluate(stat.if_false)
+  end
+
+  def_multi :evaluate, LetDirect do |let_dir| 
+    @env[let_dir.var] = evaluate(let_dir.expr)
+    ret = evaluate(let_dir.body) ; @env.delete(let_dir.var) ; ret
+  end  
+  
+  def_multi :evaluate, LetByFunc do |let_func|
+    evaluate(Call.new(Func.new(let_func.var, let_func.body), let_func.expr))
+  end
+
+
+  def test
+    p evaluate(Num.new(7))
+    p evaluate(Plus.new(Num.new(3), Num.new(5)))
+    p evaluate(Minus.new(Num.new(4), Num.new(4)))
+    p evaluate(Plus.new(Num.new(5), Minus.new(Num.new(2), Num.new(1))))
+    @env[:a] = 5
+    p evaluate(Var.new(:a))
+    p evaluate(Plus.new(Var.new(:a), Minus.new(Num.new(2), Num.new(1))))
+    p evaluate(Call.new(Func.new(:x, Plus.new(Var.new(:x), Num.new(1))), Num.new(2)))
+    p evaluate(Call.new(
+      Func.new(:f, Plus.new(Num.new(2), Call.new(Var.new(:f), Num.new(8)))), 
+      Func.new(:x, Plus.new(Num.new(5), Var.new(:x)))))
+    p evaluate(Call.new(
+      Func.new(:f, Plus.new(Num.new(2), Call.new(Var.new(:f), Num.new(8)))), 
+      Func.new(:f, Plus.new(Num.new(5), Var.new(:f)))))
+    
+    p evaluate(LetDirect.new(:x, Num.new(28), Var.new(:x))) # 28
+    p evaluate(LetByFunc.new(:x, Num.new(18), Var.new(:x))) # 18
+    p evaluate(LetByFunc.new(:b, Bool.new(true), Var.new(:b))) # 6
+    p evaluate(LetByFunc.new(:b, Bool.new(true), If.new(Var.new(:b), Num.new(6), Num.new(7)))) # 6
+    p evaluate(LetByFunc.new(:b, Bool.new(false), If.new(Var.new("b"), Num.new(6), Num.new(7)))) # 7
+    
+
+  end
+
+end
+
+inter = Interpreter.new
+inter.test

data/examples/lc_interpreter.rb

@@ -0,0 +1,154 @@
+# Simple lambda calculus interpreter to evaluate arithmetic expressions 
+# in the form of abstract syntax trees. Has support for anonymous 
+# functions, closures, and let expressions. 
+#
+# Implemented in functional way, using multi_dispatch gem.
+
+require_relative '../lib/multi_dispatch.rb'
+
+# helpers
+module Camelizer
+  def camelize
+    return self.to_s if self !~ /_/ && self =~ /[A-Z]+.*/
+    to_s.split('_').map { |e| e.capitalize }.join
+  end
+end
+
+Symbol.send(:include, Camelizer)
+
+# Lambda Calculus Interpreter
+class LCI
+  include MultiDispatch
+
+  attr_accessor :env
+
+  def initialize
+    @env = {}
+  end
+
+  def self.def_expr(name, *args)
+    klass = Object.const_set(name.camelize, Class.new)
+    klass.class_eval do
+      attr_accessor *args
+      define_method :initialize do |*values|
+        args.zip(values).each do |var, value|
+          instance_variable_set("@#{var}", value)
+        end
+      end
+    end
+  end
+
+  def_expr(:var, :name)
+  def_expr(:plus, :left, :right)
+  def_expr(:minus, :left, :right)
+  def_expr(:func, :var_name, :body)
+  def_expr(:closure, :var_name, :body)
+  def_expr(:call, :func, :param)
+  def_expr(:let_direct, :var, :expr, :body)
+  def_expr(:let_by_func, :var, :expr, :body)
+  def_expr(:if, :cond, :if_true, :if_false)
+  
+  def_multi :evaluate, Numeric do |num| ; num end
+  def_multi :evaluate, true  do ; true  end
+  def_multi :evaluate, false do ; false end
+
+  def_multi :evaluate, Plus do |plus|
+    evaluate(plus.left) + evaluate(plus.right)
+  end
+
+  def_multi :evaluate, Minus do |minus|
+    evaluate(minus.left) - evaluate(minus.right)
+  end
+
+  def_multi :evaluate, Var do |var|
+    @env[var.name]
+  end
+
+  def_multi :evaluate, Func do |func|
+    Closure.new(func.var_name, func.body)
+  end
+
+  def_multi :evaluate, Call do |call|
+    closure = evaluate(call.func)
+    @env[closure.var_name] = evaluate(call.param)
+    evaluate(closure.body)
+  end
+
+  def_multi :evaluate, If do |stat|
+    evaluate(stat.cond) ? evaluate(stat.if_true) : evaluate(stat.if_false)
+  end
+
+  def_multi :evaluate, LetDirect do |let_dir| 
+    @env[let_dir.var] = evaluate(let_dir.expr)
+    ret = evaluate(let_dir.body) ; @env.delete(let_dir.var) ; ret
+  end  
+  
+  def_multi :evaluate, LetByFunc do |let_func|
+    evaluate(Call.new(Func.new(let_func.var, let_func.body), let_func.expr))
+  end
+
+  class << self ; undef :def_expr end
+
+end
+
+# *** TESTS ***
+require 'minitest/autorun'
+
+class TestStuff < MiniTest::Unit::TestCase
+  
+  # helper for tests
+  def eval(expr)
+    LCI.new.evaluate(expr)
+  end
+  
+  def test_evaluate_to_7
+    assert_equal( 7, 
+                  eval(7))
+  end
+  def test_simple_addition
+    assert_equal( 8, 
+                  eval( Plus.new(3, 5)))
+  end
+  def test_nested_addition
+    assert_equal( 0, 
+                  eval( Minus.new(4, 4)))
+  end
+  def test_addition_and_subtraction
+    assert_equal( 6, 
+                  eval( Plus.new(5, Minus.new(2, 1))))
+  end
+  def test_eval_with_env_variable
+    i = LCI.new
+    i.env[:a] = 5
+    assert_equal( 5, 
+                  i.evaluate( Var.new(:a) ))
+    assert_equal( 6, 
+                  i.evaluate(Plus.new(Var.new(:a), Minus.new(2, 1))))
+  end
+  def test_functions
+    assert_equal( 3,
+                  eval(Call.new(Func.new(:x, Plus.new(Var.new(:x), 1)), 2)))
+  end
+  def test_passing_functions_to_functions
+    assert_equal( 15,
+      eval(Call.new(
+                Func.new(:f, Plus.new( 2, Call.new( Var.new(:f), 8))), 
+                Func.new( :x, Plus.new(5, Var.new(:x))))))
+    assert_equal( 15, 
+      eval(Call.new(
+                Func.new(:f, Plus.new(2, Call.new(Var.new(:f), 8))), 
+                Func.new(:f, Plus.new(5, Var.new(:f))))))
+  end
+  def test_let_direct
+    assert_equal( 28, eval(LetDirect.new(:x, 28, Var.new(:x))))
+    assert_equal( 18, eval(LetByFunc.new(:x, 18, Var.new(:x))))
+  end
+  def test_let_by_func     
+    assert_equal( true, eval(LetByFunc.new(:b, true, Var.new(:b))))
+    assert_equal( 6, eval(LetByFunc.new(:b, true, If.new(Var.new(:b), 6, 7))))
+    assert_equal( 7, eval(LetByFunc.new(:b, false, If.new(Var.new(:b), 6, 7)))) 
+  end
+
+end
+
+

data/examples/pattern_matching.rb

@@ -0,0 +1,122 @@
+require_relative '../lib/multi_dispatch.rb'
+
+class ListPatternMatching
+  include MultiDispatch
+
+  # (match '(1 2 3)
+  #    [(list a b c) (list c b a)]) => '(3 2 1)
+  #
+  def_multi :ex1, lambda { |l| l.size == 3 } do |list|
+    a,b,c = list
+    [c, b, a]
+  end
+
+  # (match '(1 2 3)
+  #    [(list 1 a ...) a]) => '(2 3)
+  #
+  def_multi :ex2, lambda { |l| l.first == 1 } do |list|
+    list[1..-1]
+  end
+
+  # (match '(1 2 3 4)
+  #    [(list 1 a ..3) a]
+  #    [_ 'else]) => '(2 3 4)
+  #
+  def_multi :ex3, 
+            lambda { |l| l.first == 1 && l[1..-1].size >= 3 } do |list|
+    list[1..3]
+  end
+
+  # (match '(1 2 3 4 5)
+  #    [(list 1 a ..3 5) a]
+  #    [_ 'else]) => '(2 3 4)
+  #
+  def_multi :ex4, 
+            lambda { |l| l.first == 1 && l.size == 5 && l.last == 5 } do |list|
+    list[1..3]
+  end
+
+  # (match '(1 (2) (2) (2) 5)
+  #    [(list 1 (list a) ..3 5) a]
+  #    [_ 'else]) => '(2 2 2)
+  #
+  ptr = lambda do |list|
+    list.first == 1 && list.size == 5 && list.last == 5 &&
+    list[1..-2].all? { |e| e.size == 1}
+  end
+  def_multi :ex5, ptr do |list|
+    list[1..3].map(&:first)
+  end
+
+  # (match '(1 2 3)
+  #   [(list-no-order 3 2 x) x]) => 1
+  #
+  ptr = lambda do |list|
+    list.size == 3 && list.include?(2) && list.include?(3)
+  end
+  def_multi :ex6, ptr do |list|
+    list.delete_if { |x| [2,3].include? x }.first
+  end
+
+  # (match '(1 (2 3) 4)
+  #   [(list _ (and a (list _ ...)) _) a]) => '(2 3)
+  #
+  ptr = lambda do |list|
+    list.size == 3 && list[1].size >= 1
+  end
+  def_multi :ex7, ptr do |list|
+    list[1]
+  end
+
+end
+
+class RegexPatternMatching
+  include MultiDispatch
+  
+  animals_ptr = /dog|cat|cow|ox/ 
+  def_multi :classify, lambda { |s| s =~ animals_ptr } do |s|
+    s =~ animals_ptr ; [$&, :animal]
+  end
+
+  def_multi :classify, lambda { |s| s =~ /-?\d+/ } do |s|
+    s =~ /-?\d*/ ; [$&, :integer]
+  end
+
+  food_ptr = /burger|pizza|falafel|burrito|pasta/
+  def_multi :classify, lambda { |s| s =~ food_ptr } do |s|
+    s =~ food_ptr ; [$&, :food]
+  end
+
+  os_ptr = /windows|linux|freebsd|solaris|plan b/
+  def_multi :classify, lambda { |s| s =~ os_ptr } do |s|
+    s =~ os_ptr ; [$&, :os]
+  end
+
+end
+
+# *** TESTS ***
+require 'minitest/autorun'
+
+class TestStuff < MiniTest::Unit::TestCase
+
+  def test_list_pattern_matching
+    pm = ListPatternMatching.new
+    assert_equal([3,2,1], pm.ex1([1, 2, 3]))
+    assert_equal([2,3],   pm.ex2([1, 2, 3]))
+    assert_equal([2,3,4], pm.ex3([1, 2, 3, 4]))
+    assert_equal([2,3,4], pm.ex4([1, 2, 3, 4, 5])) 
+    assert_equal([2,2,2], pm.ex5([1, [2], [2], [2], 5]))
+    assert_equal(1,       pm.ex6([1, 2, 3]))
+    assert_equal([2, 3],  pm.ex7([1, [2, 3], 4]))
+
+  end
+  
+  def test_regexp_pattern_matching
+    pm = RegexPatternMatching.new
+    assert_equal(['dog', :animal],    pm.classify('some dog'))
+    assert_equal(['-1337', :integer], pm.classify('-1337 or 31337'))
+    assert_equal(['freebsd', :os],    pm.classify('freebsd is great!'))
+    assert_equal(['pasta', :food],    pm.classify('I love italian pasta')) 
+  end
+
+end

data/examples/pe_31.rb

@@ -0,0 +1,23 @@
+require_relative '../lib/multi_dispatch.rb'
+
+# PROJECT EULER PROBLEM 31
+#
+# The example shows that it's possible to simulate pattern matching 
+# behavior using anonymous functions to define condition for the pattern.
+# It is equivalent to the haskell cade below:
+#
+# count _ 0      = 1
+# count [c] _    = 1
+# count (c:cs) s = sum $ map (count cs . (s-)) [0,c..s]
+
+
+MultiDispatch::def_multi :count, Object, 0 do ;  1 end
+MultiDispatch::def_multi :count, 
+  lambda { |list| list.size == 1 }, Object do  |a, b| 1 end
+MultiDispatch::def_multi :count, Array, Numeric do |list, sum|
+  (0..sum).step(list.first).to_a.map { |e| 
+    count(list[1..-1], sum-e) 
+  }.reduce(:+)
+end
+
+p count( [200,100,50,20,10,5,2,1], 200)

data/lib/multi_dispatch/dispatch.rb

@@ -0,0 +1,58 @@
+require_relative 'unbound_multi_method'
+require_relative 'multi_method'
+
+module MultiDispatch
+
+  module ClassMethods
+
+    def def_multi(_name, *args, &body)
+#       _name = args.shift
+      # closure (to prevent namespace pollution)
+      multi_methods = {}
+
+      # only at first invocation
+      define_singleton_method :instance_multi_methods do 
+        multi_methods.values.flatten
+      end
+      
+      define_singleton_method :instance_multi_method do |name, *args|
+        mthd = self.instance_multi_methods.select do |m| 
+          m.match?(name, args) 
+        end.sort_by { |m| m.match_distance(args) }.first
+        unless mthd
+          raise NoMethodError,
+            "undefined method `#{name}' for class `#{singleton_class}'"
+        end
+        mthd
+      end
+
+      define_singleton_method :def_multi do |name, *args, &body|
+        multi_methods[name] ||= []
+        multi_methods[name].unshift(UnboundMultiMethod.new(name, *args, body ))
+        if !method_defined?(name)
+          define_method name do |*params|
+            singleton_class.instance_multi_method(name, *params).
+            bind(self).call(*params)
+          end
+        end
+      end
+      self.send(:def_multi, *([_name]+args), &body)
+    end
+
+  end
+
+  def self.def_multi(name, *args, &body)
+      Object.instance_eval do
+        include MultiDispatch
+        def_multi(name, *args, &body)
+      end
+  end
+
+  def self.instance_multi_methods ; [] end
+  def self.instance_multi_method(name, obj)
+    raise NoMethodError,
+      "undefined method `#{name}' for class `#{obj.class}'"
+  end
+
+end
+

data/lib/multi_dispatch/multi_method.rb

@@ -0,0 +1,34 @@
+module MultiDispatch
+ 
+  class MultiMethod
+    extend Forwardable
+
+    def_delegators :@unbound_method, :arity, :eql?, :to_s, :owner, :name
+
+    def initialize(obj, unbnd_mthd)
+      @obj, @unbound_method = obj, unbnd_mthd
+    end
+
+    def call(*args)
+      if args.size != arity
+        raise ArgumentError,
+          "wrong number of arguments(#{args.size} for #{arity})"
+      end
+      @obj.instance_exec(*args, &@unbound_method.body)
+    end
+
+    def unbind
+      @unbound_method
+    end
+
+    def receiver 
+      @obj 
+    end
+
+    def to_proc
+      Proc.new { |*args| call(*args) }     
+    end
+
+  end
+
+end

data/lib/multi_dispatch/unbound_multi_method.rb

@@ -0,0 +1,62 @@
+module MultiDispatch
+
+  class UnboundMultiMethod
+    attr_accessor :patterns, :body, :name
+
+    def initialize(name, *args, body)
+      @name, @patterns, @body = name, args, body
+    end
+    
+    def match?(name, params)
+      name == @name &&
+      params.size == arity &&
+      params.zip(@patterns).all? do |param, pattern|
+        # match by type (Class)
+        (pattern.is_a?(Class) && param.kind_of?(pattern)) ||
+        # match by condition passed in Proc object
+        (pattern.is_a?(Proc) && pattern.call(param) rescue false) ||
+        # match by value
+        param == pattern
+      end
+    end
+
+    def match_distance(params)
+      params.zip(@patterns).reduce(0) do |dist, pair|
+        prm, ptr = pair
+        if prm == ptr ; dist -= 1 
+        else
+          if (ptr.is_a?(Class) && prm.kind_of?(ptr)) 
+            # calculates the distance from given type to parent type
+            prm = prm.class
+            while (dist+=1 ; prm != ptr) do 
+              prm = prm.superclass
+            end
+          end
+        end
+        dist
+      end
+    end
+    
+    def bind(obj)
+      MultiMethod.new(obj, self)
+    end
+
+    def arity 
+      @patterns.size 
+    end
+
+    def eql?(mthd)
+      self.body == mthd.body
+    end
+
+    def to_s
+      "#{self.class}: #{self.class}##{name} (#{@patterns.map { |p| p.is_a?(Proc) ? Proc : p }})"
+    end
+
+    def parameters
+      @patterns
+    end
+
+  end
+
+end

data/lib/multi_dispatch/version.rb

@@ -0,0 +1,3 @@
+module MultiDispatch
+    VERSION = "0.1dev"
+end

data/lib/multi_dispatch.rb

@@ -0,0 +1,13 @@
+require 'forwardable'
+
+require_relative 'multi_dispatch/version'
+require_relative 'multi_dispatch/dispatch'
+
+
+module MultiDispatch
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+end

data/multi_dispatch.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'multi_dispatch/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "multi_dispatch"
+  spec.version       = MultiDispatch::VERSION
+  spec.authors       = ["Robert Pozoga"]
+  spec.email         = ["robert.pozoga@gmail.com"]
+  spec.description   = %q{This gem provides light-weight and easy-to-use multiple dispatch generic methods.}
+  spec.summary       = %q{Multiple dispatch for Ruby.}
+  spec.homepage      = "http://github.com/robpe/multi-dispatch"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/tests/ambiguity_tests.rb

@@ -0,0 +1,41 @@
+require_relative '../lib/multi_dispatch.rb'
+require 'minitest/autorun'
+
+class TestAmbiguity < MiniTest::Unit::TestCase
+  
+  class Foo
+    include MultiDispatch
+    
+    def_multi :arg, 1, Numeric do |*a|
+      a.first 
+    end
+    def_multi :arg, Numeric, 2 do |*a|
+      a.last
+    end
+
+    def_multi :is_one?, 1 do 
+      true
+    end
+    def_multi :is_one?, lambda { |x| x == 1 } do
+      true
+    end
+
+  end
+
+  def test_ambigous_cases
+    f = Foo.new
+    
+    assert_equal(2, f.arg(1,2))
+    assert_equal(1, f.arg(1, 1337))
+    assert_equal(2, f.arg(1337, 2))
+  end
+
+  def test_values_over_lambdas
+    f = Foo.new
+    # values have higher priority than lambda functions
+      assert_equal( 1,
+        f.singleton_class.instance_multi_method(:is_one?, 1).parameters.first)
+
+  end  
+
+end

data/tests/multi_dispatch_tests.rb

@@ -0,0 +1,87 @@
+require 'minitest/autorun'
+require_relative '../lib/multi_dispatch'
+
+
+class TestSimpleStuff < MiniTest::Unit::TestCase
+  
+  class JuliaExample
+    include MultiDispatch
+
+    def initialize(mul)
+      @mltplr = mul
+    end
+
+    def_multi :g, Float, Float do |x, y|
+      @mltplr*x + @mltplr*y
+    end
+
+    def_multi :g, Float, Object do |x, y|
+      @mltplr*x + y
+    end
+
+    def_multi :g, Object, Float do |x, y|
+      x + @mltplr*y
+    end
+  end
+
+  def test_looking_up_instance_multi_methods_works
+    multi_methods = JuliaExample.instance_multi_methods
+    
+    assert_equal(3, multi_methods.size)
+    assert_equal(3, multi_methods.select { |m| m.name == :g }.size)
+    
+    example = JuliaExample.new(2)
+    assert_equal( 
+      JuliaExample.instance_multi_methods.select { |m|
+        m.patterns.all? { |p| p.eql? Float } 
+      }.first, 
+      JuliaExample.instance_multi_method(:g, 1.0, 1.0))
+  end
+
+  def test_bind_call_to_proc_methods
+    unbound = JuliaExample.instance_multi_method(:g, Float, Float)
+    bound = unbound.bind(JuliaExample.new(7))
+    
+    assert_equal(unbound, bound.unbind)
+    expected = JuliaExample.new(7).g(133.0, 37.0)
+    assert_equal(expected, bound.call(133.0, 37.0))
+    assert_equal(expected, bound.to_proc.call(133.0, 37.0))
+  end
+
+  def test_dispatch_fails_on_nonexistent_methods
+    example = JuliaExample.new(7)
+    assert_raises(NoMethodError) { example.f(1) }
+    assert_raises(NoMethodError) { 
+      JuliaExample.instance_multi_method(:f, 1)
+    }
+  end
+
+end
+
+class TestDispatchFunctionality < MiniTest::Unit::TestCase
+
+  class Container
+    include MultiDispatch
+    
+    def_multi :reverse, [] { [] }
+    def_multi :reverse, Array do |list| 
+      [list.pop] + reverse(list) 
+    end
+
+    def_multi :map, [], Proc do ; [] end
+    def_multi :map, Array, Proc do |list, func|
+      [func.call(list.first)] + map(list[1..-1], func)
+    end
+
+  end
+
+  def test_multi_methods
+    container = Container.new
+    container.reverse([1,2,3,4,5])
+
+    assert_equal( [5,4,3,2,1], container.reverse([1,2,3,4,5]))
+    assert_equal( [1,4,9,16], 
+                  container.map([1,2,3,4], Proc.new { |x| x**2 }))
+  end
+
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: multi_dispatch
+version: !ruby/object:Gem::Version
+  version: 0.1dev
+platform: ruby
+authors:
+- Robert Pozoga
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem provides light-weight and easy-to-use multiple dispatch generic
+  methods.
+email:
+- robert.pozoga@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- examples/functional_style.rb
+- examples/lambda_calc.rb
+- examples/lc_interpreter.rb
+- examples/pattern_matching.rb
+- examples/pe_31.rb
+- lib/multi_dispatch.rb
+- lib/multi_dispatch/dispatch.rb
+- lib/multi_dispatch/multi_method.rb
+- lib/multi_dispatch/unbound_multi_method.rb
+- lib/multi_dispatch/version.rb
+- multi_dispatch.gemspec
+- tests/ambiguity_tests.rb
+- tests/multi_dispatch_tests.rb
+homepage: http://github.com/robpe/multi-dispatch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Multiple dispatch for Ruby.
+test_files: []
+has_rdoc: