Dartの変数定義時の修飾static/final/const、そしてconst constructorについて

# 2019/09/13追記

[Dart 2.5](https://medium.com/dartlang/announcing-dart-2-5-super-charged-development-328822024970)で「 As of Dart 2.5, we support many more ways to define constant expressions, including the ability to use casts and the new control flow and collection spread features shipped in Dart 2.3:」とのことで以下が可能となりました。本文には反映していません。

```Dart
// Example: these are now valid compile-time constants.
const Object i = 3;
const list = [i as int];
const set = {if (list is List<int>) ...list};
const map = {if (i is int) i: "int"};
```

# はじめに

Dart言語における変数定義時の修飾子には[final、const](https://www.dartlang.org/guides/language/language-tour#final-and-const)、およびstaticがある。
final,const及び型を指定しないことを意味する「var」を指定することもできる。
本記事では、これらの変数修飾子、およびconst constructorについて説明する。

# final指定

finalが指定された変数は、プログラム開始後のある時点で一回だけ初期化され、初期化以降は、代入などを通じて変更されない/できないことが保証される(再代入不可)。なお、finalな変数が「指す先」のメモリ領域の内容が変更されることについての制約はない。

## finalの使用例
```Dart
  final int i = 0;
  i = 2; // Error(再代入不可)
  final List<int> a = [1,2,3];
  a[0] = 4; // OK(指す先は変更可能)
```

# const指定

変数の値が「コンパイル時定数(compile-time constant)」であること、すなわち、コンパイル時に確定している値であることを示すための指定。constな変数の値はプログラムの実行開始に先立って初期化されており、プログラムの実行を通じて不変であることが保証される。const変数は再代入も不可である。つまり、finalの意味に加え、constな変数が指す先のメモリ領域の内容も変更不可であることを表す。

## constの使用例
```Dart
  const int i = 0;
  i = 2; // Error(再代入不可)
  const List<int> a = [1,2,3]; // OK ※1
  const List<int> b = const [1,2,3]; // OK(const値)
  b[0] = 4; // コンパイルエラー(指す先も変更不可)
```
※1 コメント欄にてご指摘いただき修正しました。以前のDartでは配列リテラルに明示的にconstを付けないとconstなListを初期化できずコンパイルエラーだったのが、現在はコンパイルエラーにならないとのことです(むしろ付けない方が推奨)。

# コンパイル時定数

const指定された変数を含み、より一般的な概念が「コンパイル時定数(compile-time constant)[^2]」である。以下はコンパイル時定数として扱うことのできる要素である。const指定する変数の値の初期化値はコンパイル時定数である必要がある。

[^2]: 「const値」でも通じると思われる。

* 数値リテラル
   * 例: `1.0`
   * 例: `3`
* 文字列リテラル
   * 例: `"abc"`
* boolean型リテラル
   * 例: `true`, `false`
* const指定された定数
   * 例: `myConst`
* null値
   * 例: null
* constなリストリテラル(型はListBase&&UnmodifiableListMixin)。当然ながら要素もコンパイル時定数である必要がある。
   * 例: `const [1,2,3]`
* constなマップリテラル(型は_ImmutableMap)。当然ながら要素もコンパイル時定数である必要がある。
   * 例: `const {"a":1, "b":2}`
* コンパイル時定数のみから成る演算式(の結果の値)
  * 例1: コンパイル時定数
     * 例: `2+3`
     * 例: `"abc"+"def"`
  * 例2: const指定された定数
     * 例： `myConst1 + myConst2+5`
     * 例： `myConst1 && myConst2`
  * 例3
     * 例: `3 == 4 ? "a" : "b"`
* コンパイル時定数の文字列テンプレート展開
   * 展開される値が定数ならテンプレート文字列はconstになれる。
   * 例：
     * `const a = "world"; const b = "hello ${a}"` --- OK
     * `var a = "world"; const b = "hello ${a}"` --- NG(コンパイル時エラー)
* const constructor(後述)の呼び出し。const constructorに与える引数(finalフィールドに設定するための値)はコンパイル時定数である必要がある。
   * 例： `const ClassWithConstantConstructor(1, "abc", [1,2,3])`
* 関数や静的メソッドの参照
   * 例:
      ```
      import 'dart:math';
      const f = min;
      ```

以下はコンパイル時定数にはならない。

* 乱数値など呼び出す度に変化する値や式
* 評価するために入出力の副作用を伴う式
* ランタイムにメモリ上にアロケートされる値(newで構築されるオブジェクトインスタンス)
* 値の計算に静的関数やメソッドの呼び出し結果を必要とする値
   * たとえば`const [1,2,3].length`
   * たとえばリストの結合やマップの併合
   * n回の繰り返し(たとえnがコンパイル定数であろうとも)。

コンパイル時定数の実行時モデルとしては、ROM領域もしくは「初期化された静的定数領域」に、領域内のポインタ参照構造を含めて配置されることを想定すれば良いと思われる。

全体としては、残念ながら皆が期待するところのコンパイル時プログラミングの用には供せないのではないかと思う(が定かではない)。

## const constructor

前項で示した[const constructorの呼び出し](https://www.dartlang.org/guides/language/language-tour#constant-constructors)は、以下のようにconst constructorが定義されたクラス定義を前提とした例である。

```dart
class ClassWithConstantConstructor{
  final int n;
  final String s;
  final List l;
  const ClassWithConstantConstructor(this.n, this.s, this.l); // const constructor
}
```

const constructorは通常のコンストラクタとは異なり、ボディを持つことができない。
前項の例でも示したように、const constructorの呼び出しは通常のコンストラクタ呼び出しで使用するnewの代りにconstキーワードを使用する。

```dart
var x = const ClassWithConstantConstructor()
```

<del>クラスには、const constructorと通常のconstructorの両方を定義することもできる。
Dart2ではインスタンス生成のためのキーワードnew、constが省略できるが、constの文脈ではconst constructorが、非constの文脈では通常のconstructorが呼び出される。</del>(訂正)クラスには、同一名のconst constructorと通常のconstructorの両方を定義することはできない(重複定義となり構文エラーとなる)。一方を名前付きコンストラクタにする、異なる名前の名前つきコンストラクタにするなどすれば、1つのクラスが通常のconstructorとconst constructorの両方を持つことができる。

const constructorを使うことで、「コンパイル時に定まるDAG構造[^1]」のリテラルを表現することができる。
なお、構造をもったコンパイル時定数(DAG構造、リスト、マップを含め)一般に、これらの構造はinternされる。すなわち値や構造が一致していればオブジェクトインスタンスが一致していることが保証される。

internされることは、コンパイル時定数がswitch-case文のcase節に利用できることに関連して重要である。

[^1]: 枝を共有できるので(次に例を示す)、ツリー以外のDAGも表現できる。なお、循環構造は表現できないようである(確信はないけど。もしできるのであれば教えて欲しい)。

## const constructorの例
```dart
class Cons {
  final dynamic car;
  final Cons cdr;
  const Cons(this.car, [this.cdr=null]);
  @override
  String toString() =>
     "(${this.car} . ${this.cdr == null ? "nil" : this.cdr.toString()})";

}

main() {
  const Cons list1 = Cons(1, Cons(2));
  const Cons list2 = Cons(list1, Cons(list1));
  const Cons list3 = Cons(Cons(1, Cons(2)), Cons(Cons(1, Cons(2))));

  print(list2); // ((1 . (2 . nil)) . ((1 . (2 . nil)) . nil))
  print(list3); // ((1 . (2 . nil)) . ((1 . (2 . nil)) . nil))
  print(list2 == list3); // 値が等しいのでtrueが表示される。
  print(identical(list2, list3)); // オブジェクトが等しいのでtrueが表示される(internされている)。
}
```

# constとfinalの違い

- finalは***変数の性質***なので、「final変数に代入できない」など、代入の左辺になったときの***変数としての扱い***について差異が生じる。しかし、final変数の保持する***値***には影響を与えない。たとえば、「〜には、final変数の***値を***代入できない(orできる)」「〜の場合の引数には、final変数の***値を***渡せない」といったfinal指定起因の***値***に対する制約はない。
- constは***変数の性質***でもあることに加えて、const変数が保持する***値の性質***も規定している(つまり値は「コンパイル時定数」であることを意味している)ので、const変数の***値を***他の変数に代入したり、関数の引数として***値を***渡したりするときに、constが付く・付かないで制約回避できる・できないといった差異が生じる場合がある。たとえば、以下の状況に使用できるのはコンパイル時定数のみである。
   - const変数に代入
   - 省略可能パラメタのデフォルト値
   - switch case文のcase節の式

# static指定

クラスのフィールド変数に指定し、その変数がインスタンスごとに保持されるのではなく、クラスで1つの実体を持つことを宣言する。

なお、Dart言語では関数ローカルなstatic変数や、関数の外側でのstatic指定は文法上使用できず、クラススコープのstaticのみが文法上許されている。CやC++における、名前空間のコントロールのためのstaticや、C/C++/Javaにおける「可視範囲は関数ローカルだが生存期間はグローバルであることを意味するstatic」はDartでは使用できない。

## staticの例
```Dart
class Test {
  static int i1;
  static var i2;
  static final int i3 = 3;
  static const int i4 = 4;
}
static int i5;  // Error
main() {
  static int i6; // Error
}
```

# (余談)Dartでの可視性の制御

前節で示したように、C/C++における「モジュールローカル」を意味するstaticの用法はDartには無い。Dartでのモジュール(ライブラリ)ローカルの指定は、大域変数の変数名をアンダースコア(下線, '_')で始めることで実現される。同様に、可視性をクラス内に限定するためにはフィールドやメソッド名をアンダースコアで開始する。

```Dart
final int _modulePrivate = 0; // 他モジュールに公開されない変数

class _SomeClass { // 他モジュールに公開されないクラス
  int _num;  // クラス外から不可視なフィールド
}
```

# 変数の初期化タイミング

ローカル変数は、関数が呼びだされ、その変数が宣言されているブロックに処理が入った時点で値が初期値指定があれば、その値で初期化される。この事はfinal、const、varを通じて同じである。ただし、constなローカル変数の初期化式はコンパイル時定数であることが必要である。

初期化式を伴なって宣言されたconstではない大域変数、クラス変数(static変数)は、その変数の***初回参照時***に初期化式が評価され、値が確定する(Lazyな初期化)。constとは異なり、任意の初期化式が指定可能である。

初期化指定のある大域変数やクラス変数を***初回参照する前***に代入したとき、初期化式は評価されず、代入する値に設定される。このことは直感的ではないかもしれないので再度強調しておくと、__初期化式を伴なって宣言された大域変数やstatic変数を「参照する前に代入する」と、初期化がスキップされる。初期化式が関数呼び出しを含むのであれば、それは実行されない__ということである。

# 表にまとめると

<table>
<thead>
<tr>
<th style="text-align: left">指定</th>
<th style="text-align: left">変数への再代入</th>
<th style="text-align: left">スコープ</th>
<th style="text-align: left">変数値の設定タイミング</th>
<th style="text-align: left">初期化/代入できる値</th>
<th style="text-align: left">変数の指す先の破壊的変更</th>
</tr>
</thead>
<tbody>
<tr>
<td style="text-align: left" rowspan="3">varもしくはなし</td>
<td style="text-align: left" rowspan="3">可</td>
<td style="text-align: left">大域</td>
<td style="text-align: left">初回参照時(Lazy)か代入時</td>
<td style="text-align: left" rowspan="3">任意</td>
<td style="text-align: left" rowspan="3">可</td>
</tr>
<tr>


<td style="text-align: left">ローカル</td>
<td style="text-align: left">初期化</td>


</tr>
<tr>


<td style="text-align: left">クラス</td>
<td style="text-align: left">コンストラクタでの初期化時、代入時</td>


</tr>
<tr>
<td style="text-align: left" rowspan="3">final</td>
<td style="text-align: left" rowspan="3">不可</td>
<td style="text-align: left">大域</td>
<td style="text-align: left">初回参照時(Lazy)</td>
<td style="text-align: left" rowspan="3">任意</td>
<td style="text-align: left" rowspan="3">可</td>
</tr>
<tr>


<td style="text-align: left">ローカル</td>
<td style="text-align: left">初期化時</td>


</tr>
<tr>


<td style="text-align: left">クラス</td>
<td style="text-align: left">コンストラクタでの初期化時</td>


</tr>
<tr>
<td style="text-align: left" rowspan="2">const</td>
<td style="text-align: left" rowspan="2">不可</td>
<td style="text-align: left">大域</td>
<td style="text-align: left" rowspan="2">コンパイル時に確定</td>
<td style="text-align: left" rowspan="2">コンパイル時定数式</td>
<td style="text-align: left" rowspan="2">不可</td>
</tr>
<tr>


<td style="text-align: left">ローカル</td>



</tr>
<tr>
<td style="text-align: left">static var(あるいは単にstatic)</td>
<td style="text-align: left">可</td>
<td style="text-align: left" rowspan="3">クラス</td>
<td style="text-align: left">初回参照時(Lazy)か代入時</td>
<td style="text-align: left" rowspan="2">任意</td>
<td style="text-align: left" rowspan="2">可</td>
</tr>
<tr>
<td style="text-align: left">static final</td>
<td style="text-align: left">不可</td>

<td style="text-align: left">初回参照時(Lazy)</td>


</tr>
<tr>
<td style="text-align: left">static const</td>
<td style="text-align: left">不可</td>

<td style="text-align: left">コンパイル時に確定</td>
<td style="text-align: left">コンパイル時定数式</td>
<td style="text-align: left">不可</td>
</tr>
</tbody>
</table>

<!--
|指定|変数への再代入|スコープ|変数値の設定タイミング|初期化/代入できる値|変数の指す先の破壊的変更|
|:-- |:-- |:--|:--|:--|:--|:--|
|varもしくはなし|可|大域|初回参照時(Lazy)か代入時|任意|可|
|||ローカル|初期化時|||
|||クラス[*1]|コンストラクタでの初期化時、代入時|||
|final|不可|大域|初回参照時(Lazy)|任意|可|
|||ローカル|初期化時|||
|||クラス[*1]|コンストラクタでの初期化時|||
|const|不可|大域|コンパイル時に確定|コンパイル時定数式|不可
|||ローカル||||
|static var(あるいは単にstatic)|可|クラス|初回参照時(Lazy)か代入時|任意|可
|static final|不可||初回参照時(Lazy)|||
|static const|不可||コンパイル時に確定|コンパイル時定数式|不可|
-->

- スコープが「クラス」は、クラスのフィールドとして定義される変数の意。