Rubyの型システム (第1回)

DSLを作ったりするために、Rubyの型システムについて整理してみます。Ruby 1.8ベースです。

Rubyのクラス

Rubyはクラスベース (class-based) のオブジェクト指向言語です。

クラスを雛形として、クラスからオブジェクトを生成します。メジャーなプログラミング言語ではよくあるやり方です。

クラスベースでないのは、プロトタイプベース (prototype-based) と呼ばれ、あるオブジェクトからコピーして別のオブジェクトを生成します。

Rubyはクラスもオブジェクトなのが変わっています。例えば、メソッド呼び出しの引数として、オブジェクトと同じ形でクラスを渡すこともできます。

JavaやC++では、クラスはオブジェクトではないので、このようなことはできません。

クラスとClassクラス

クラスは次のようにして定義します。 

class クラス名 < スーパークラス名
  クラス定義...
end

「< スーパークラス名」を省略すると、自動的に Object のサブクラスになります。スーパークラスを持たないクラスを新しく作ることはできません。ただし, Object クラスにはスーパークラスはありません。

(2019.9) Ruby 2.5では, Object のスーパークラスは BasicObject クラスであり, BasicObject クラスはスーパークラスがありません。

クラスからオブジェクトを生成することをインスタンス化といい、そうやって生成したオブジェクトのことを、クラスと対比して「インスタンス」と呼ぶこともあります。

Rubyではクラスは Class クラスのインスタンスです。次のようにしてもクラスを生成できます。 

クラス名 = Class.new(スーパークラス名)

クラスに変わりないので、このようにして作ったクラスでも普通にインスタンス化することもできます。次の例では, N はクラスです。

Ruby
[RAW]
  1. N = Class.new
  2. k = N.new
  3. p k #=> #<N:0x...>

逆に, オブジェクト (インスタンス) からは#classメソッドでクラスオブジェクトを得ることができます。

Ruby
[RAW]
  1. class C; end
  2. i = C.new
  3. p i #=> #<C:0x...>
  4. p i.class #=> C
  5. p i.class.class #=> Class
  6. p i.class.class.class #=> Class

クラスもオブジェクトなので, class メソッドを持っています。クラスのclassメソッドはClassクラスを返します。Classクラス (これもオブジェクト) のクラスはClassクラスで、ここでループしています。

[[図1]]

メソッド定義

オブジェクトはメソッドを持てます。def ... end でメソッドを定義します。

Ruby では, 見た目, インスタンスメソッドとクラスメソッドがあります。インスタンスメソッドはインスタンスに対して呼び出すようなメソッド, クラスメソッドはクラスに対して呼び出すようなメソッドです。

Rubyでは、クラス定義のなかでも普通に文が書け、クラス定義のときに実行されます。

Ruby
[RAW]
  1. class C
  2. # 文を書ける
  3. p self #=> C
  5. # クラスメソッド.「def C.f」と書いてもよい (self = Cなので).
  6. def self.f
  7. p self #=> この例ではC. ただし、継承すると違う場合あり
  8. end
  10. # インスタンスメソッド
  11. def g
  12. p self #=> #<C:0x...>
  13. end
  14. end

さらに, Rubyでは, クラスを通じてではなく, 一つ一つのオブジェクトに直接メソッドを定義するようにも書けます。

Ruby
[RAW]
  1. class C; end
  2. i = C.new
  4. # レシーバ.メソッド名
  5. def i.f
  6. p self #=> #<C:0x...>
  7. end
  9. i.f

実際には, クラスメソッドは, クラスのクラスのインスタンスメソッドです。

さらに, オブジェクトのメソッドは, 内部でこっそり無名クラスが作られた上で, その無名クラスのインスタンスメソッドになります。オブジェクトのクラスが差し替えられます。(特異クラス; 後述)

def ... end の内側では, 定義したときのではなく, メソッドが呼び出されたときのレシーバ (上記の例では変数 iが指すオブジェクト) がselfになります。

インスタンスメソッドは、インスタンス化したオブジェクトに付けるためのメソッドで、インスタンス化して初めて呼び出せるようになります。

Ruby
[RAW]
  1. i = C.new
  2. i.g

クラスメソッドは、クラスというオブジェクトに付けるメソッドなので、次のように呼び出します。

Ruby
[RAW]
  1. C.f

Rubyでは、既存のクラスに後からメソッドを追加できます。例として、Classクラスにインスタンスメソッドを追加してみます。

Ruby
[RAW]
  1. class Class
  2. def s; end
  3. end
  5. class T; end
  7. # TはClassクラスのインスタンス
  8. T.s
  10. # ClassはClassクラスのインスタンスでもある
  11. Class.s

インスタンス変数

オブジェクトのメンバの変数をインスタンス変数といいます。Rubyでは、JavaやC++と違い、オブジェクトのメンバをあらかじめ宣言する必要はありません。

インスタンス変数は, インスタンスごとに格納されます。たとえクラスが同じでも, インスタンス間で共有されません。

インスタンス変数は「@変数名」と書き、実行時の selfが指すオブジェクトに格納されます。

Ruby
[RAW]
  1. class C
  2. @u = 50
  4. def self.f
  5. # この例ではself = Cなので、Cのメンバ
  6. @v = 100
  7. end
  9. def self.g
  10. p "#{@v}, #{@u}"
  11. end
  13. # インスタンスメソッド
  14. def s
  15. @v = 500
  16. end
  17. end
  19. C.f
  20. i = C.new # iはCのインスタンス
  21. i.s
  23. C.g #=> 100, 50
  25. def i.t; p @v; end
  26. i.t #=> 500

この例では、f(), g() が呼び出されるときのselfはCなので、@u は g() のなかからアクセスできます。(継承した場合は後述)

同じ「@v」と書いていても、s() はインスタンスメソッドなので、呼び出されるときのレシーバ (= self) は、上の例では, iが指すオブジェクトになります。

注意したいのは, Rubyでは実行時にインスタンス変数が確保されるため, 継承 (すぐ後で説明。) との関係で, スーパークラスで定義したインスタンス変数がサブクラスのインスタンスで何もせずに使えるわけではない, ということ。スーパークラスのメソッドを呼び出して, インスタンス変数を確保してやらなければならない。

[[TODO: 例]]

継承

クラスは継承できます。

継承されるほうのクラスを基底クラスあるいはスーパークラス、継承するほうのクラスを派生クラスまたはサブクラスといいます。

クラスの継承は、メソッド呼び出しの探索経路にスーパークラスのメソッドを加える、という意味です。

Ruby
[RAW]
  1. class B
  2. def f; p "B::f" end
  3. def f2; p "B::f2" end
  4. end
  6. # クラスの派生
  7. class D < B
  8. # 基底クラスのインスタンスメソッドを隠す
  9. def f; p "D::f"; end
  10. end
  12. class D2 < B
  13. def f; p "D2::f"; end
  14. end
  16. i = D.new
  17. i.f #=> D::f
  19. # メソッド検索にB (基底クラス) が加わるので、Bで定義したメソッドも呼び出せる
  20. i.f2 #=> B::f2
  22. # クラスオブジェクトはただ一つだけしか生成されず、派生するクラスで共有される
  23. p B.object_id #=> 70167453374980
  24. p D.object_id #=> 70167453374920
  25. p D.superclass #=> B
  26. p D.superclass.object_id #=> 70167453374980
  27. p D2.superclass.object_id #=> 70167453374980

上の例で, スーパークラスというオブジェクトとサブクラスというオブジェクトはあくまでも別のオブジェクトということに注意してください。インスタンスは, スーパークラスに基づく部分とサブクラスに基づく部分を両方含みます。

継承によって、スーパークラスオブジェクトがコピーされたりはしません。

インスタンス変数はオブジェクトに属しますから, 当然, クラスのインスタンス変数が混ざったりもしません。

Ruby
[RAW]
  1. class A
  2. @a = 10
  4. # 落とし穴:: 呼び出されるときのselfはAとは限らない
  5. def self.a; @a end
  7. def self.a_
  8. p self
  9. # Aだと明記すればAオブジェクトのインスタンス変数が取れる
  10. A.instance_variable_get('@a')
  11. end
  12. end
  14. class B < A
  15. @a = 20
  16. end
  18. class C < A
  19. @a = 5
  20. end
  22. class D < A; end
  24. # インスタンス変数は共有されない
  25. p A.a #=> 10
  26. p B.a #=> 20
  27. p C.a #=> 5
  29. # スーパークラスのインスタンス変数は見えない
  30. p D.a #=> nil
  32. p D.a_ #=> D 10

クラスメソッドのなかでインスタンス変数を使ったときに、派生クラスのインスタンス変数にアクセスしてしまうのは、ちょっと字面から想像できません。メソッド定義のときにはself = Aなのでなおさらです。

考えてみると、クラスというオブジェクトにメソッドを付けているような字面なのに、サブクラスをレシーバにしても呼び出せるのが違和感の元のように思います。

とはいうものの、この挙動は、実用的な利点もあります。

次の例は、MF Bliki: ClassInstanceVariable のサンプルを一部修正したものです。

これはスーパークラスでクラスメソッドを定義していますが、インスタンス変数はサブクラスのものを用います。

Ruby
[RAW]
  1. class Employee
  2. # 呼び出されるときは, selfはサブクラス
  3. def self.instances= x; @instances = x end
  4. def self.instances; @instances end
  6. def store
  7. # selfはサブクラスのインスタンス
  8. self.class.instances ||= []
  9. self.class.instances << self
  10. end
  12. def initialize name; @name = name end
  13. end
  15. class Overhead < Employee; end
  16. class Programmer < Employee; end
  18. Overhead.new('Martin').store
  19. Overhead.new('Roy').store
  20. Programmer.new('Erik').store
  22. puts Overhead.instances.size #=> 2
  23. puts Programmer.instances.size #=> 1

特異クラス (singleton class)

オブジェクトに直接メソッドを付けようとすると、内部でこっそり、そのオブジェクト専用の特異クラスが生成されます。

上の、違和感のあったクラスメソッドは、次のように考えればスッキリします。

1. クラスCにクラスメソッドを付けようとすると、特異クラス (仮にMetaCとします。) が生成され、Cはその特異クラスのインスタンスになります。

2. クラスDの特異クラス (仮にMetaD) のスーパークラスはMetaCになります。

3. クラスCはMetaCのインスタンスであり、クラスDはMetaDのインスタンスなので、そのインスタンス変数はそれぞれ別のものです。

4. クラスDをレシーバにしてクラスメソッドを呼び出す場合、MetaD, MetaCの順で検索されます (クラスのインスタンスメソッドをスーパークラスの方向へ辿る)。

特異クラスは、次の構文で明示的に定義できます。 

class << オブジェクト
  ...
end

Rubyでは、特異クラスすらオブジェクトです。

Ruby
[RAW]
  1. class C
  2. # selfはC
  3. class << self
  4. p self #=> #<Class:C>
  5. p self.object_id #=> 70240027190120
  7. # 特異クラスのインスタンスメソッド
  8. def f
  9. end
  10. end
  11. end
  13. class D < C
  14. class << self
  15. p "#{self}, #{self.object_id}" #=> #<Class:D>, 70240027190040
  16. p "#{self.superclass}, #{self.superclass.object_id}"
  17. #=> #<Class:Class>, 70240027262160
  18. p "#{self.class}, #{self.class.object_id}"
  19. #=> Class, 70240027262220
  20. end
  22. p self.class.object_id #=> 70240027262220
  23. end
  25. # クラスメソッドとして呼び出せる
  26. D.f

Dの特異クラスのスーパークラスはClassの特異クラスになっています。惜しい。惜しすぎる。

[Note.] Ruby 1.9では、D の特異クラスのスーパークラスはCの特異クラスになっている、ようです。Rubyのメタクラス階層について再び - 世界線航跡蔵

「def オブジェクト.メソッド」という書き方のメソッド定義のほうが一貫性がないような気がします。

クラス変数

クラスのインスタンス変数はそれはそれで意味がありますが、クラスのインスタンス全部で変数を共有したい場合もあります。

クラス変数は、クラス、そのサブクラス、それらのインスタンスで共有されます。

Ruby
[RAW]
  1. class C
  2. @@v = 1
  4. def self.cvar; @@v end
  5. def icvar; @@v end
  6. end
  8. class D < C
  9. @@v = 2
  10. end
  12. p C.cvar #=> 2
  13. p D.cvar #=> 2
  14. p C.send :class_variable_get, '@@v' #=> 2
  16. i = D.new
  17. p i.icvar #=> 2

Rubyでは、メソッドや変数がどのオブジェクトのものか、という意識が強いのに、クラス変数は、あっさりオブジェクトを跨いでしまっています。むしろグローバル変数に近い。