facets 2.9.2 → 2.9.3

data/work/sandbox/multidispatch0.rb

@@ -1,224 +0,0 @@
-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

@@ -1,590 +0,0 @@
-
-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