[dennou-ruby:000189] paramclass.rb

[gotoken@xxxxxx (GOTO Kentaro)]

ごとけんです

そういえばパラメトリッククラスをここに送ってなかったので送り
ます。使いの例として、まず固定長配列というのを先に示します。
パラメトリッククラスを実現するMix-inモジュールParametric自体
はその後にあります。

これを作った主な目的は
 * パラメータをオブジェクトでなくクラスが持った方が良い場合
 * いちいちクラス名を与えるのが面倒な場合

に対処するためです。

主な機能は「クラス名(*params)」で指定されたパラメータparams
をクラスメソッドもしくはメソッドparametersで参照できるという
ものです。parametersの各要素の意味は以下のサンプルのように、
冒頭で定義すると良いでしょう。

また「クラス名(*params)」 はクラスを返しますが、このクラスは
引数に対してユニークなので、リテラルのように扱えます(ただし、
Rubyの文法上、定数に代入しないと特異クラス定義には使えません)。
paramclass.rb 自体を実行すると全機能が実演されます。

必ずしも効率は良くありませんので、C化希望の声が多ければ拡張
モジュールとして作り直す用意はあります。

require "paramclass"

class FixedSizeArray
  include Parametric
  include Enumerable

  def size;           parameters[0];   end
  def default_value;  parameters[1];   end

  def self.[](*args); self.new(*args); end

  def initialize(*args)
    @xxxxxx = args
    s = @xxxxxx
    raise ArgumentError, "Too many initial values" if s > size
    @xxxxxx(default_value, s, size - s)
  end

  def [](n)
    if n < -size or size <= n
      raise IndexError, "index out of range"
    end
    @xxxxxx[n]
  end

  def []=(n,v)
    if n < -size or size <= n
      raise IndexError, "index out of range"
    end
    ary[n] = v
  end

  def each(&blk)
    @xxxxxx(&blk)
  end

  def inspect
    @xxxxxx
  end
end

# example

p a = FixedSizeArray(5, "")["foo", "bar", "baz"]
  #=> ["foo", "bar", "baz", "", ""]
p a.is_a? FixedSizeArray(5, "")
  #=> true


#
# paramclass.rb
#

# begin: class variable emulation by Matz [ruby-dev:8245]
    class Module 
      private
      def module_attr(*names)
	names.each do |name|
	  name = name.id2name unless name.kind_of? String
	  self.module_eval <<-EOS
	  CV_#{name} = []
	  class <<self
	    def #{name}; CV_#{name}[0] end
	      def #{name}=(val); CV_#{name}[0] = val end
	      end
          EOS
	end
      end
    end

    class Class
      private
      alias class_attr module_attr
    end
# end: class variable emulation by Matz [ruby-dev:8245]

module Parametric
  def Parametric.append_features(mod)
    super mod

    # class generating function
    cn = mod.name
    eval "def #{cn}(*args); #{cn}.instance_eval{class_generate(*args)} end", 
         TOPLEVEL_BINDING

    mod.module_eval{
      class_attr :rootclass, :class_parameters, :classes
      @xxxxxx = true
    }

    mod.rootclass = mod
    mod.class_parameters = {}
    mod.classes = {nil => mod}

    def mod.class_generate(*args)
      args = nil if args.empty?
      klass = self::classes[args] || self::classes[args] = Class.new(self)
      klass.class_parameters[klass] = args unless klass.rootclass?
      klass
    end

    def mod.parameters
      if rootclass?
	defined?(default_parameters) ? default_parameters : []
      else
	res = nil
	self.ancestors.find{|i| res = class_parameters[i] }
	res
      end
    end

    def mod.rootclass?
      @xxxxxx
    end
  end

  def parameters
    self.type.parameters
  end
end


########## devel test ##########

if __FILE__ == $0
  def xmp(arg, show = true) # prints expample code and result line by line
    if show
      __res__ = []
      eval arg.gsub(/^(.*)\n?/){ "__res__ << (#{$1}).inspect;" }
      arg.split(/\n/).each_with_index{|l,i|
	(puts "\n" ; next) if l =~ /^$/
	print "#{l}\n    #=> #{__res__[i]}\n"
      }
    else
      print arg; eval arg
    end
  end

  xmp <<-EOS, nil
    class C
      include Parametric

      def C.default_parameters
	[100]
      end
    end

  EOS

  xmp <<-EOS
    C.parameters
    C(10).parameters
    C(10).id == C(10).id
    C(20,10) < C

    C.rootclass
    C(10).rootclass

    C.rootclass?
    C().rootclass?
    C("foo").rootclass?

    D = C(0)
    C(0)
  EOS

  xmp <<-EOS, nil

    class Bar < D; 
      include Parametric
      
      def Bar.default_parameters
	superclass.parameters + [""]
      end
    end

  EOS

  xmp <<-EOS
    Bar.rootclass
    Bar.parameters
    Bar.new.is_a? D
    Bar.new.is_a? C(0)
    Bar.new.is_a? C(10)
  EOS
end