LuneScript のクラスは、次をサポートします。

• アクセス制御
• accessor
• 継承
• abstract
• override
• advertise
• Mapping
• interface

今回は基本的なクラス定義を説明します。

最小のクラス定義は次のように行ないます。

// @lnsFront: ok
class Test {
}

これは Test というクラスを定義しています。

なお、クラス定義は最上位のスコープで行なう必要があります。

(2019/6/24) 関数内でもクラス定義できるように対応しました。 ただし、外部公開可能なクラスは最上位のスコープで宣言する必要があります。

// @lnsFront: ok
pub class Test {
}

クラスのインスタンス生成は、次のように new 演算子を使用します。

// @lnsFront: ok
class Test {
}
let test = new Test();

メソッド定義は、ほぼ関数定義と同じです。

// @lnsFront: ok
class Test {
   pub fn func() {
      print( __func__ );
   }
}
let test = new Test();
test.func();  // Test.func

なお、メソッドは form 型にはセットできません。

例えば、次の sub( test.func ) はエラーします。

// @lnsFront: error
class Test {
   pub fn func() {
      print( __func__ );
   }
}
fn sub( foo:form ) {
   foo();
}

let test = new Test();
sub( test.func );  // error

これをエラーしないようにするには、 次のように anonymous 関数を作成して sub() に渡します。

// @lnsFront: ok
class Test {
   pub fn func() {
      print( __func__ );
   }
}
fn sub( foo:form ) {
   foo();
}

let test = new Test();
sub( fn() { test.func(); } );

// @lnsFront: ok
class Test {
   fn func() {
      print( __func__ );
   }
   pub fn sub() {
      self.func();
   }
}
let test = new Test();
test.sub();  // Test.func

// @lnsFront: ok
class Test {
}
pub fn Test.func() {
   print( __func__ );
}
let test = new Test();
test.func();  // Test.func

// @lnsFront: ok
class Test {
   pub fn func();
   pub fn sub() {
      self.func();
   }
}
pub fn Test.func() {
   print( __func__ );
}
let test = new Test();
test.sub();  // Test.func

// @lnsFront: ok
class Test {
   pub static fn sfunc() {
      print( __func__ );
   }
}
Test.sfunc(); // Test.sfunc

メンバ定義は、ほぼ変数定義と同じですが、次の違いがあります。

• 宣言時に初期値の設定が出来ない
• アクセス制御が追加
• accessor 指定が可能

次にメンバ定義の例を示します。

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
   pri let val3:int;
   pub fn func() {
      print( self.val1, self.val2, self.val3 );
   }

}
let test = new Test( 1, 2, 3 );
test.func(); // 1 2 3

クラス Test は、 val1, val2, val3 をメンバに持ちます。

val1 の定義は pri let val1:int; となっています。

これは、 これは通常の変数宣言に pri が付いただけなので問題ないと思います。

pri はアクセス制御で、意味はメソッド定義と同じです。

メンバ、メソッドにも mutable と immutable があります。

メソッドの mutable と immutable の違いは次の通りです。

• mutable なメソッドは、メンバを変更可能なメソッド
• immutable なメソッドは、メンバを変更不可能なメソッド

次に mutable なメンバ、メソッドの例を示します。

// @lnsFront: ok
class Test {
   pri let mut val1:int;
   pri let val2:int;
   pub fn func() {
      print( self.val1, self.val2 );
   }
   pub fn add( val:int ) mut {
      self.val1 = self.val1 + val;
   }
}
let mut test = new Test( 1, 2 );
test.func(); // 1 2
test.add( 10 );
test.func(); // 11 2

この例では、val1 が mutable で val2 が immutable です。 また func() が immutable で、 add() が mutable です。

mutable なメソッドは、引数宣言後に mut を宣言します。

mutable のメソッド add() は、 メンバ val1 に値をセットしています。 これはエラーせずにビルド可能です。

では、次のように メソッド add() の mut 宣言を外した場合はどうなるかというと。

// @lnsFront: error
class Test {
   pri let mut val1:int;
   pri let val2:int;
   pub fn func() {
      print( self.val1, self.val2 );
   }
   pub fn add( val:int ) {
      self.val1 = self.val1 + val;  // error
   }
}

上記の例は、エラーとなります。

mutable でないメソッド内からメンバを変更しようとした場合、エラーします。

次の場合もエラーします。

// @lnsFront: error
class Test {
   pri let mut val:int;
   pub fn increment() mut {
      self.val = self.val + 1;
   }
   pub fn func() {
      self.increment(); // error
   }
}

上記の例では、 func() から increment() をコールしていますが、 immutable なメソッドから mutable なメソッドのコールは出来ません。

前述の通り、 あるクラスのメンバが mutable であっても、 そのクラスのインスタンスが immutable である場合、 そのメンバは immutable となります。

次の例では、 func() メソッド内から mutable なメンバ val にアクセスしていますが、 func() メソッドは immutable であるため val もまた immutable となり、エラーします。

// @lnsFront: error
class Test {
   pri let mut val:int;
   pub fn func() {
      self.val = self.val + 1;  // error
   }
}

mutablity は、意図しないタイミングでの値の変化を防止するために必要な概念です。 一方で、 immutable なメソッドからはいかなるメンバも変更できない、 というのは非常に厳しいルールです。

このルールが適応されてしまうと、 例えば次のような場合、設計が難しくなってしまいます。

• キーに紐付けて、読み取り専用データを管理するクラス Data を考える
• Data クラスには、引数にキーを与えると、紐付けられたデータを返すメソッド get() を定義する
• 管理する全てのデータを登録した Data インスタンスは、不要な変更を防ぐため immutable とする

これは一般的な考え型だと思います。

そして、開発が進んでから次の仕様を追加するとします。

• 上記 get() メソッドの処理を高速化するため、 直前の引数キーと、そのキーに紐付けされたデータをキャッシュする

この「直前の引数キーと、そのキーに紐付けされたデータをキャッシュする」という処理は、 データを書き換えることになります。 つまり、 immutable ではなく mutable である必要があります。

一方で、既に Data インスタンスは多くの箇所で immutable として宣言されています。 つまり、キャッシュすることが出来ません。

このような場合に利用するのが allmut です。 allmut は、メンバの mutablity を宣言し、 インスタンスの mutablity とは独立して常に mutable となります。

次に allmut のサンプルを示します。

// @lnsFront: ok
class Test {
   pri let allmut val:int;
   pub fn func() {
      self.val = self.val + 1;  // ok
   }
}

このように pri let allmut val:int; と宣言することで、 val は常に mutable となります。 これにより、 immutable なメソッド func() から、 val を書き換えることが可能となります。

ただし、allmutはあくまでも救済手段であり多用すべきではありません。

特に、後述する go での非同期プログラミングを行なう際に、 allmut があると安全性が担保されなくなります。

コンストラクタは __init で定義できます。

コンストラクタは、メソッド定義と次の点で異なります。

• コンストラクタ名は __init でなければならない。
• 戻り値の型を指定できない。
• コンストラクタの定義は、全メンバ定義の後にしなければならない。

• クラスを継承している場合、そのクラスのコンストラクタを先頭で実行しなければならない。

  • super クラスのコンストラクタの実行は super() を使用する。

• コンストラクタは、全メンバを初期化しなければならない。

  • nilable 型のメンバを明示的に初期化しない場合、 初期値 nil となります。

• コンストラクタ内の処理で全メンバを初期化してからでなければ、 そのクラスで定義するメソッドにアクセスできない。

  • ただし static メソッド、 super クラスのメソッドにはアクセス可能。
  • また、コンストラクタ内ので定義した関数オブジェクトからはメソッドにアクセス可能。
• コンストラクタ内からは、プロトタイプ宣言しただけのメソッドはコールできない。
• コンストラクタ内で return できない。

次にコンストラクタの例を示します。

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
   pub fn __init() {
      self.val1 = 0;
      self.val2 = 0;
   }
}
let test = new Test();

なお、コンストラクタでは immutable なメンバにも初期値を設定可能です。

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
   pub fn __init( val1:int, val2:int ) {
      self.val1 = val1 + 10;
      self.val2 = val2 + 10;
   }
   pub fn func() {
      print( self.val1, self.val2 );
   }
}
let test = new Test( 1, 2 );
test.func(); // 11 12

// @lnsFront: ok
class Test {
   pri let val1:int;
   pri let val2:int;
}

// @lnsFront: skip
   pub fn __init( val1:int, val2:int ) {
      self.val1 = val1;
      self.val2 = val2;
   }

// @lnsFront: ok
class Test {
   pro let val:int;
}
class Sub extend Test {
   let val2:int;
   pub fn func() {
      print( self.val, self.val2 );
   }
}
let sub = new Sub( 1, 2 );
sub.func(); // 1, 2

// @lnsFront: ok
class Test {
   pro let val:int!;
}
class Sub extend Test {
   let val2:int;
   _lune_control default__init_old;
   pub fn func() {
      print( self.val, self.val2 );
   }
}
let sub = new Sub( 2 );
sub.func(); // nil, 2

// @lnsFront: error
class Test {
   pri let mut val:int {pub};
   pub static fn create(): Test {
      return new Test( 1 );  // error
   }
}

// @lnsFront: ok
class Test {
   pri let mut val:int {pub};
   _lune_control default__init;
   pub static fn create(): Test {
      return new Test( 1 );
   }
}

クラスのインスタンスが開放されるときの処理を定義できます。

// @lnsFront: skip
class Hoge {
   fn __free() {
      print( __func__ );
   }
}
{
   let hoge = new Hoge();
}
collectgarbage(); // print Hoge

メソッドにクラスメソッドがあるように、メンバにもクラスメンバがあります。

クラスメンバの定義も static を付けるだけです。

クラスメンバの初期化は __init ブロックで行ないます。

次はクラスメンバ定義の例です。

// @lnsFront: ok
class Test {
   pri static let val1:int;
   pri static let val2:int;

   __init {
      Test.val1 = 1;
      Test.val2 = 1;
   }
}

__init ブロックは、次の制限があります。

• __init ブロックの定義は、全クラスメンバ定義の後にしなければならない。

  • nilable 型のメンバを明示的に初期化しない場合、 初期値 nil となります。
• __init ブロックは、全メンバを初期化しなければならない。
• __init ブロック内で return できない。
• __init ブロックからクラスメソッドをコールできるが、コールするクラスメソッドは、 __init ブロックより前に宣言しなければならない。

LuneScript のクラス定義は、次をサポートします。

• キーワード class でクラスを定義する
• インスタンス生成は new
• アクセス制御可能
• self シンボルで自分自身にアクセス
• クラス定義とメソッド定義を分離可能
• プロトタイプ宣言
• static でクラスメソッド、クラスメンバ
• コンストラクタは __init
• コンストラクタを作成しない場合はデフォルトコンストラクタが作られる

次回は、 accessor の生成方法について説明します。