facets 2.9.1 → 2.9.2

data/work/sandbox/multidispatch0.rb

@@ -0,0 +1,224 @@
+require 'facets/core/kernel/instance_exec'
+
+module MultipleDispatch
+
+  class Dispatcher
+
+    def initialize(name, lists)
+      @name = name
+      @lists = lists
+    end
+
+    def run(you, args)
+      @lists.each do |list|
+        catch(:mismatch) do
+          return list.match(you, args)
+        end
+      end
+      begin
+        raise NoMethodError.new("undefined method `#{@name}' for #{you.inspect}:#{you.class}")
+      rescue NoMethodError => e
+        e.set_backtrace(e.backtrace[2..-1])
+        raise e
+      end
+    end
+
+  end
+
+  class ArgumentList
+
+    def initialize(required, optional, defaults, catch_all, catch_all_type, &action)
+      @required = required
+      @optional = optional
+      @defaults = defaults
+      @catch_all = catch_all
+      @catch_all_type = catch_all_type
+      @action = action
+      calc_arity
+    end
+
+    def calc_arity
+      @min_arity = @required.length
+      @max_arity = (@min_arity + @optional.length unless @catch_all)
+    end
+
+    def match(you, args)
+      throw :mismatch if args.length < @min_arity
+      throw :mismatch if @max_arity && @max_arity < args.length
+      (0...@required.length).each do |i|
+        throw :mismatch unless @required[i] === args[i]
+      end
+      (@required.length...[args.length, @required.length + @optional.length].min).each do |i|
+        throw :mismatch unless @optional[i - @required.length] === args[i]
+      end
+      (args.length - @required.length...@optional.length).each do |i|
+        args << @defaults[i]
+      end
+      if @catch_all
+        (@required.length + @optional.length...args.length).each do |i|
+          throw :mismatch unless @catch_all_type === args[i]
+        end
+        you.instance_exec(*(args[0, @required.length + @optional.length] << args[@required.length + @optional.length..-1]), &@action)
+      else
+        you.instance_exec(*args, &@action)
+      end
+    end
+
+  end
+
+  module ArgumentChanger
+
+  end
+
+  class PropertyDispatch
+
+    def initialize(&blk)
+      @blk = blk
+    end
+
+    def ===(arg)
+      @blk.call(arg)
+    end
+
+  end
+
+  class CastDispatch
+
+    include ArgumentChanger
+
+    def initialize(type)
+      @type = :"to_#{type}"
+    end
+
+    def ===(arg)
+      arg.send(@type) rescue nil
+    end
+
+    def changes_argument?
+      true
+    end
+
+  end
+
+  class AndDispatch
+    
+    def initialize(subterms)
+      @subterms = subterms
+    end
+
+    def ===(arg)
+      @subterms.each do |t|
+        return false unless t === arg
+      end
+      true
+    end
+
+  end
+
+  class OrDispatch
+
+    def initialize(subterms)
+      @subterms = subterms
+    end
+
+    def ===(arg)
+      @subterms.each do |t|
+        return true if t === arg
+      end
+      false
+    end
+
+  end
+
+  class DontCareDispatch
+
+    def initialize
+      
+    end
+
+    def ===(arg)
+      true
+    end
+
+  end
+
+end
+
+if __FILE__ == $0
+
+  include MultipleDispatch
+
+  class A
+
+    def m(*args, &blk)
+      # Argument list 1
+      arg1 = ArgumentList.new([String, String], [], [], false, nil) do |s1, s2|
+        yield [:two_strings, s1, s2]
+      end
+      # Argument list 2
+      arg2 = ArgumentList.new([String, Integer], [], [], false, nil) do |s, i|
+        yield [:string_and_integer, s, i]
+      end
+      # Argument list 3
+      arg3 = ArgumentList.new([Integer, Integer, Integer], [], [], false, nil) do |i1, i2, i3|
+        yield [:three_integers, i1, i2, i3]
+      end
+      # Argument list 4
+      arg4 = ArgumentList.new([:do1, Integer], [], [], false, nil) do |_, i|
+        yield [:do1, i]
+      end
+      # Argument list 5
+      arg5 = ArgumentList.new([:do2, Integer], [], [], false, nil) do |_, i|
+        yield [:do2, i]
+      end
+      # Argument list 6
+      arg6 = ArgumentList.new([:do3, Integer], [Integer, String], [11, "extra"], false, nil) do |_, i1, i2, s|
+        yield [:do3, i1, i2, s]
+      end
+      # Argument list 7
+      arg7 = ArgumentList.new([:do4], [], [], true, Integer) do |_, args|
+        yield [:do4, args]
+      end
+      # Argument list 8
+      arg8 = ArgumentList.new([:do4], [], [], true, String) do |_, args|
+        yield [:do4, args]
+      end
+      # Argument list 9
+      arg9 = ArgumentList.new([PropertyDispatch.new { |a| :do5 === a }], [], [], false, nil) do |_|
+        yield [:do5]
+      end
+      # Argument list 10
+      arg10 = ArgumentList.new([/run/, DontCareDispatch.new], [], [], false, nil) do |i, dc|
+        yield [:run, i, dc]
+      end
+      # Argument list 11
+      arg11 = ArgumentList.new([:do6, CastDispatch.new(:sym)], [], [], false, nil) do |_, s|
+        yield [:do6, s]
+      end
+      
+      # Dispatcher
+      d = Dispatcher.new(:'test', [arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11])
+
+      d.run(self, args)
+    end
+
+  end
+
+  A.new.m("hello", "world") { |a| p a }
+  A.new.m("world", 1) { |a| p a }
+  A.new.m(1, 2, 3) { |a| p a }
+  A.new.m(:do1, 1) { |a| p a }
+  A.new.m(:do2, 2) { |a| p a }
+  A.new.m(:do3, 3, 4, "a1") { |a| p a }
+  A.new.m(:do3, 3, 4) { |a| p a }
+  A.new.m(:do3, 3) { |a| p a }
+  A.new.m(:do4) { |a| p a }
+  A.new.m(:do4, 2) { |a| p a }
+  A.new.m(:do4, 2, 3) { |a| p a }
+  A.new.m(:do4, "2", "3") { |a| p a }
+  A.new.m(:do5) { |a| p a }
+  A.new.m("grunt", 1) { |a| p a }
+  A.new.m("grunt", :a) { |a| p a }
+  A.new.m(:do6, "hi") { |a| p a }
+
+end

data/work/sandbox/multiton2.rb

@@ -0,0 +1,590 @@
+
+module Multiton
+
+  #  disable build-in copying methods
+  def clone
+    raise TypeError, "can't clone Multiton #{self}"
+  end
+
+  def dup
+    raise TypeError, "can't dup Multiton #{self}"
+  end
+
+  protected  #  default marshalling strategy
+  def _dump(depth=-1)
+    Marshal.dump(@multiton_initializer)
+  end
+
+  #
+
+  class << self
+    private
+    def append_features(mod)
+      #  help out people counting on transitive mixins
+      unless mod.instance_of?(Class)
+        raise TypeError, "Inclusion of Multiton in module #{mod}"
+      end
+      super
+    end
+
+    def included(klass)
+      # gracefully handle multiple inclusions of Multiton
+      unless class << klass; include?(Multiton::ClassMethods) end
+        klass.private_class_method  :new, :allocate
+        klass.extend Multiton::ClassMethods
+      end
+    end
+  end
+
+  #
+
+  module ClassMethods
+
+    def instance(*e)
+      arg = multiton_id(e)
+      @multiton_instance.fetch(arg) do
+        @multiton_mutex[arg].synchronize do
+          @multiton_instance.fetch(arg) do
+            val = @multiton_instance[arg] = new(*e)
+            val.instance_variable_set(:@multiton_initializer,e)
+            @multiton_mutex.initialized(arg)
+            val
+          end
+        end
+      end
+    end
+
+    def initialized?(*e)
+      @multiton_instance.key?(multiton_id(e))
+    end
+
+    protected
+    def reinitialize
+      @multiton_instance.clear
+      @multiton_mutex.clear
+    end
+
+    def _load(str)
+      instance(*Marshal.load(str))
+    end
+
+    private
+    def multiton_id(e)
+      e
+    end
+
+    def initialize_copy(orig)
+      super
+      Multiton::ClassMethods.extended(self)
+    end
+
+    def inherited(sub)
+      super
+      Multiton::ClassMethods.extended(sub)
+    end
+
+    class << self
+      protected
+      def extended(klass)
+        klass.class_eval do
+          @multiton_instance = Hash.new
+          @multiton_mutex = InstanceMutex.new
+
+          private
+          # Defining  marshal_dump & marshal_load instance methods introduces
+          # a loop hole to create additonal instances. Providing a private
+          # marshal_dump method forces Ruby to fall back on the _dump & _load
+          # marshalling scheme. When $VERBOSE == true issue a method re-
+          # definition warning for (re)defining marshal_dump.
+          def marshal_dump(depth = -1)
+            raise TypeError, "don't use marshal_load + marshal_dump marshalling"
+          end
+        end
+      end
+
+      class InstanceMutex < Hash
+        def initialize
+          @global = Mutex.new
+        end
+
+        def initialized(arg)
+          store(arg,DummyMutex)
+        end
+
+        def (DummyMutex = Object.new).synchronize
+          yield
+        end
+
+        def default(arg)
+          @global.synchronize { fetch(arg) { store(arg,Mutex.new) }}
+        end
+      end
+    end
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+module Multiton
+  #  disable build-in copying methods
+  def clone
+    raise TypeError, "can't clone Multiton #{self}"
+  end
+
+  def dup
+    raise TypeError, "can't dup Multiton #{self}"
+  end
+
+  protected  #  default marshalling strategy
+  def _dump(depth=-1)
+    Marshal.dump(@multiton_initializer)
+  end
+end
+
+class << Multiton
+  private
+  def append_features(mod)
+    #  help out people counting on transitive mixins
+    unless mod.instance_of?(Class)
+      raise TypeError, "Inclusion of Multiton in module #{mod}"
+    end
+    super
+  end
+
+  def included(klass)
+    # gracefully handle multiple inclusions of Multiton
+    unless class << klass; include?(Multiton::ClassMethods) end
+      klass.private_class_method  :new,:allocate
+      klass.extend Multiton::ClassMethods
+    end
+  end
+end
+
+module Multiton::ClassMethods
+  def instance(*e)
+    arg = multiton_id(e)
+    @multiton_instance.fetch(arg) {
+      @multiton_mutex[arg].synchronize {
+        @multiton_instance.fetch(arg) {
+          val = @multiton_instance[arg] = new(*e)
+          val.instance_variable_set(:@multiton_initializer,e)
+          @multiton_mutex.initialized(arg)
+          val
+    }}}
+  end
+
+  def initialized?(*e)
+    @multiton_instance.key?(multiton_id(e))
+  end
+
+  protected
+  def reinitialize
+    @multiton_instance.clear
+    @multiton_mutex.clear
+  end
+
+  def _load(str)
+    instance(*Marshal.load(str))
+  end
+
+  private
+  def multiton_id(e)
+    e
+  end
+
+  def initialize_copy(orig)
+    super
+    Multiton::ClassMethods.extended(self)
+  end
+
+  def inherited(sub)
+    super
+    Multiton::ClassMethods.extended(sub)
+  end
+end
+
+class << Multiton::ClassMethods
+  protected
+  def extended(klass)
+    klass.class_eval do
+      @multiton_instance = Hash.new
+      @multiton_mutex = InstanceMutex.new
+
+      private
+      # Defining  marshal_dump & marshal_load instance methods introduces
+      # a loop hole to create additonal instances. Providing a private
+      # marshal_dump method forces Ruby to fall back on the _dump & _load
+      # marshalling scheme. When $VERBOSE == true issue a method re-
+      # definition warning for (re)defining marshal_dump.
+      def marshal_dump(depth = -1)
+        raise TypeError, "don't use marshal_load + marshal_dump marshalling"
+      end
+    end
+  end
+
+  class InstanceMutex < Hash
+    def initialize
+      @global = Mutex.new
+    end
+
+    def initialized(arg)
+      store(arg,DummyMutex)
+    end
+
+    def (DummyMutex = Object.new).synchronize
+      yield
+    end
+
+    def default(arg)
+      @global.synchronize { fetch(arg) { store(arg,Mutex.new) }}
+    end
+  end
+end
+
+
+
+
+### Simple marshalling test #######
+class A
+  def initialize(a,*e)
+    @e = a
+  end
+
+  include Multiton
+
+end
+
+
+
+
+C = Class.new(A.clone)
+s = C.instance('a','b')
+
+raise unless Marshal.load(Marshal.dump(s)) == s
+
+
+### Interdependent initialization example and threading benchmark ###
+
+class Regular_SymPlane
+  def self.multiton_id(e)
+      a,b = e
+      (a+b - 1)*(a+b )/2  + (a > b ? a : b)
+  end
+
+  def initialize(a,b)
+    klass = self.class
+    if a < b
+      @l =  b > 0 ?  klass.instance(a,b-1) : nil
+      @r =  a > 0 ?  klass.instance(a-1,b) : nil
+    else
+      @l =  a > 0 ?  klass.instance(a-1,b) : nil
+      @r =  b > 0 ?  klass.instance(a,b-1) : nil
+    end
+  end
+
+  include Multiton
+end
+
+
+
+def nap
+  # Thread.pass
+  sleep(rand(0.01))
+end
+
+class SymPlane < Regular_SymPlane
+  @m = Mutex.new
+  @count = 0
+end
+
+class << SymPlane
+  attr_reader :count
+  def reinitialize
+    super
+    @m = Mutex.new
+    @count = 0
+  end
+  def inherited(sub_class)
+    super
+    sub_class.instance_eval { @m = Mutex.new; @count = 0 }
+  end
+
+  def multiton_id(e)
+    nap()
+    super
+  end
+
+  def new(*e)
+    super
+  ensure
+    nap()
+    @m.synchronize { p @count if (@count += 1) % 15 == 0 }
+  end
+
+  def run(k)
+    threads = 0
+    max = k * (k+1) / 2
+    puts ""
+    while count() < max
+      Thread.new { threads+= 1; instance(rand(30),rand(30)) }
+    end
+    puts "\nThe simulation created #{threads} threads"
+  end
+end
+
+
+require 'Benchmark'
+include Benchmark
+
+bmbm do |x|
+  x.report('Initialize 465 SymPlane instances') { SymPlane.run(30) }
+  x.report('Reinitialize ') do
+    sleep 3
+    SymPlane.reinitialize
+  end
+end
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+module Multiton
+  #  disable build-in copying methods
+  def clone
+    raise TypeError, "can't clone Multiton #{self}"
+  end
+
+  def dup
+    raise TypeError, "can't dup Multiton #{self}"
+  end
+
+  protected  #  default marshalling strategy
+  def _dump(depth=-1)
+    Marshal.dump(@multiton_initializer)
+  end
+end
+
+class << Multiton
+  private
+  def append_features(mod)
+    #  help out people counting on transitive mixins
+    unless mod.instance_of?(Class)
+      raise TypeError, "Inclusion of Multiton in module #{mod}"
+    end
+    super
+  end
+
+  def included(klass)
+    # gracefully handle multiple inclusions of Multiton
+    unless class << klass; include?(Multiton::ClassMethods) end
+      klass.private_class_method  :new, :allocate
+      klass.extend Multiton::ClassMethods
+    end
+  end
+end
+
+
+module Multiton::ClassMethods
+  class SyncHash < Hash
+    def initialize
+      @global = Mutex.new
+      super {|a,b| @global.synchronize {|| fetch(b) {|| a[b]= yield }}}
+    end
+  end
+
+  PoolInstance = SyncHash.new{ Hash.new }
+  PoolInstanceMutex = SyncHash.new{ SyncHash.new{ Mutex.new }}
+  def (DummyMutex = Object.new).synchronize
+    yield
+  end
+
+  def instance(*e)
+    arg = multiton_id(e)
+    (@multiton_instance ||= PoolInstance[self]).fetch(arg) {
+      (@multiton_mutex ||= PoolInstanceMutex[self])[arg].synchronize {
+        @multiton_instance.fetch(arg) {
+          val = @multiton_instance[arg] = new(*e)
+          val.instance_variable_set(:@multiton_initializer,e)
+          @multiton_mutex[arg]= DummyMutex
+          val
+    }}}
+  end
+
+  def initialized?(*e)
+    # the method is not thread safe ...
+    (@multiton_instance ||= PoolInstance[self]).key?(multiton_id(e))
+  end
+
+  protected
+  def reinitialize
+    (@multiton_instance ||= PoolInstance[self]).clear
+    (@multiton_mutex ||= PoolInstanceMutex[self]).clear
+  end
+
+  def _load(str)
+    instance(*Marshal.load(str))
+  end
+
+  private
+  def multiton_id(e)
+    e
+  end
+
+  # Defining  marshal_dump & marshal_load instance methods introduces
+  # a loop hole to create additonal instances. Providing a private
+  # marshal_dump method forces Ruby to fall back on the _dump & _load
+  # marshalling scheme. When $VERBOSE == true issue a method re-
+  # definition warning for (re)defining marshal_dump.
+  def self.extended(klass)
+    klass.class_eval do
+      private
+      def marshal_dump(depth = -1)
+        raise TypeError, "don't use marshal_load + marshal_dump marshalling"
+      end
+    end
+  end
+  private_class_method :extended
+
+end
+
+
+
+
+
+
+
+
+### Simple marshalling test #######
+class A
+  def initialize(a,*e)
+    @e = a
+  end
+
+  include Multiton
+
+end
+
+
+
+
+C = Class.new(A.clone)
+s = C.instance('a','b')
+
+raise unless Marshal.load(Marshal.dump(s)) == s
+
+
+### Interdependent initialization example and threading benchmark ###
+
+class Regular_SymPlane
+  def self.multiton_id(e)
+      a,b = e
+      (a+b - 1)*(a+b )/2  + (a > b ? a : b)
+  end
+
+  def initialize(a,b)
+    klass = self.class
+    if a < b
+      @l =  b > 0 ?  klass.instance(a,b-1) : nil
+      @r =  a > 0 ?  klass.instance(a-1,b) : nil
+    else
+      @l =  a > 0 ?  klass.instance(a-1,b) : nil
+      @r =  b > 0 ?  klass.instance(a,b-1) : nil
+    end
+  end
+
+  include Multiton
+end
+
+
+
+def nap
+  # Thread.pass
+  sleep(rand(0.01))
+end
+
+class SymPlane < Regular_SymPlane
+  @m = Mutex.new
+  @count = 0
+end
+
+class << SymPlane
+  attr_reader :count
+  def reinitialize
+    super
+    @m = Mutex.new
+    @count = 0
+  end
+  def inherited(sub_class)
+    super
+    sub_class.instance_eval { @m = Mutex.new; @count = 0 }
+  end
+
+  def multiton_id(e)
+    nap()
+    super
+  end
+
+  def new(*e)
+    super
+  ensure
+    nap()
+    @m.synchronize { p @count if (@count += 1) % 15 == 0 }
+  end
+
+  def run(k)
+    threads = 0
+    max = k * (k+1) / 2
+    puts ""
+    while count() < max
+      Thread.new { threads+= 1; instance(rand(k),rand(k)) }
+    end
+    puts "\nThe simulation created #{threads} threads"
+  end
+end
+
+
+require 'Benchmark'
+include Benchmark
+
+bmbm do |x|
+  x.report('Initialize 465 SymPlane instances') { SymPlane.run(30) }
+  x.report('Reinitialize ') do
+    sleep 3
+    SymPlane.reinitialize
+  end
+end