18. Case Study : Imperative Objects Mizukami Tatsuo 2001/06/18

概要 オブジェクト指向の言語をこれまでに学んだ概念を使用して考察する。 Functions Records General recursion Mutable references Subtyping

オブジェクト指向とは？ いくつかの一般的な特徴 Multiple representations Encapsulation Subtyping Inheritance Open recursion

簡単なObjectを作成してみる Instance variableのカプセル化し、オブジェクトを操作するためのインターフェース(Method)を定義する。 c = let r = {x=ref 1} in {get = λ_:Unit. !(r.x), inc = λ_:Unit. (r.x) := succ(!(r.x))};

Objectの型 Objectの型とは、メソッドの名前とその型のレコード 型の省略形 c : {get:Unit -> Nat, inc:Unit->Unit}; 型の省略形 Counter = {get:Unit -> Nat, inc:Unit->Unit}; 上のcの型をCounterと表示するには、ascriptionが必要。(ここでは省略)

Representation Type Objectのinstance variables recordの型をRepresentation typeと呼ぶ。 CounterRep = {x: Ref Nat};

Objectを操作してみる Method Invocationとか、メッセージが投げられると言う。 c.inc unit; > unit : Unit c.get unit; > 2 : Nat (c.inc unit; c.inc unit; c.get unit); > 4 : Nat

コンストラクタ オブジェクトを作成に、毎度関数を定義するのは煩雑。コンストラクタ(Object generators)を使用する。 newCounter = λ_:Unit. let r = {x=ref 1} in {get = λ_:Unit. !(r.x), inc = λ_:Unit, (r.x) := succ(!(r.x))}; > newCounter : Unit -> Counter

Subtyping オブジェクトの型にSubtypingを導入。 ResetCounter = { get:Unit -> Nat, inc:Unit -> Unit, reset:Unit -> Unit}; ResetCounter <: Counter RecordのSubtypingと同じ

Basic class Subtypingの導入により、コードの共通部分を１個所にまとめたくなる (Class) 考慮する特徴 継承によるコードの再利用 late binding of self とりあえず無視 visibility annotations, static fields and method, inner class, friend class, et al.

継承を行うための問題点 以前の定義だと、instance variableが子クラスからも全く使用できない。 Instance variable recordを分離する。 以前のクラス用関数はそのrecordを引数に受け取る。

新しいObjectの作り方 counterClass = λr:CounterRep. {get = .. , inc = ..}; > counterClass : CounterRep -> Counter newCounter = λ_:Unit. let r = {x=ref 1} in counterClass r; > newCounter : Unit -> Counter

子クラスの作り方 親クラスのメソッドを定義してから、子クラスのメソッドを再定義する。 resetCounterClass = λr:ResetCounterRep. let super = counterClass r in {get = super.get, inc = super.inc, reset = λ_:Unit. r.x := 1};

同一クラス内のメソッド呼び出しを導入 本質的には関数の相互再帰と同じ。 11章11節のGeneral Recursionの例 ff = λieio:{iseven:Nat -> Bool, isodd:Nat > Bool} {iseven = λx:Nat if iszero x then true else ieio.isodd (pred x), isodd = ... }; r = fix ff; > r : {iseven:Nat -> Bool, isodd:Nat -> Bool}

Class with Self setCounterClass = λr:SetCounterRep λself: SetCounter {get = .., set = .., inc = λ_:Unit. self.set (succ (self.get unit))}; newSetCounter = λ_:Unit. let r = {x=ref 1} in fix (setCounterClass r);

→ [x -> (fix (λx:T1. t2))]t2 Evaluation rules fix(λx:T1. t2) → [x -> (fix (λx:T1. t2))]t2 t1 → t1’ fix t1 → fix t1’ Typing rules Γ├ t1 : T1 → T1 Γ├ fix t1 : T1

使用例 クラスのインスタンスを作成してみるnewSetCounter unit = fix (setCounterClass r1) ;r1= {x=ref 1} = fix (λself. [r -> r1]F) ;F = {get..,set..,..} = fix (λself. F’) ;F’ = [r -> r1]F = [self -> fix (λself. F’)]F’ ;value

子クラスの再考 以前と同様に実装すると childClass = λr : childRep λself : child let super = parentClass r self in { ... <methods> ... }; > childClass : childRep → child → child コンストラクタでselfにはfix tが代入される。 上の定義ではself (fix t)の評価順序が早すぎて、評価が発散してしまう。　(別紙参照)

継承と相互再帰を可能にするには 解決方法 dummy lambda-abstraction reference new primitive

Dummy lambda-abstraction fix tをλ抽象化し、評価を先送りする selfの型(e.g. child)をthunk(Unit → child)に変更する。 methodのレコードをUnitで抽象化する Method Recordのselfの使用個所を(self unit)に変更する 抽象化により、発散しない。(別紙参照) 実行効率が非常に悪い

サンプルクラス setCounterClass = λr:CounterRep. λself: Unit -> SetCounter {get = λ_:Unit. !(r.x), set = λi:Nat. r.x := i, inc = λ_:Unit. (self unit).set (succ((self unit).get unit))};

Reference fixを使用せずに参照を使用する。 selfをmethods recordへの参照。 コンストラクタの最初ではdummy recordを使用し、コンストラクタの最後でdummy recordを本当のMethodが入ったrecordで上書きする。 fixなしより、評価は発散しない。 詳細は別紙参照

サンプルクラス setCounterClass = λr:CounterRep. λself. Source SetCounter. {get = λ_:Unit. !(r.x), set = λi:Nat. r.x = i, inc = λ_:Unit. (!self).set (succ ((!self).get unit))};

Open Recursion selfを利用した場合、親クラスでのMethod呼び出しが、子クラスの呼び出しに変わる場合がある。