本文へ移動
Hikari 仕様

静的解析 (static analysis)

Hikari の静的解析は、評価を開始する前にソースを検査して問題を報告する。次の層から成る。

値の位置の型不明・未確定の型変数・期待型の無い割れた合流、Any の操作、
暗黙の下方変換を静的に検査する。関数型の代入と実行時照合は、検査済みシグネチャの同じ一致規則を使う。

節 層 対象 いつ走るか
§1 構文層の一括検査 パースエラー・import 解決・呼び出さずに書いた制御の綴り 実行前・LSP 診断前(常時)
§2 静的型検査 型的 panic と契約違反 全実行系・hikari check / LSP(常時)
§3 単一化による結果型推論 §2 の基盤(多相な結果型を解く) 型検査中
§4 末尾位置マーキング TCO 用の末尾呼び出し検出 パース直後
§5 診断コードと重大度 診断の安定識別子と Error/Warning の割り当て —

前提: 型注釈の文法と意味は language-spec.md §17、エラーの三層モデルは
同 §16。静的に証明できないアスクリプションは評価地点で照合する。
束縛・パラメーター・結果型の注釈は静的検査で証明し、実行時には照合しない。
各コマンドの挙動は hikari-command.md。

本書で繰り返す用語

型検査(§2〜§3)は、
型が付くと示せないものを受理しない。

  • 健全性: 静的型を割り当てた評価点で、値はその型を満たす。NonZero(T) なら値は 0 でない。
  • 部分型 S <: T: S の値を、下方変換せず T の位置へ渡せる関係。
  • 期待型: 束縛・パラメーター・結果型などの使用先から式へ与える型。
  • Any: すべての型 T が T <: Any を満たす top 型。
    値を受け取れるが、その値へのメンバー参照・演算子・呼び出しはできない。
  • Unknown(型不明): 検査器が型を決められなかった状態。利用者が選ぶ型ではなく、Any とも異なる。
    値の位置に残れば静的エラーになる。
  • 式アスクリプション 値: T: 唯一の明示の下方変換。
    静的に証明できれば照合を省ける。証明できなければ評価地点で照合し、不一致なら型の panic になる。
  • 型検査の backstop: 静的に証明できないアスクリプションの実行時照合。
    通常の注釈への静的な代入証明を肩代わりするものではない。
  • 契約: 型・述語・効果・多重度・網羅性など、受理に必要な条件。
    条件が成立すると示せない場合は静的エラーにする。

1. 構文層の一括検査(実行開始前)

実行(hikari <file> / hikari build)と LSP 診断の前に、entry ファイルを起点とした到達可能な全モジュールを一括で構文検査する。構文層のみを対象とし、1 件でも見つかれば実行を開始しない(exit 1)。

静的エラーとして検出するもの

  • 構文エラー: entry および import 先の各ファイルのパースエラー。
    • 動的 import — import <対象> := "path" の := 右辺が文字列リテラルでないもの(変数・文字列補間 "${...}"・bare 識別子・任意式)— もパーサーが弾く。リテラル限定によりモジュールグラフを実行前に静的確定できる。
  • import の配置: import は宣言形(type / enum と同型)で、ファイルトップレベルの宣言位置にのみ書ける。関数本体・入れ子リテラル内部の import はパーサーが構文エラーにする(配置は文法で担保。別途の placement 検査は持たない)。
  • type / enum の配置: ファイルトップレベルと本体の文に置ける。明示した値リテラルの slot-list と部分式・代入右辺・引数には置けず、構文エラーである(language-spec.md §17.4)。
  • ファイルレベルの構造(language-spec.md §13.1)。ファイル全体が 1 つの slot-list 領域なので、次の 2 つを弾く。
    • (a) ファイルレベルの |: 領域を分けるパイプはファイルには現れない(入れ子リテラルには | を書ける)。パーサーが構文エラーにする
    • (b) デフォルト値を持たないトップレベルのスロット宣言(name: Type だけの形): ファイルオブジェクトはロードで完成するため、未束縛スロットを埋める呼び出し側がいない(analyze で検出)
  • 循環 import: import をたどった先が、たどっている途中のファイルへ戻る場合(analyze で検出)。同じファイルへ別の経路で 2 度到達するだけ(菱形)は循環ではない。
  • import 先不在: import リテラルが解決したパスにファイルが無い場合(analyze で検出。これだけは構文層でなく解決層の検査)。language-spec.md §16.1 の「ファイル不在 = 回復可能エラー」は fs.read 等プログラムが明示的に行う I/O への指針であり、モジュール解決には適用しない(欠落モジュールはロード時の静的エラーである)。
  • 未知の標準ライブラリモジュール: import <対象> := "std:<name>" の <name> が std/index.md に無い場合(analyze で検出)。解決層の静的エラーで、回復可能にはしない。
  • third-party パッケージ解決の失敗: import <対象> := "pkg:<alias>" で次のいずれか(analyze で検出)。解決層の静的エラー。
    • (a) その .hika を含むパッケージにマニフェストが無い
    • (b) <alias> がマニフェストの deps に無い
    • (c) 解決先がキャッシュに未取得(この場合は取得コマンド hikari get の実行を案内する)
    • 詳細は packages.md。
  • export の配置と項目(language-spec.md §13.2)。
    ファイル・値の slot-list・タグ定義領域に置ける。本体・式位置の export と、領域に許されない項目の綴りは構文エラー。
    ファイルと値は名前・型注釈・宣言可能な演算子名、タグ領域は裸のタグ名または非空の Tag(slot, …) を持つ。
    同じ領域に二つ以上の export がある形は構文エラー、項目の名前の重複は duplicate-export-name、
    定義領域にない名前は export-unknown-member とする。export {} は合法である。
    分解列の意味と enum 原型の条件は §2.7 で型情報とともに検査する。
  • 呼び出さずに書いた break / continue / return: prelude 束縛のままの制御の綴りを呼び出しの先頭以外に書いた形(uncalled-control)。entry と import 先の各ファイルに当てる。規則は下の「呼び出さずに書いた制御の綴り」。
  • 制御の呼び出しへ重ねた実引数: prelude 束縛のままの制御の呼び出しを、さらに適用した形(return id 5 = (return id) 5。curried-control)。規則は下の「制御の呼び出しへ重ねた実引数」。

呼び出さずに書いた制御の綴り

prelude 束縛のままの break / continue / return(language-spec.md §18.1)が呼び出しの先頭以外に現れたとき、uncalled-control として報告する。呼び出しの先頭とは適用の呼ばれる側の位置で、break!・break(v)・break v・continue!・return x・return(a, b) がそれに当たる。並置を重ねた return 1 2(= (return 1) 2)も、return そのものは最も内側の適用の先頭にあるのでこの規則には当たらない(重ねた実引数は下の curried-control が報告する)。

mutable i := 0
while { i < 5 } {
  i = i + 1
  when (i == 3) {
    break  # uncalled-control: break! と書く
  }
}
  • 根拠: 呼ばずに書いた綴りは発火しない。上の例を許すとループは 3 で止まらず、i は 5 まで進む。実行しても何の診断も出ないので、抜けたつもりの書き手は気づけない。
  • import 先にも当てる: この規則は構文層にあるので到達可能な全モジュールに当たる。import 先に書いた { break } も、entry に書いたときと同じく実行前に止まる。
  • 無効化の手段は持たない: この形を正しく使う綴りは無い。
  • 構文が組む形は対象外: ?(language-spec.md §16.5)は return の綴りを書かないので、この規則に触れない。
  • 名前でない位置は対象外: スロット名として引く o.break・束縛や分解やスロットの名前・export の列挙・型注釈の中の綴りは値の参照ではない。

覆った名前は対象外

書き手が同じ綴りを束縛した名前(language-spec.md §1.2.2 の被覆)はその束縛を指す普通の名前なので、どこに置いてもよい。構文層は名前を解決しないので、覆ったかどうかは字句の範囲で保守側に決める。

  • 覆う束縛: 束縛宣言(break := …)・分解(continue, y := … / { return } := …)・スロットとパラメーター({ return: Int | … })・inner と inner_bound の名前・import の名前・type / enum の名前。
  • 覆う範囲: その束縛を書いたリテラル(ファイルそのものを含む)の全体と、その中に入れ子になったリテラルである。束縛の前後を問わない。
  • パターンの束縛はアームの中だけ: match のパターンが束縛した名前は、そのアームのガードと本体だけを覆う。別のアームに書いた綴りは覆われない。

前後を問わないのは保守側に倒した結果である。後ろで宣言した名前を入れ子のリテラルから読む形(f := {| break } の後に break := 1)は正当で、同じリテラルの中で宣言より前に読む形(x := break の後に break := 1)と見分けるには、実行時の名前解決の順序を構文層へ写すことになる。後者はこの検査では報告しないが、実行を始める前にエラーで止まる。呼ばずに書いた綴りが実行へ届くことは無い。

制御の呼び出しへ重ねた実引数

prelude 束縛のままの break / continue / return の呼び出しを、さらに適用した形を curried-control として報告する。並置はカリー化した適用なので(language-spec.md §3.5)、return id 5 は (return id) 5 と読まれる。

id := { x: Int | x }
f := { c: Bool |
  # curried-control: return (id 5) と書く
  when c {
    return id 5
  }
  3
}
  • 根拠: 内側の return id が発火した時点で制御が移るので、後ろの実引数は決して評価されない。書き手はほぼ確実に呼び出しの結果を返すつもりで書いており、許すと関数 id が気づかれないまま返る。結果型が割れて divergent-result になるときしか気づけず、return 1 2 のように型が合えば何の診断も出ない。
  • 直し方を文面が言う: 括弧で包んで 1 つの実引数にする(return (id 5)・break (f x))。continue は値を取らないので、重ねた実引数そのものが要らない。
  • 報告は 1 件: 見るのは制御の呼び出しを直に包む適用だけなので、return 1 2 3 のように実引数をいくつ重ねても 1 件である。位置は制御の綴りそのものである。
  • 1 回の適用に並べた実引数は対象外: return(a, b) は 1 回の適用にタプルを渡す形で、重ねた適用ではない。
  • 覆った名前・import 先・無効化: 「呼び出さずに書いた制御の綴り」と同じ走査で見るので、覆った名前の扱い(字句の範囲で保守側)と import 先への適用はそちらと同じで、無効化の手段も持たない。

構文層と型検査の分担

未定義参照・arity 不一致・型不一致は構文だけでは判定せず、§2 で検査する。

2. 静的型検査

2.1 検査の保証と適用範囲

静的検査は、評価前にすべての値の使用へ型を付け、契約の成立を証明する。
診断が 1 件でもあれば評価・生成を行わない。診断の重大度は §5 が定める。

すべての実行系に同じ規則を適用する。ファイル実行・eval・test・build・
Playground・LSP・check に、水準を下げるフラグや edition は無い。

検査するファイル

入口と、そこから import で到達するすべてのファイルを型検査する。
相対 import と pkg: は公開する値・型・効果を同じ検査から得る。
std: は標準ライブラリのシグネチャを用いる。循環・解決不能な import は静的エラーになる。

検査の保証

診断ゼロで受理したプログラムには、次の 2 つを保証する。

  1. 静的型は値について誤らない。 静的型を割り当てた評価点で、値はその型を満たす。
    NonZero(T) なら値は 0 でない。
  2. 型の panic は、静的に証明できないアスクリプションの評価地点でしか起きない。

したがって、アスクリプションを書かないプログラムは型の panic を起こさない。
バグ層の panic や外部資源の失敗は、この保証の対象外である。

受理の判定原則

型が付くと示せないものは受理しない。実行時に必ず失敗すると示せるかどうかは、診断の条件にしない。
推論や証明が足りない場合にも診断し、期待型・注釈・明示のアスクリプションで直せるようにする。

束縛・パラメーター・結果型の注釈では、値を宣言型へ静的に代入できることを要求する。
Any から具体型への暗黙の下方変換は認めない。panic しない絞り込みは match と matches で書く。
公開する型契約は language-spec.md §17.6 に従う。

2.2 静的型の決め方(ローカル推論)

リテラル・束縛・関数シグネチャと期待型から型を決める。値の位置の型不明は
unknown-value-type として報告し、注釈か期待型を書くよう案内する。

値の位置は使われる値の位置であり、束縛される値・実引数・結果・被演算子・
メンバー参照の受け手・呼ばれる値を含む。除外は次の 4 種類に限る。

  1. 型文脈(型引数・注釈)。型式自身の妥当性は検査する。
  2. 修飾子として使う名前(Shape.Circle の Shape、{ Circle } := Shape の右辺、l.inc の l)。
    一般の値を受け手にした参照は除外されない。
  3. メソッド呼び出しの呼び出し位置(out.push(x) の out.push)。
    受け手と実引数と呼び出しの解決は検査する。呼ばずに取り出す f := out.push は値の位置である。
  4. 値を捨てる位置(文の位置・Unit の結果位置)。
    部分式は値の位置として検査する。結果を捨てる呼び出しでも、呼ばれる側には型が要る。

束縛・代入・アスクリプション

  • 束縛注釈があれば、その型を期待型として右辺を検査する。注釈が無ければ右辺の型を採る。
  • mutable ローカルは初期化で型を確立し、再代入で変えない。
    型に Never が残る初期値には期待型が必要である(§2.10)。
  • 分岐中の再代入も確立した型へ検査する。合流点で可変束縛の型を広げない。
  • expr: T の型は T である。内側の式には有効な静的型が必要で、Unknown を隠すためには使えない。
    Any から具体型・union から選択肢・基底型から NonZero(T) への下方変換を書ける。
    静的に証明できないときだけ、その式の評価地点に実行時照合を残す。
  • 束縛・代入・分解代入・複合代入は、文としては Unit である。右辺などの部分式は個別に検査する。

関数リテラルのパラメーター型・結果型

パラメーター型はインライン注釈・関数型の期待型・内部名注釈・デフォルト値の型から決める。
決まらない位置を Any にしない。名前付き関数の規律は §2.5。

結果型の宣言は期待型として本体へ与える。宣言が無ければ、末尾式とすべての脱出値から
§3.4 の合流規則で推論する。return の引数と ? の失敗 bail を含む。
? の失敗経路の成功要素には Never を用いる。型が割れる場合には期待型が必要である。

値として格納した関数の return は、その関数自身の結果へ帰属する。
標準制御構文と透過を持つブロック内の return は外側関数へ帰属する。
ユーザー定義高階関数へ渡したブロックを、標準制御構文の脱出経路へ加えない。

再帰と前方参照は、宣言の名前へ解決する。関数の結果型は Never を初期値とする
最小不動点で求め、確定できなければ結果型注釈を要求する。値の前方参照も、
注釈や初期値から有効な型が決まる必要がある。自己参照だけの別名は有効な型を定めず not-a-type になる。

データオブジェクト・メソッド・要素アクセス

body の無いデータオブジェクトは、各スロットの注釈・期待型・デフォルト値から record 型を組む。
inner-name も同じ record 型で検査する。推論した record もメンバー集合を閉じる。
注釈の無いスロットを、型不明のまま Any として記録しない。

ユーザー定義タグ原型は、全通常スロットを宣言順で受け取る本体省略リテラルの型を持つ。
デフォルト値付きの操作も入力に数え、完成状態と具体化した enum 型引数を結果へ保持する。
修飾形と名前分解で取り出したタグは、同じ宣言と型を指す。

メソッド呼び出しは受け手の型とシグネチャから引数と結果を解く。
多相メソッドも §3 に従って型を付ける。
呼ばずに取り出したメソッドは、受け手を束縛済みの関数型を持つ。
数値のキーによる要素アクセスは、そのコンテナーの要素型を採る。

注釈の無いブロックパラメーターへ型を流す

ブロックを受け取るシグネチャを期待型として、無注釈のブロックを検査する。
反復メソッドでは要素型を、fold では蓄積型と要素型を、map_err ではエラー型を渡す。
引数を取らない thunk には要素を渡さない。each・build・collect など結果を捨てる
コールバックの結果位置は Unit とする。Unit の結果位置では値を捨てる。

import 先モジュールの型

相対 import と pkg: は、import 先を検査して公開値の型を record として得る。
std: は公開シグネチャの表から同じ情報を得る。型名と enum のタグの可視性は公開規則に従う。
std の self-host ソースにも、そのモジュールの不透明型とタグを名前として置く。
解決不能な import と循環 import は静的エラーになり、モジュールを Any として扱わない。

Any の使用と確定不能式

Any は何でも受け取るパラメーターや、明示して値を保存する位置に使える。
型テストの matches は Any の値からも取り出して呼べる(v.matches(type T))。
それ以外のメンバー参照・演算子・呼び出し・分解は any-operation になる。
matches と match、および式アスクリプションで具体型へ絞ってから操作する。

一般の関数呼び出しと多相メソッドの結果は、シグネチャと実引数から推論する。
推論できなかった値の位置は unknown-value-type、呼び出し後に残る型変数は
unresolved-type-argument として報告する。表せない形を暗黙の Any にしない。

2.3 条件による型の絞り込み(フロー絞り込み)

if / when / while の条件に書いた matches テストと数値の比較から、その条件が真である枝の中でだけ対象の静的型を絞る。v が Any や型変数でも if (v.matches(type Int)) { … } の中では Int として型付けされ、Int に無いメソッドの呼び出しが §2.7 で報告される。絞り込みは枝の子スコープへの上書きとして実装し、型システムには交差型・差集合型を導入しない。

  • 対象の枝: if の then 枝・if の else 枝・when / while の本体。then 枝と when / while 本体では条件が真、else 枝では条件が偽と分かっている。if は else を省いた 2 引数形も対象で、その場合は then 枝だけを絞り込む(綴りの違いで絞り込みの有無が割れると、書き手に直しようの無い除数の診断が出る)。枝がサンクリテラルでない(変数経由で本体が見えない)場合は対象外(保守側)。
  • 絞り込む名前: 裸の識別子に束縛されたもの。r.field のような path は対象外。絞り込んだ型が古びる原因は「枝の実行中に対象が別の値へ差し替わる」ことだけなので、それが起きないと確証できる束縛だけを対象にする。
    • 再代入されない束縛(immutable)は無条件に対象。:= 宣言・bare 必須スロット(=パラメーター)・match の アームパターン束縛(値コンストラクターの payload Some(x)、レコードパターンのスロット { code }、型付き束縛 name: T、およびタプル要素に入れ子で現れるそれら。prelude.md §8.4)が該当する。差し替えが言語仕様上起きないため無効化の機構が要らない(language-spec.md §6.1)。
    • 可変ローカル(=)は、その名前を所有するフレーム本体の入れ子リテラル(サンク・関数リテラル)のどこにもその名前への代入が無いときだけ対象。枝の本体はフレーム本体から見て入れ子リテラルなので、この 1 つの条件が「枝の中で直接代入される」形と「枝の中で呼んだクロージャがスコープチェーンを遡って書き換える」形(language-spec.md §6.1)の両方を塞ぐ。フレーム本体の文の位置にある代入(v = a の後に if (v.matches(type Int)) { … } と続く形)は枝の実行中には走らないので、絞り込みを妨げない。複合代入(v += 1)と分解代入も代入として数える。
    • ファイル直下の公開された可変メンバーは対象にしない。import した側が m.name = v で書ける(language-spec.md §13.2「可変 member は束縛そのものである」)ので、枝の中で呼んだ関数(importer が渡したコールバックなど)が差し替えうる。その書き込みはこのファイルに現れないので、入れ子リテラルの代入を数えても塞げない。export { … } に載らない名前は importer から届かないファイル私的な束縛なので、上の可変ローカルと同じ条件で対象になる。export が無いファイルではトップレベルはすべて公開である。
  • 条件の分解: v.matches(type T)(並置の v.matches type T を含む)、および下記の比較の葉を葉とし、&& は両辺の事実の和(同名で型が食い違う組は到達不能な枝なのでどちらにも絞らず落とす。比較の葉の事実は matches で決まった型の上に重なる — if (v.matches(type Int) && v > 0) の v は NonZero(Int) になる)、|| は両辺に共通する名前だけを残して union(OneOf)へ持ち上げ、.not()(postfix 短縮 .not! を含む)は極性を反転する。否定の内側ではド・モルガンにより && と || の扱いが入れ替わる。述語 T が静的に型へ解決できない場合はその葉から事実を作らない(保守側)。
  • 比較の葉: 片辺が裸の名前、他辺が数値の定数である比較(< / <= / > / >= / == / !=)を葉とする。定数は数値リテラル・その単項マイナス・定数に不変束縛された名前(別名の連鎖を含む)で、算術は評価しない(K := 2 * 3 の K は定数ではない)。定数はどちらの辺に書いてもよい — 0 < x は演算子を鏡映して x > 0 と読む。比較がその名前の非ゼロを含意するとき、名前の静的型を NonZero(T)(prelude.md §3.3)へ絞る(n: Int は NonZero(Int) になる)。極性が負(else 枝・.not()・ガード節)のときは比較を反転してから引く(x > 0 の否定は x <= 0)。
名前の型 非ゼロを含意する比較(c は定数)
Int n != 0・n == c(c != 0)・n > c(c >= 0)・n >= c(c >= 1)・n < c(c <= 0)・n <= c(c <= -1)
Float x > c(c が 0.0 以上)・x >= c(c が 0.0 より大きい)・x < c(c が -0.0 以下)・x <= c(c が -0.0 より小さい)・x == c(c が 0.0 でも -0.0 でもない)・x != 0.0 と x != -0.0 の両方

Float の順序は language-spec.md §9.4 の全順序で読み、-0.0 < 0.0 である。したがって x != 0.0 は 0.0 だけを、x != -0.0 は -0.0 だけを除き、片方だけでは絞らない。両方を除くには x != 0.0 && x != -0.0 と書く(&& で除いたゼロを合わせる)。x > -0.0 も -0.0 だけを除くので絞らない。

&& は両辺で除いたゼロを合わせ、|| は両辺がともに除いたゼロだけを残す(n > 0 || n < 0 の n は NonZero(Int))。比べた定数と名前の基底が同じ数値型のときだけ絞る — Int の名前と 0.0 の比較、Any や union の名前は絞らない(保守側)。

事実を立てない条件: 2 つ以上の名前を含む比較(i < n)・算術を含む辺(n - 1 > 0)・path(b.value > 0.0)・length!・呼び出しを含む辺・数値でない定数(s == "x")と、葉にならない Bool 式(ユーザー関数の呼び出し・path・String のメソッド・裸の Bool 変数・is_empty!)。これらは条件に書いてよく、事実を立てないだけである。範囲・区間・名前同士の関係は型に載せない — 判定が式の形と束縛と型だけで決まるので、書き手が読んで同じ答えを出せる。

  • match アームでの照合対象の絞り込み: match v { … } の照合対象が上の「絞り込む名前」を満たす裸の識別子であるとき、各アームの body で対象そのものを絞る。対象が式や path のときは対象外(保守側)。レコードパターンへ絞るときは下記「幅と封印」に従い封印マークを落とす。
    • 正の事実: そのアームのパターンが型へ解決できるときに立てる。パターンが複数(OR パターン)のアーム からは立てない — 正の事実としては union に持ち上げないと健全でないためである(保守側)。catch-all アーム(_)も正の事実を持たない。
    • 否定の事実: アーム N の body では、アーム 1..N−1 のうちガードを持たない アームのパターンを否定として立てる。アーム N に到達したことが意味するのは「先行アームがすべて外れた」ではなく「先行アームの(パターン ∧ ガード)がすべて偽だった」である。ガード付きアームは「パターンは当たったがガードが偽だった」経路でこのアームへ落ちてくるので、そのパターンを否定にすると健全でない(match v { String | c => … ; _ => … } の _ 側の v は、c が偽なら String でありうる)。網羅性の判定(§2.9「closed variant の match に網羅性を要求」「到達しえないアーム・冗長な catch-all」)が「ガード付きアームは非貢献」と扱うのと同じ規律である。ガードを持たない OR パターンのアームは、全パターンをそのまま否定に使える。否定の差し引きは下記の条件(閉じた union・排他型)にそのまま従うので、record・List(T)・Option(T) の選択肢は差し引かない。
  • アームガード: pattern | guard => body の guard が真であることは body の中で分かっているので、条件と同じ分解で正の事実を立てる。対象はアームパターンが束縛した名前でも外側の名前でもよい。パターンが立てた事実と同名に立つ場合は && と同じく両方を合わせる。
  • 事実の極性: 葉は極性に応じて正の事実(「対象は T に一致する」)と否定の事実(「対象は T に一致しない」)のどちらかを生む。正の事実は絞り込み先の型として使い、否定の事実は下の差し引きにかける。同じ名前に正と否定が同時に付く場合は正を採り(正の方が強い)、正の事実と同じ型の否定が同時に立つ組(v.matches(type Int) && (v.matches(type Int)).not())は到達不能なのでその名前を落とす。
  • 正の事実に使える型: 実行時の型判定が所属を保証する型を使う。
    関数型は検査器が決めたシグネチャで照合するので、無注釈の関数もこの判定に使える。
    Future(T) は待たずに、Future を作った組込が確定した結果の型で照合するので、この判定に使える。
    型変数の型判定は、その境界が保証する情報だけを運ぶ。未確定の型を確定したことにはしない。
    ジェネリック型の展開を追いきれず所属を保証できない場合は、その正の事実を使わない。
  • 正の事実の適用(交わりの代用): 正の事実の適用は本来「分岐前の型との交わり」であって置き換えではない — 型システムに交差型を導入しないので置き換えで代用するが、置き換えは分岐前の型が持っていた情報を落としうる。そこで確実に狭める組にだけ適用し、それ以外はその正の事実を使わない(保守側)。確実に狭めるのは次の組だけで、これ以外はすべて据え置く。
    • 分岐前の型と同一。
    • 分岐前の型が閉じた union で、正の事実の型がその選択肢の部分集合。
    • 分岐前の型が Any。
    • record 同士 — 分岐前の型の各フィールドが正の事実の型にもあり、その型も確実に狭い。matches は record を幅で照合するので、フィールドが増える方が狭い型になる(正の事実の型の側にフィールドが増えるのは可)。
    • 同じ型コンストラクターの共変コンテナー(List(T) / Option(T) / Result(T, E) / tuple)— 要素ごとに確実に狭い。
    • 分岐前の型が NonZero(T) のときは、上のいずれかに加えて正の事実の型も NonZero(T) であること。

この定義の帰結として、Any への「絞り込み」、v: Int に union 別名 OneOf(Int, String) を当てる形、分岐前の型が NonZero(Int) のときに素の型名(Int)を当てる形は、いずれも狭めないので使わない。record 同士・Variant タグ同士のようにどちらが狭いとも言えない組も据え置く — どちらを採っても相手側の情報を落とすので、分岐前の型を保つ方が情報を失わない。正の事実を使わない場合も、同じ名前に立つ否定の事実や比較の葉の事実は通常どおり適用され、分岐前の型に据え置くのは名前に何も適用できなかったときだけである。

  • 否定の事実による差し引き: 否定の事実は、分岐前の型が閉じた union(OneOf(...)) であり、かつ union の各選択肢と述語がいずれも「値が高々ひとつにしか一致しない型」であるときに限り、一致する選択肢を union から取り除く形で絞り込む。この条件を満たすのは原始型(Int / Float / String / Bool / Bytes / Range)・Unit・同じ enum に属する Variant タグ(タグ同一性は所属 enum を含む。language-spec.md §17.4)で、いずれも「値はどれかひとつのタグ・原始型に属する」ため差し引きが健全に定義できる。if (v.matches(type Int)) { … } { … } で v: OneOf(Int, String) なら else 枝の v は String になる。record・List(T)・Option(T) のような幅や要素で重なりうる型は選択肢にも述語にも許さない(例えば空リストは List(Int) にも List(String) にも一致するため、取り除くと健全でない)。取り除いた結果が空になる(=その枝が到達不能)場合と、取り除ける選択肢が無い場合は絞り込まず分岐前の型に据え置く(保守側)。
  • ガード節(フロー感応): 枝が確実に脱出する分岐文の後では、その分岐を通過したことが事実になる。when (x <= 0) { return 0 } の後続の文では x > 0 が成り立つ。これは枝の子スコープではなく、同じ body のそれ以降の兄弟文への上書きになる。次をすべて満たすときだけ事実を立てる。
    • 文の形 — 式だけの文が when (cond) { … }・2 引数 if (cond) { … }・3 引数 if (cond) { … } { … } のいずれかで、枝がサンクリテラルであること。while は本体が 0 回実行されうるので対象外。
    • 確実に脱出する枝があること — その枝の全経路が return で脱出するか、prelude の panic / exit で発散する(どちらも結果型が Never で呼び出し位置へ戻らない。prelude.md §1)。書き手が同じ綴りを取り直していれば普通の呼び出しなので数えない。1 経路でも脱出しないなら事実を立てない(保守側)。両方の枝が脱出する形は以降が到達不能なので、やはり事実を立てない。? bail は数えない — postfix ? が脱出するのは被演算子が失敗 variant のときだけで、成功なら中身に開いて後続へ進む(language-spec.md §16.5)ので「必ず脱出する」にならない(脱出しうる箇所を集める §2.6「宣言結果型と全脱出経路の整合」とはここが逆向きである)。この判定自体は枝の末尾文だけを見る保守的なもので、when / while / match の末尾へは降りない — match の全アームが return で脱出する形を末尾に置いても、それだけでは「全経路脱出」と数えない(見逃し側)。
    • 対象 — 上の「絞り込む名前」を満たすこと。
    • 無効化 — 次の 3 つで事実を落とす。いずれも可変ローカルにだけ効く条件で、immutable な束縛は言語仕様上代入の対象になれないため無効化が要らない。上の可変ローカルの条件(入れ子リテラルに代入が無いこと)は「枝の実行中に走らない」ことを根拠に文位置の代入を許していたが、フロー感応ではその前提が成り立たないので、これらを足して代入の全経路を覆う。
      • ガード以降の兄弟文にその名前への文位置の代入があれば、その代入位置以降は落とす。
      • 枝の内側の代入でも落とす。 match のアームや if / when の枝の中でその名前へ代入したら、そのフレームに載っている事実を全部落とす(内側の 1 枚だけではない)。枝が走るかどうかは静的に決まらないので、走ったかもしれない代入の後で古い事実を使ってはいけない。落とす向きは事実を減らす側なので診断は増えない。
      • 入れ子リテラルの本体には持ち込まない。フロー感応な事実が有効なのは、それを立てたフレームの直線的な文の並びの中だけである — 入れ子リテラルは値として格納されうるので、その本体が走るのは事実を古びさせる代入より後でありうる(when (x > 0) { return 0 } の後に g := {| … x … } と書き、さらに後で x = 5 して g() を呼ぶ形)。

立てる極性は脱出した枝の反対側である — when (c) { return … } と if (c) { return … } は負(c が偽)、if (c) { … } { return … } は正。3 引数形を含めるのは、除くと if (c) { return 1 } と if (c) { return 1 } { } で絞り込みの有無が割れるためである(綴りの違いで割れると書き手に直しようの無い除数の診断が出る)。

  • 適用先: 枝の本体スコープに絞り込み後の型で束縛を上書きする。効くのはチェッカーの逐次診断(枝内の文の型照合)である。枝の外へは持ち出さない — 可変ローカルの型は確立時に決まって動かないので(§2.2)、枝を跨いで型を運ぶ機構そのものが無い。
  • 幅と公開範囲: record 述語は公開した通常スロットについて幅構造型として照合する。
    述語への絞り込みは値の定義公開メンバー集合・所属・内部アクセスの出所を変更しない。
    非公開名は述語の要求へ数えず、定義元でも公開した欄だけで構造照合する。
  • 絞り込み先が分岐前の型と確実に非整合な場合(その枝が到達不能)は、絞り込まず分岐前の型に据え置く(保守側)。枝内で同名のスロット・:= を宣言していれば、そちらのシャドウが素直に勝つ。

絞り込まない対象

  • path: r.field のような path を対象とする条件は対象外。path は受信者が別名で参照されうる(s := r の後 s.field = …)ほか、枝の中で呼んだ任意の関数からも書き換えられるため、「枝の実行中に差し替わらない」ことを確証するには別名解析と呼び出し先の副作用解析が要る。
  • 可変ローカル: 上記「絞り込む名前」の条件を満たすものだけが対象。入れ子リテラルのどこかで代入される名前は、その代入が枝の実行中に走るかを問わず絞り込まない(呼び出しの有無までは追わない)。

絞り込みで事実を得られなかった場合は元の型を保つ。
その型が使用先の要求を満たさなければ、その位置の規則(除数なら §2.11)に従って診断する。

2.4 型注釈と値の照合

型注釈位置に来る値と、注釈そのものを静的に検査する。

型注釈と値の不一致

注釈が T の位置へ値 v を置くには、期待型を使った検査か部分型 type(v) <: T により
静的に代入できることを証明する。示せなければ type-mismatch を報告する。
束縛注釈で Any を具体型へ下方変換することはできない。

対象は束縛・分解・実引数・デフォルト値・結果型・enum 原型の通常スロット である。
部分適用も渡した実引数ごとに検査する。タプルを引数列へ広げる形と、1 つのスロットへ
複数の実引数をタプルとしてまとめる形は、language-spec.md §3.5
の規則で対応する位置を決める。対応する型を決められない適用は受理しない。

剛な型変数はその同一性と境界で証明する(§3.1)。
別々の型変数や、型変数と具体型を wildcard として扱わない。

  • T <: Any と Never <: T はすべての型 T について成立する。
  • immutable な組込コンテナーは共変である。ユーザー定義 enum の型引数は不変である。
  • record は幅部分型を持つ。要求するスロットがすべて存在し、型付きフィールドは不変に一致する必要がある。
  • std の可変なコンテナーの型引数も不変である(§2.10)。
  • enum と不透明型は宣言の位置で同定する。同名でも別宣言の型は一致しない。
  • union の値を渡すには、すべての選択肢が目標型へ代入できる必要がある。
  • 値を持たないスロットは、型付きフィールドを満たさない。
    値を持つと証明できない場合も、注釈の位置へ渡せない。
  • NonZero(T) は値が非ゼロの定数か静的型が NonZero(T) であることを要求する(§2.11)。

式アスクリプションでは静的な代入証明を必須にしない。静的に証明できないときは
式の評価地点で照合する。型式自身と、内側の値の型・効果・多重度などの検査は省かない。

型注釈位置の未定義型名・非型式

型注釈位置(束縛・スロット・分解・結果型アスクリプション expr: T)に次が来る場合、到達すれば確実に実行時エラーになるため報告する。文言は実行時の型評価と一致させる。

型位置に書いた [...] はここへ来ない — 角括弧は List のリテラルであって型位置には現れないので、静的検査より手前で構文解析が brackets are not a type; for a list write List(T), for a record write { name: T |} と報告する(language-spec.md §17.2)。

型位置の {} に書いたエントリも同じく手前でエラーにする。 型位置のエントリは name: 型 と bare 識別子で尽きる(language-spec.md §17.2)ので、デフォルト値つきスロット(name := 型 / 可変スロット mutable name := 型)は slot defaults are not a type entry; for a field write { name: T |}、structural 型の名前でない位置エントリ({ 1 |})は a bare type entry must be a name; for a field write { name: T |} と報告する。拒否しないと型欄が空のまま検査を素通りし、hikari check は通るのに走らせると落ちる(型を引く位置で止まる)。関数型({ … | 結果型 })の位置エントリはパラメーター型なので名前に限らず、List(Int) も { Int | Int } も書ける。

  • 未定義の型名(スコープに束縛の無い大文字始まりの参照)— undefined: <name>
    • enum 原型の通常スロットの型名は走査の終わりに判定する。 宣言はファイルを上から順に見る途中で読むので、その時点では import が解けていないことがある(enum P := { Rep := { value: Html |} | Rep } の Html を後段の import が供給する形)。そこで報告すると正しいコードを undefined と呼ぶことになるので、走査を終えてから解き直し、なお解けないものだけを報告する。名前でない型式(型変数・適用形)は断じない
  • 型になり得ない式(数値・文字列リテラル・演算子式など)— not a valid type expression
  • モジュールが公開しない型メンバー参照 mod.Name(下記「モジュール型メンバーの解決」)
  • 非構造型への埋め込み({ Int |})— {...} 形の bare 大文字エントリは埋め込みで、
    取り込む先は構造型でなければならない。
    <name> is not a structural type; cannot embed; for a list of <name>, write List(<name>)
  • function 型で名前付きと位置を混ぜた slot-list({ x: Int, String | Int })—
    位置エントリとスロットは別の列に載るので、混在した綴りは書いた順を保てない
    (language-spec.md §17.3)。関数型のパラメーター名は照合に参加しない
    ので、混在を許して並び順の規則を読者に負わせるより書けなくする方が安い。
    function type mixes positional and named parameters; write all positional ({ Int, String | R }) or all named ({ a: Int, b: String | R })

結果型を持つ形だけが対象である — 結果型の無い { Ord, x: Int |} は record 型で、
bare 大文字は埋め込み(上記)であって位置パラメーターではない。

埋め込み先が構造型であることを静的に証明する。
別名・ジェネリック適用は解決して判定し、証明できない形は not-a-type にする。

モジュール型メンバーの解決

型位置の mod.Name は、モジュール束縛とその不変な別名をたどり、公開された型メンバーから引く。
相対 import・pkg: はトップレベル型宣言、std: は標準ライブラリの型メンバー表で集合を定める。
集合に無い名前は not-a-type になる。公開されたタグは型述語として書ける。
型でもタグでもない値スロットを、型不明として受け入れない。

モジュール束縛へ帰着しない recv.Name は型式として読めず、not-a-type になる。
循環 import と解決不能な import は、import の診断で止める。

型名の解決順

型式の位置(language-spec.md §17.1「型式の位置」)の識別子は、追跡済みスコープを先に引き、束縛が無いときだけ prelude の型語彙へフォールバックする。

  • スコープに型の名前がある(type / enum の宣言・import した型メンバー・呼び出しで埋める型スロット type a・ジェネリック宣言の型パラメーター): その型を採る。
  • スコープに値の束縛がある: 型式にならないので not-a-type を報告する。例外は裸のタグで、型式の位置に書いたタグは型述語として読む(x: Circle。language-spec.md §17.4 の照合表)。
  • スコープに束縛が無い: prelude の型語彙(Int / String / List / Error 等)として解決する。

型名は予約語ではなく値と同じスコープに載る名前(language-spec.md §1.2.1・§17.2)なので、書き手が同名を宣言すればそちらが勝つ。type Error := { code: Int |} を書いたファイルの e: Error はその定義を指す。値の束縛も同じく prelude の型語彙を隠す — Int := 3 の後の x: Int は not-a-type である。

型語彙の固定セットを先に見てはならない。
検査と matches・アスクリプションの照合は、この解決が選んだ同じ型を使う。
書き手が覆った名前を別の型として扱うと、静的型と値の所属が食い違う。

型適用のコンストラクター(Nope(Int))と、メンバー m.Name の受け手の名前(foo.Baz の foo)も同じで、束縛が無ければ undefined-ref を報告する。後ろで宣言するコンストラクター(前方参照)は束縛があるものとして扱う。値の位置の同じ綴りは値位置の未定義参照(§2.13)が 1 度だけ報告する。小文字始まりの bare 名は型変数(language-spec.md §17.2)なので、この判定の対象外である。

型式の位置の型適用 Name(T)(ジェネリック type / enum のインスタンス化)は宣言のテンプレートへ型引数を代入して解決する。再帰ジェネリック enum(enum Tree(a) := { Leaf := { value: a |}, Node := { left: Tree(a), right: Tree(a) |} | OneOf(Leaf, Node) }、language-spec.md §17.4)は宣言中の自己参照 Tree(a) を遅延型適用のまま保持し(無限展開しない)、使用サイトの Tree(Int) は 1 段だけ展開したテンプレートに解く。これにより注釈と値の照合(§2.4)・closed variant の match 網羅性(§3 — 判定時に遅延適用を 1 段ずつ展開)が非再帰ジェネリック enum と同水準で働く。

型コンストラクターの型引数の個数

型引数の個数が宣言と食い違う型適用は type-arity-mismatch を報告する。ジェネリック type / enum の宣言に対してだけでなく、型引数を 1 つも取らない宣言(type P := { a: Int |} に対する P(Int))にも、prelude がスコープに載せる型コンストラクターのうち arity が固定のもの——List(T) / Option(T) / Future(T)(いずれも 1 個)・Result(T) と Result(T, E)(1 個または 2 個)・多重度型 AtMostOnce(T) / ExactlyOnce(T) / Borrowed(T) / Consuming(F)(いずれも 1 個。§2.14)・EffectConduit(F)(1 個。§2.15)・NonZero(T)(1 個。prelude.md §3.3)——にも同じ判定を行う。Effect(T, …) は効果ラベルの個数が可変なので本判定の対象外で、第 1 引数を欠く Effect() だけを type-arity-mismatch とする。

型式は書いた地点で静的に解けるので(language-spec.md §17.1「型式の位置」)、個数の合わない適用は型式にならない。書き手が prelude のコンストラクターと同じ綴りをコンストラクターでない型で覆った形(type List := { n: Int |} を書いた後の x: List(Int))も、解決順(上記)どおり書き手の宣言で判定し、0 個を期待する不一致として報告する。

型引数を取らない prelude の型(Int / Float / String / Bool / Bytes / Range / Unit / Any / Never / Ordering / Control / Error / Number / Comparable / Copyable / Sequence)への適用(Int(Int))も、0 個を期待する不一致として報告する。

タグへの適用(x: Some(Int)・x: Ok(Int)・書き手の enum のタグ x: A(Int)・修飾形 x: E.A(Int))は not-a-type である(下記「型式として読めない形」)。タグは型引数を取らない — 裸のタグは型述語として注釈に書ける(x: Circle)が、適用した形は型式にならない。

コンストラクターの位置が型適用の結果で、それが型引数を取らない確定した型に解ける形(List(Int)({ n | n > 0 }) と読まれる x: List(Int) { n | n > 0 })も、0 個を期待する不一致として List(Int) expects 0 type argument(s) を報告する。コンストラクターを返す値の呼び出し(mk()(Int))は型式として読めない形で、not-a-type である(下記)。

可変長の OneOf は対象外。OneOf(A, B, …) は最小 2 個で上限が無いため、個数だけからは不一致を確定できない。固定 arity と同じ「N 個丁度」の判定に載らないので、本判定の対象外とする。

判定するのは型式の位置だけである。 型は値ではないので、型適用を値の位置に書いた形(println List(Int) / t := Result(Int, String))は個数を問わず type-in-value-position である(下記「値の位置に置いた型の名前」)。

判定は §2.4 の解決順に従う。書き手が同名を宣言していれば(type List(a, b) := (a, b))そちらが勝ち、その宣言の arity で判定する。宣言が使用より後ろにある形(前方参照)も、宣言の arity で判定する — prelude の個数で報告すると、宣言の位置が使用より後ろというだけで誤検出になる。

NonZero の型引数

NonZero(T)(prelude.md §3.3)の型引数が、別名を展開した後に Int でも Float でもない形は nonzero-type-argument を報告する(NonZero(String)・NonZero(Number)・NonZero(NonZero(Int))・型変数の NonZero(a))。どの値が 0 かは値の種類を 1 つに決めないと定まらないので、union・型変数・入れ子は受けない。型引数の個数の誤り(NonZero・NonZero(Int, Int))は上の type-arity-mismatch である。書き手が NonZero を宣言していれば、解決順どおりそちらが勝つ。

d: NonZero(Int) := 3  # 受理
e: NonZero(String) := "a"  # nonzero-type-argument

型式として読めない形

型式の位置(language-spec.md §17.1「型式の位置」— 注釈・type の右辺・enum 原型の通常スロットの宣言型・型引数)では、
型を指す位置に型の名前しか置けない。置けないものを次のとおり報告する。位置による違いは無い — 型式はどの位置でも書いた地点で静的に解け、実行時に評価して答えを出す経路を持たない。

型式の位置に書いた形 例 報告
コンストラクターの位置が名前でない mk()(Int)・ns.sub.Seq(Int) not-a-type
受け手が裸の名前でないメンバー ns.sub.T not-a-type
値の束縛 x := 3 の x・関数 f・`o := { n := 1 } の o.n` not-a-type
型コンストラクターでない束縛への適用 関数 f(Int)・タグ Some(Int)・修飾したタグ E.A(Int)・型変数 f(Int) not-a-type
型を持ち得ない値を受け手にしたメンバー m := 3 の m.Baz・関数 f.Baz not-a-type
呼び出しで埋めた型スロットを読む p := k(type Int) の x: p.a not-a-type
束縛の無いコンストラクター・受け手 Nope(Int)・foo.Baz undefined-ref
  • 名前と読めるのは裸の識別子(List(Int)・Pair(a, b))と、受け手が裸の名前のメンバー
    (m.Seq(Int)・m.T)までである。受け手はモジュール束縛(import)に帰着しなければならない
    (リテラルの slot-list は型を宣言できないので、型メンバーを持つのはモジュールだけである)。
  • 型の名前は type / enum の宣言(import で取り出したもの・後ろで宣言する
    もの(前方参照)を含む)・prelude の型語彙・ジェネリック宣言の型パラメーター・呼び出しで埋める型スロット type a
    (language-spec.md §17.4.1)である。
  • 型を持ち得ない受け手は、推論した型が数・Unit・List・tuple・関数・Option・Result・
    Future・Ordering・Control のものである。
  • 型式のどこに現れても同じで、型引数・record のフィールド・tuple の要素・ジェネリック宣言の
    本体も対象になる。位置は他の型式の問題と同じく型式の先頭である。
  • 呼び出しで埋めた型スロット(x: p.a)は、中身が呼び出しごとに違い、書いた地点で静的に解けない
    (language-spec.md §17.4.1「型スロットは値として取り出せない」)。

値の不変条件を型に書こうとした綴りもここで報告される。type Pos := Int where { n | n > 0 } は
(Int where)({ n | n > 0 }) — 呼び出しの結果への適用 — と読まれ、型式にならない。
不変条件は型式では書かず、検査つきの構築関数で守る
(language-spec.md §17.7「他の不変条件の書き方」)。

宣言で導入していない型変数

型を値へ結び付ける位置では、書いた型変数を導入する宣言が要る。
型宣言の右辺・enum 原型の通常スロットの型・型引数 type T・式アスクリプションの型に、
導入されていない型変数を書いたら undefined-ref を報告する。位置はその型変数である。

型変数を導入するのは次のものである。

  • ジェネリック宣言の型パラメーター(type L(a)・enum E(a))と、呼び出しで埋める型スロット type a。
  • 囲む関数のシグネチャに書いた型変数。
  • 関数型のパラメーター型に現れた型変数。関数型はそれを量化する(type F := { a | a })。
    結果型にだけ現れる型変数は呼び出しで決まらないので量化されない。
    関数型に解ける別名の適用(type M(a) := { a | a } の M(a))も、その型引数の型変数を量化する。
  • type 別名の右辺に書いた境界付き型変数 (a: B)。別名を使うシグネチャがその変数を量化する
    (language-spec.md §17.8「全体を別名にする」)。
    引数を持たない関数型の結果にだけ書いた形は導入にならない。

enum 原型の状態の宣言型では境界付き型変数も導入にならない。enum は名目型なので、使う側が量化できない。
型引数・式アスクリプションの型は照合の目標なので、そこで書いた境界付き型変数も導入にならない。

type T := r                  # undefined: r
enum E := { C := { value: (r: Int) |}, D := {} | OneOf(C, D) }  # undefined: r
type Config := { a: Int }    # undefined: a(record 型なら末尾に `|` を書く)
n := v: (r: Int)             # undefined: r

縦棒の無い { a: Int } は record 型ではなく、引数を持たずに (a: Int) を返す関数型と読む
(language-spec.md §17.2「型位置の {} の解釈」)。
この形には record 型の綴り { a: Int |} を案内する。

値の位置に置いた型の名前

型は値ではない(language-spec.md §17 冒頭)。値の位置で引いた名前が型の名前(「型式として読めない形」の 2 つ目の箇条)に解けたとき、type-in-value-position を報告する。型適用(List(Int))も同じである。受け手の型をメンバーとして値の位置で読む形(モジュールの型メンバー m.T・呼び出しで埋めた p.a)と、名前リストで取り出す形({ a } := p)も同じく報告する。

x := Int  # type-in-value-position
println List(Int)  # type-in-value-position
f := { type a | a }  # type-in-value-position(a は呼び出しで埋める型スロット)
p := { type a, x: Any | x } type Int
p.a  # type-in-value-position(型スロットは値として読めない)
nz := NonZero(Int)  # type-in-value-position
fs := Fs  # type-in-value-position(効果ラベルも型式の位置でだけ引く名前)

次の 3 つは値の位置ではないので対象外である。

  • enum のタグを引く形: 修飾したタグ Name.Tag の受け手と、名前リストによる取り出し { A, B } := Name の右辺(language-spec.md §17.4)。
  • 呼び出しの型引数: 直接の実引数に書いた type T の T(json.decode(text, type Config)・v.matches(type Int))。呼び先の静的型に依らず型式として読むので、「型式として読めない形」の規則が当たる。
  • 呼び出しで埋める型スロットの宣言: { type a | … } は型を受け取るスロットを宣言する形で、値を置いていない。

呼び出しの実引数が型引数かどうかは type の有無だけで決まる。呼び先の静的型が分かるときは、通常値を型スロットへ渡した形を not-a-type、型引数を値スロットへ渡した形を type-argument-to-value-slot として報告する。型引数の型式自体が不正なら not-a-type を優先し、スロットとの不一致を重ねない。

型の名前をマーカーなしで実引数へ置けば type-in-value-position とし、type T と書くよう案内する。
型スロットと値スロットの対応も静的に決め、対応が違う場合は診断する。
Any や Unknown を呼び先にした適用は受理しない。

2.5 型注釈の規律(暗黙 Any の禁止)

型を決められなかった位置と、明示して選んだ top 型を区別する。
型不明・型が割れた合流・未確定の型変数を、暗黙の Any で補わない。

暗黙・明示 Any の許可マトリクス

位置 必要な型 明示した Any
パラメーター 注釈・期待型・デフォルト値から決まる型 インライン x: Any で書ける
結果型 宣言型または全脱出経路から推論した型 束縛注釈・内部名注釈の結果型に書ける
値束縛 注釈または右辺から推論した型 x: Any := v で書ける

名前付き関数の結果型

結果型を省略しても推論できればよい。推論型のネスト位置に暗黙の Any が残る場合は
implicit-any-result、呼び手へ渡す結果型の内側に Never が残って要素型を定めない場合も
同じコードで注釈を要求する。bare な Never は発散を表すので許す。
明示した Any の値を返す場合、結果は操作できない top 型である。

束縛注釈・内部名注釈で Any を結果型に指定できる。
body 末尾の expr: Any は any-result-ascription とし、結果型の明示として認めない。
型不明は unknown-value-type、型が割れた合流は divergent-result で報告する。
? を含む関数にも同じ規則を適用する。

名前付き関数のパラメーター型

インライン注釈・関数型の期待型・内部名注釈・デフォルト値の型から各パラメーター型を決める。
決まらない名前付き関数のパラメーターは untyped-parameter になる。
型変数も有効な型であり、本体では剛に扱う。

何でも受け取るパラメーターは x: Any と明示する。
関数型注釈だけの { Any | R } は、無注釈パラメーターの明示としては認めない。
ワイルドカード _ と型スロット自身は、この名前付きパラメーターの規律の対象外である。
値として使われる部分式の型検査は行う。

値束縛の型

無注釈の束縛の推論型が、コンテナー・payload・タプル・record・enum の型引数・union の
ネスト位置に暗黙の Any を含む場合は implicit-any-binding を報告する。
要素型も期待型から静的に検査する。注釈を付けても List(Any) から List(Int) への
暗黙の下方変換は認めない。必要なら値に : List(Int) とアスクリプションを書く。

bare な top 型の値をそのまま束縛することは、操作できない Any として扱う。
未確定の型変数は unresolved-type-argument、Unknown は unknown-value-type で報告する。
Result のエラー型も、呼び出し後に未確定なら同じ規則に従う。

再代入しない xs := [] の List(Never)、x := None の Option(Never) は許す。
再代入できるローカルとスロットでは §2.10 の期待型を要求する。

2.6 宣言した型を契約として使う

宣言した型を、その値のすべての使用地点へ運ぶ。
宣言と本体・実体シグネチャの一致を静的に証明してから受理する。

結果型の越境利用

完全適用の結果型は関数の宣言型か推論型を実引数で実体化して決める。
使用先の期待型も型変数の確定に使う。値の位置で結果型が決まらない呼び出しは受理しない。
本体が宣言結果型に適合することは、定義地点で証明する。

宣言結果型と全脱出経路の整合

末尾式・return・? の失敗 bail をすべて宣言結果型へ静的に検査する。
型が収まると示せない経路は type-mismatch になる。結果位置が Unit なら値を捨てるが、
その値を計算する部分式も検査する。通常の結果型注釈は実行時に照合しない。

body 末尾の式アスクリプションは、その式の評価地点で照合する。
早期 return と ? はその式を通らないので、宣言結果型へ静的に代入できなければならない。
早期脱出値の下方変換が必要なら、その脱出値自身へアスクリプションを書く。

標準制御構文・透過するブロック内の脱出は外側関数に帰属する。
格納した関数や透過しないユーザー関数のブロックからの脱出は、その関数自身に帰属する。

inner-name 型と slot/結果型の整合

内部名注釈はパラメーター・スロット・結果型の期待型となる。
インライン注釈との一致、本体結果の適合を静的に証明する。決まらない位置を wildcard にしない。
食い違いは inner-name-mismatch として報告する。

関数型注釈と実体シグネチャの整合

関数型はパラメーターと結果について不変に照合する。効果集合は
§2.15 の包含規則で照合する。
型変数を持つ関数は、そのシグネチャのインスタンスとして一致させる。

関数値は検査器が決めたシグネチャを実行時の型として持つ。
matches とアスクリプションも、このシグネチャで照合する。
関数型注釈で関数を包み直して呼び出し時に引数・結果を強制することはない。
部分適用は残りのパラメーターと実体化した結果型を持つ。

結果を捨てる Unit の期待型は、リテラルの本体を値を捨てる文脈として検査する。
任意の既存関数の結果型を Any との照合で捨てることはしない。

2.7 メンバー・メソッドの解決

受け手の静的型から、名前とシグネチャを解決できることを要求する。

存在しないメソッド/スロット

recv.name と recv.name(args) は、受け手の静的型が定めるスロット・メソッド集合から解決する。
集合に無い名前は no-such-member になる。中置形も対応するメソッドと同じ規則である。

  • record: すべてメンバー集合を閉じる。注釈・名前付き型・推論・mutable 束縛の別を問わない。
    型が宣言する欄と、適用できる組込メソッドだけを参照できる。
    値が余分な欄を持つ可能性は、型に無い名前を参照する根拠にならない。
    必要ならアスクリプションか matches で、その欄を持つ型へ絞る。
  • 原始型・コンテナー・関数・std の不透明型: その型のスロットとメソッドの表で解決する。
    import したモジュールも公開メンバーの集合を閉じる。std: の名前空間も同じ規則を使う。
  • ユーザー定義 enum の値: 通常のスロットを持つ。受け手の全候補で公開され、完全な契約が同じ操作だけを解決する。
    非公開タグも候補に含め、絞り込み済みの型はその候補集合で検査する。
    特定のタグ型ならその公開メンバー集合と、証明できる内部アクセスを使う。v.Tag は通常のメンバー参照である。
  • enum の名前空間: 定義領域が公開したタグ名、または定義元からの内部参照で解決する。
    名前分解・タグ述語・タグパターンにも同じ名前の権限を要求する。
    非公開原型を公開した値の別名は構築に使えるが、タグとしての述語とパターンには使えない。
  • Any: 上「Any の使用と確定不能式」に従う。
  • 型変数: 無境界の型変数は全値について保証された操作だけを持つ。
    境界付き型変数は、その境界が保証するメンバーを持つ。
    呼び出しで未確定な型変数と Unknown は、それぞれの型決定の診断になる。

std の不透明型と interface: メソッド表を interface の一致の対象とする。
名前だけのエントリはメソッドの存在を確かめ、シグネチャ付きエントリは
その表のシグネチャと不変に照合する。静的検査と matches・アスクリプションの実行時照合は
同じ規則で一致を判定する。Db と Tx の共通操作も interface に書ける。
この規則はユーザー定義不透明型にメソッド表を追加するものではない。

定義に固定した公開範囲は、下記「非公開メンバーへのアクセス」の規則で検査する。
型メンバーは値ではなく、値の位置に置けば type-in-value-position になる。

値を持たないスロットの読み出し

スロットを読むには値を持つと静的に示す必要がある。
デフォルト値の無い未束縛スロットと、派生元で派生ごとのデフォルト値(language-spec.md §4.2.2)を持つスロットは unbound-slot-read になる。
名前での読み(c.get・c.get!)だけでなく、+ の被演算子にして演算子スロットを使う形(c + o)と、スロット分解の右辺に置く形({ get } := c)も同じ読みとして扱う。
分岐の一方だけ値を持つ場合と、可変の位置へ置いた場合も、値が存在すると示せなければ読めない。

呼び出しで埋まるスロットは、タプル引数の展開も含めて静的に決める。
関数の未束縛パラメーターを、値のスロットとして読む形も同じである。
型スロットは値ではないので、type-in-value-position として報告する。

派生ごとのデフォルト値

デフォルト値の式に自リテラルの inner_bound 名が現れるとき、そのデフォルト値を派生ごとのデフォルト値とする(language-spec.md §4.2.2)。

  • 派生元では値を持たない: リテラルそのものの型では、派生ごとのデフォルト値を持つスロットを値の無いスロットとして型付けする。
    読み出しは上記「値を持たないスロットの読み出し」の unbound-slot-read、値を要求する record 型への受け渡しは type-mismatch になる。
    ! や実引数の束縛を経た値(部分適用を含む)では、派生ごとのデフォルト値を持つスロットはデフォルト値を持つ。
    inner-name は派生元を指すので(language-spec.md §4.2)、inner-name 経由の読みも値を持たない。
  • 裸の兄弟名での読み: 同じリテラルのスロットのデフォルト値の式から、派生ごとのデフォルト値を持つスロットを裸の兄弟名で指す出現を per-derivation-default-sibling-read として報告する。
    デフォルト値が作る関数リテラルの中の出現も対象である。裸の兄弟名は派生元を指し、派生元ではそのスロットは値を持たないからである。
    同名の内側の束縛で隠されていれば報告しない。body 領域の裸の名前は呼び出しで束縛された値を指すので対象外である。
  • 効果: 派生ごとのデフォルト値の式の効果集合が空でなければ per-derivation-default-effect として報告する。効果の決め方は §2.15 に従う。
    Mut も含む 8 ラベルすべてが対象である。関数リテラルの本体の効果は数えず、関数リテラルのスロットのデフォルト値の効果は数える。
    可変な値の確保は効果ではない。派生ごとのデフォルト値の式の中で組んだ値と、inner_bound 名を通した書き込み(所有者はそのリテラル。§2.15)は、この派生で新しく作る値への書き込みなので Mut に数えない。
  • 多重度: 派生ごとのデフォルト値の式に、静的型が多重度型(language-spec.md §17.8)に解ける外側の名前が現れれば per-derivation-default-multiplicity として報告する。
    派生ごとのデフォルト値は派生のたびに評価されるので、消費も借用も、何回起きるか決まらない位置になる。

非公開メンバーへのアクセス

値の定義にある非公開スロットへの名前アクセス・代入・名前分解・レコードパターンは、
アクセスを書くコードの定義ファイルと値の定義ファイルが同じで、内部表現を静的に特定できるときだけ受理する。
条件を満たさないアクセスは private-member-access になる。
広い構造型だけの受け手は内部表現を特定する根拠にならない。
他ファイルのコールバックは、呼び出し元の内部権限を受け取らない。
存在しない名前は no-such-member、Any の操作は any-operation とし、非公開の判定を重ねない。
構造型照合・interface・型パターンは、内部権限によらず公開メンバー集合だけを使う。

export { name: T } は普通の型注釈と同じ代入可能性を検査し、公開する静的型を T にする。
実際の公開メンバー集合を変更せず、入れ子の値にも公開制限を伝播して変更することはない。
T にない名前を読むには、実際の公開メンバー集合が満たす型へのアスクリプションまたは matches の絞り込みを要する。

enum 定義と公開分解の検査

タグ原型は同じ領域に直接置いた不変な本体省略リテラルでなければならない。
原型の流用、明示した本体、原型直下の型スロット、領域内の補助束縛、
本体の他領域タグ・重複・未列挙のタグは invalid-enum-definition になる。
本体は自領域のタグ一つか、全タグを丁度一度含む非空の OneOf である。
操作内の独立した型スロットと、enum 頭部の型パラメーターは使える。

export { Tag(slot, …) } の分解列は、通常の直接スロットの宣言順の非空の部分列に限る。
逆順・重複・未定義名・型スロット・inner 名は invalid-public-decomposition になる。
空の丸括弧と項目の型注釈は構文エラーであり、名前での公開の規則と分ける。
非公開欄を位置分解へ列挙しても、名前アクセスは公開されない。

enum 構築と型引数

構築の全未束縛入力を宣言順で検査し、デフォルト値付きの操作も入力に数える。
部分適用の後の kick は必須入力を満たしている必要がある。
未完成の原型と部分適用値を完成した enum として使う形は type-mismatch になる。
型引数は不変で、状態と操作の契約に同じ型を当てる。
実引数・結果の期待型から確定させ、未確定の空タグや状態にない型引数も unresolved-type-argument にする。
匿名 union の期待型では、入れ子の匿名 union も含めて同じ enum の選択肢が 1 つだけなら、その選択肢から空タグの型引数を確定する。複数の選択肢がある場合は推論で選ばず、注釈を要求する。
暗黙の union・Any・Never による補完は行わず、確定済みの部分適用を後続の適用で再実体化しない。
再帰型と自身を返す操作は有限の型グラフで検査し、循環する推論には通常の注釈を要求する。

予約した通常スロット名

matches は固定された型判定であり、ファイルの通常スロット(import で導入するものを含む)、
関数入力・値リテラルの通常スロットに宣言すると reserved-slot-name になる。
公開・非公開、必須・デフォルト値に関係なく検査する。本体ローカルと構造型の要求名には使える。
普通の述語関数の結果には、型判定の絞り込みの証拠を与えない。

公開した値の名目型の名前

公開値の型に現れる enum・不透明型は、import した側が名前で書ける必要がある。
公開操作の入力と結果、公開原型の構築入力、公開位置分解の欄、型引数とコンテナーの要素などを再帰的に検査する。
非公開の状態だけに現れる名目型には公開を要求しない。
書けなければ公開した側で unnameable-exported-type を報告する。構造型の別名は対象外である。

  • std の型は常に名前で書ける。
  • 同じプロジェクトの相対 import は、その型を宣言したモジュールが公開していればよい。
  • パッケージの入口は、入口自身がその型を公開する必要がある。

診断は export { X } を案内する。
型名を届けることと、タグを公開するかどうかは別に選べる。

分解 import の未 export 名

スロット分解 import { a, b, … } := "…"(language-spec.md §13.2)で、解決済みの import 先モジュール(closed record)に帰着するとき、各分解名が import 先のトップレベル slot(値・型メンバーとも)に無ければ、実行時に確実にエラー(no such slot)になるため報告する。enum は Name のみがトップレベル slot で、各タグは Name の下の member なので分解 import では直接引けない。

これは export が公開を絞ったファイルから未列挙の名前を import { x } := "…" で受けるエラーを、実行前に捕捉する。循環・解決不能な import は import の診断になる。

タプル分解の要素数と分解元

タプル分解は右辺がタプル・List・String・Bytes・Range のいずれかであると静的に示す必要がある。
後の 4 つは Sequence を実装するが、タプルは Sequence 全体には一致しなくても分解できる。
示せなければ non-positional-destructure を報告する。
タプルの静的な要素数と名前の個数が合わなければ arity-mismatch になる。
List・String・Bytes・Range のように長さが静的型で決まらない場合の長さ違いは、バグ層の失敗である。
要素型は静的に検査する。Any の使用と Unknown の右辺を理由に型の検査を免除しない。

スロット分解の対象

スロット分解 { x, y } := recv は、受け手の静的型から各名前と型を解決する。
スロットを持つと示せなければ non-name-slot-destructure、無い名前は no-such-member になる。
分解元の型が分かっていても要素型を引けない場合(分解元が union・関数値など)、
注釈を書いた要素は unknown-value-type として受理しない。注釈は照合を経ずに名前の型になるからである。
分解元を matches・match で絞ってから取り出す。位置分解も同じである。
enum の名前空間からタグを取り出す形は、可視なタグの集合で検査する。
Any からの取り出しには明示の型判定かアスクリプションが必要である。

制限対象への既定の構造操作

受け手が名目的な所属または非公開の通常スロットを持つと静的に分かる場合、
組込の copy に非空の overlay を渡す操作は restricted-structural-operation になる。
定義元での操作、全通常スロットが公開された enum、公開名だけの差し替えにも適用する。
interface・Any・コンテナー経由で実体が不明なら、実行時に操作前に判定して panic する。
透明な record を受け取る汎用関数、空 overlay と普通の複製は許す。
公開した独自の copy はその関数の契約を使う。

copy-and-update overlay の未知キー

組込の copy overlay は、キーが受け手の静的型のスロットに存在する必要がある。
存在しないキーは copy-unknown-slot になる。各更新値の型も、そのスロットの型へ検査する。
受け手の由来を理由に検査を外さない。

copy スロットを持つ値は、そのスロットのシグネチャで overlay の実引数を検査する。
型とメンバーの解決を示せない overlay は受理しない。
record は幅部分型を持つので、overlay の静的型に無いスロットも実行時の overlay は持ちうる。
リテラルでない overlay は、スロット集合が確定する値(リテラルを不変に束縛した名前)のときだけ受理し、
そうでなければ copy-unknown-slot を報告する。

ブロックリテラルへの Sequence メソッド

recv.name の recv が本体付きリテラル({ params | body } / { body })で、name が Sequence(language-spec.md §17.5)のメソッド(each / map / filter / fold / length ほか)のとき sequence method on a block literal: name … を報告する。オブジェクトは要素の並びを持たない(同 §2.1)ので、この綴りは到達すれば必ず失敗する。

この形は並置形のブロック実引数に後置 .name を続けたときに生まれる。
. は並置より強く結びつくので、xs.filter { p | … }.each { p | … } の .each は
filter の結果ではなくブロック自身へ当たる。静的型から解決して診断する。
意図した連鎖は (xs.filter { … }).each { … } か、結果を名前へ束縛してから書く。

報告しない:

  • List リテラル([1, 2, 3])— 本物の Sequence であり、.each は 1, 2, 3 を巡る。
  • 本体の無いリテラル(record)— 受け手がブロックではないので、本規則ではなく §2.7 の未知スロット検査が扱う。
  • スロットを見るメソッド(names / values / has_name)— オブジェクトで意味を持つ({ a := 1 | body }.names! は ["a"]、パラメーターだけの { p | body }.names! は ["p"])。
  • universal method(copy / inspect ほか)・演算子メソッド糖衣・Sequence に無い名前。Sequence に無い名前は §2.7「存在しないメソッド/スロット」が扱う({ body }.fork! は大域関数の後置形ではなく、関数に無いメンバーなので no-such-member)。

デフォルト値の中の inner-name

スロットのデフォルト値式はリテラル評価時に宣言順で 1 回だけ走る(language-spec.md §12)。その最中のオブジェクトは半端なので、inner-name ({ inner self, … |} の self) から読めるのはその位置より上で宣言したスロットだけである。それ以外の読みを inner-name-in-default として報告する。

式 状況 エラー
self.name name が同じ slot-list の下で宣言されている(前方参照) 'name' is not initialized yet in this slot default
self.name name が同じ slot-list のスロットではない(universal method・型メソッド・未宣言) 'name' is not a slot declared above this slot default
self dot の受け手でない裸の出現(半端なオブジェクトそのものを持ち出す) inner name 'self' may only read a slot declared above it in a slot default

報告するのは inner-name の出現がデフォルト値式の中に直接あるときに限る。読みの側だけを見ても足りない — 裸の出現が残ると、半端なオブジェクトが名前を通り抜けて同じ穴が開く。

inner_bound は出現そのものを報告する。 inner_bound (language-spec.md §4.2.1) が指すのは束縛を写した自分だが、デフォルト値の評価時点では束縛がまだ始まっていない — inner-name のように「上で宣言した兄弟だけは読める」という逃げ道が無く、読める値が 1 つも無い。したがって dot の受け手かどうかを問わず、デフォルト値式の中の出現を inner-bound-in-default として報告する(inner bound name 'b' is not available in a slot default)。

inner_bound ではデフォルト値の外も報告する。 inner_bound は束縛が 1 つも始まっていない時点の名前なので、初期化済みかどうかに関わらず読める値が無い。対象はスロット destructure の右辺({ p } := b)と型注釈(x: b・{ p: b } := …)の 2 つで、それぞれ inner bound name 'b' is not available in a destructure source / … in a type annotation を報告する。

報告しない条件のうち inner_bound にも及ぶのは、body 領域・デフォルト値が作る関数リテラルの中・内側で隠されているときの 3 つである。隠されているかは束縛の綴りで見る — 走査に現れたリテラルがその名前をスロット・inner-name・inner_bound のどれかで宣言していれば、その内側の出現は別のものを指すので降りない(内側のリテラルが b を宣言していれば報告しない)。

報告しない:

  • body 領域({ … | body } の body)と、デフォルト値が作る関数リテラルの中(get := {| self.x })。どちらもデフォルト値の評価より後に走るので inner-name は完成したオブジェクトを指す。走査が止まるのは関数リテラル(body を持つリテラル)である。body を持たない入れ子のデータオブジェクト(me := { a := self |})とリスト(me := [self])はデフォルト値の評価の最中にその場で組まれるので中まで降り、そこの裸の出現も報告する。
  • inner-name が内側で隠されているとき(入れ子のリテラルが同じ名前を inner に取る・同名のローカルが手前にある)。受け手はその literal の inner-name ではない。

原始型メソッドの引数型

原始型メソッドも、受け手をシグネチャへ単一化して実引数を期待型へ検査する。
型に収まると示せなければ method-arg-type-mismatch になる。
要素型・payload 型に依存する引数と、部分適用の実引数も同じ規則で検査する。
未知の引数や Any からの下方変換を暗黙に受理しない。

2.8 演算子と適用

被演算子・呼び先・実引数に型を付け、演算と適用が成立すると静的に示す。

演算子の型不一致(二項算術)

+ / - / * / / / % / ** は、受け手の型が定める演算と引数型を静的に検査する。
組込算術は同型の Int 同士か Float 同士、String の + は String 同士である。
Int と Float を暗黙に変換しない。満たすと示せない組合せは operator-type-mismatch になる。

List 同士の + は連結で、結果の要素型を合流規則で決める。
型が割れた要素を暗黙の Any にせず、期待型を要求する。
record や関数の演算子スロットは、その静的シグネチャに従って検査する。
受け手の静的型が演算子スロットを宣言しない場合、組込のオブジェクト演算として受理しない。
Any の演算は any-operation、Unknown の被演算子は型決定のエラーになる。

union の被演算子

union の選択肢すべてについて演算が型付けできることを要求する。
型変数の境界についても、その境界が保証する演算だけを使える。
record・関数・不透明型を含むことを理由に検査を免除しない。
操作を保証できなければ、match や matches で適切な型へ絞る。

オブジェクトの + の解決

record・コンストラクター・関数の組込マージは持たない。
左辺の静的型が + スロットのシグネチャを宣言する場合だけ、そのスロットへの適用として検査する。
中置形で解決できない + は operator-type-mismatch になる。
型に現れない実行時のスロットへ委譲する可能性を根拠に受理しない。
別名・引数・不変フィールド・import・高階関数を経由しても同じである。
演算結果へのアスクリプションを理由に、演算の成立の検査を外さない。
ドット形と複合代入も演算子スロットの解決と引数型を検査する。

f := { r: { x: Int |} | r + { y := 2 |} }  # エラー: operator-type-mismatch

順序比較の型不一致

< / <= / > / >= は、compare のシグネチャに従って両辺を検査する。
組込の順序は同型の Int・Float・String・Bool・Unit 同士で定義される。
暗黙の数値変換は無い。record や不透明型の順序は、その型が保証するメソッドで判定する。
保証できない組合せは operator-type-mismatch、Any の操作は any-operation になる。

短絡の型不一致

&& / || の両辺、および真偽値の条件は Bool として検査する。
短絡で評価されない可能性があっても、右辺を型検査する。
Bool として受け取れると示せなければ non-bool-operand を報告する。
Any を暗黙に Bool へ下方変換しない。

関数でない値への適用

f a・f(a)・f! は、呼ばれる値の型から未束縛スロット・引数・結果型を決める。
関数とコンストラクターは、その適用規則に従って検査する。
呼び出せると示せない型は not-callable、Any は any-operation になる。

record の値へ渡す実引数は、値がまだ束縛していないスロットへ宣言順に当てて照合する。
型式から解いた record 型(注釈・Comparable などの interface)と、! で派生した値の型は、
値がどのスロットを未束縛で持つかを運ばない。実引数を受けるスロットを示せないので、
そうした型の値へ実引数を渡す適用は not-callable になる。
record の公開欄の型だけでは、本体が無いことを保証しない。
関数型を持たず、本体の無い値と示せない record への引数ゼロの kick も not-callable になる。

部分適用の結果は、残りのパラメーターを持つ関数型である。
その結果を続けて呼ぶ形も、段ごとにこの関数型で検査する。
完全適用の結果型が Unit なら値は捨てる。Unit を呼ばれる値として扱うことはできない。

完全適用の arity 超過

実引数の個数と型を、language-spec.md §3.5 に従って
スロットへ対応させる。対応できなければ arity-mismatch を報告する。
0 パラメーターへの実引数も検査する。1 パラメーターへ複数の実引数を渡す場合はタプルとして照合する。
不足は正当な部分適用であり、渡した実引数は型検査する。
タプルを展開する適用も型と要素数で対応を決め、型不明を理由に検査を免除しない。

引数ゼロの明示的 kick に必須スロットが残る

f() と f! は明示的 kick であり、デフォルト値で残りのスロットを埋めて本体を走らせる。
すべてを埋められると静的に示せなければ arity-mismatch を報告する。
リテラルと不変な別名ではスロットのデフォルト値をたどる。
std の関数と payload コンストラクターにはデフォルト値が無いので、未束縛パラメーターが残れば呼べない。
関数型だけを通した値は、明示的 kick が安全であると示せる情報を要求する。

obj.m { x | … }! はブロック自身へ kick が当たる。
診断は (obj.m { x | … })! のように呼び出しを括弧で囲む方法も案内する。

値コンストラクターパターンの分解個数

組込タグの位置パターンはその payload 個数、ユーザー定義タグは宣言した公開位置分解列の個数を要求する。
食い違いは arity-mismatch とし、定義元でも公開位置分解列を使う。
分解列を宣言していないユーザータグへの位置パターンは invalid-public-decomposition になる。
裸のタグは完成値の所属・タグだけを判定するので個数検査の対象ではない。
入れ子・タプル要素・ガード付きパターンにも同じ規則を使い、未確定型には型決定の診断を優先する。
E.Tag { slots } は完成値のタグ判定と名前アクセスの規則を使う。
ユーザータグへのタグを伴わない位置分解と数値添字は認めない。

2.9 分岐の収束と網羅性

分岐が型として収束すること、match が closed variant を過不足なく覆うことを要求する。いずれも契約系の診断である。

分岐の結果型に収束を要求

値として使う分岐・関数の脱出経路・コンテナー要素の型は、合流できる必要がある。
型が割れて期待型が無い場合は divergent-result を報告する。
record 同士は、両方に在る公開欄の型が合流できないときに割れとする。片方にしか無い欄は合流から落ちる。
Any へ倒して推論を続けることはしない。

期待型があれば、各枝・各要素をその型へ静的に検査する。
OneOf(Int, String) や Any を明示した期待型なら、その型へ収まる値を受け取れる。
Any を選んだ結果は操作できない。

文の位置・Unit の結果位置・ファイルルートの捨てる結果には、結果の収束を要求しない。
部分式、条件、実引数、呼ばれる側の検査は行う。
Never は値を返さない経路なので合流を妨げない。

closed variant の match に網羅性を要求

closed variant の値を照合する match は、すべてのタグと payload の可能性を覆う必要がある。
被覆を証明できなければ non-exhaustive-match を報告する。公開した不足タグか catch-all を案内する。
非公開タグも候補集合へ含め、名前を使えない不足タグには catch-all を要求し、診断に非公開名を載せない。
絞り込み済みの集合にないタグは要求しない。型引数を固定した別名のパターンはその実体化だけを覆う。
ガード付きアームは、ガードが必ず真であると証明できなければ完全被覆へ数えない。
OR パターンは枝の被覆を合わせる。

payload の列も、値の種類を列挙できる場合は再帰的に被覆を検査する。
Any や型変数の列は全可能性を列挙できないが、ワイルドカードや列全体を覆う型付き束縛なら被覆を示せる。
その列の一部だけを覆うパターンは完全被覆にしない。列挙できないことを被覆の証明に使わない。
再帰ジェネリック enum は必要な範囲で展開し、被覆を示せなければ catch-all を要求する。

非 Variant の値の網羅性は、このタグ集合の診断の対象外である。
その値の型と各アームの型は検査し、Unit フォールスルーを結果型に含める。

到達しえないアーム・冗長な catch-all

本節「closed variant の match に網羅性を要求」の網羅性(被覆漏れ=下からの不足)と対をなす、被覆過剰(上からの冗長)の収束系診断。match subject { arms } の照合対象の型が closed variant に確定するとき、確実に評価されない次のアームを報告する。match はパターンを上から試して最初の一致で確定し、catch-all は全アームが外れた後に最初の 1 つだけが使われる(prelude.md §8.4)ため以下は死アームである(ガード付きアームはガードが偽になりうるため、それより後ろのアームを死アームとは断じない)。

  • 全値一致パターンより後ろのアーム: 先行アームが全値に一致する(Any 型パターン、型付き束縛 name: Any)と、それ以降のアームは到達しない。
  • 2 つ目以降の catch-all: catch-all は最初の 1 つだけが使われるため、2 つ目以降の _ => body は到達しない。
  • 先行アームで完全被覆されたタグ: あるタグ T を完全に覆うアーム(bare タグ T / payload 全 wildcard の T(_…)、または修飾形 Name.T / Name.T(_…))より後ろに現れ、OR の全 positional が被覆済みタグだけのアームは到達しない(Some(x) => … Some(0) => … の 2 つ目)。
  • 冗長な catch-all(不要 default): closed variant の全タグが catch-all 以外のアームで完全被覆されているとき、catch-all は決して評価されない冗長アーム(Some(x) => … None => … _ => 0 の _ => 0)。網羅済みを whole-tag 完全被覆(各タグを payload 全 wildcard で覆うアームがあること)で確かめてから報告する。
  • 健全性: 本節の「完全被覆」は payload を wildcard で覆う whole-tag 被覆に限って数える。これは意図的に保守側で、入れ子の部分被覆だけで網羅が成り立つ場合は catch-all を冗長と断じない(見逃す)。列挙不能なパターンが紛れても、到達不能の根拠を「先行する全値一致」「2 つ目以降の default」「先行する whole-tag 被覆」に限るため過剰報告は生じない。照合対象の型が closed variant に確定しないときは何も報告しない。

演算子のスロットは効果を持たない

演算子のスロット(language-spec.md §8.2。+ - * / % **・->・==・compare・negate の名前で宣言したスロット)に、効果を持つ関数を置いたとき報告する。

  • スロットは効果を許さない関数型として扱う。 判定は §2.15 の効果推論が担い、どの経路で置いたかで診断が分かれる。
    • デフォルト値に書いた関数リテラルの本体が効果を起こすとき — 宣言との食い違いとして §2.15「宣言との照合」の定義側に落ち、undeclared-effect になる。
    • それ以外の値(名前・呼び出しの結果・構築で渡す実引数・copy の overlay)が効果を持つとき — 使用側に落ち、effect-mismatch になる。
    • 型を書かずに置いた値が、効果を持たないと示せない値(型変数の値・EffectConduit で受けたパラメーター)であるとき — これも effect-mismatch になる。型変数のパラメーターからは効果についての保証を得られず(§2.15「効果の保証と対象外」)、透過のパラメーターは呼び手が渡した値の効果を運ぶ。
    • 可変スロットへの書き込みは、宣言した型と一致する値しか受けない規則(§2.10)が先に拒み、mutable-slot-type-instability になる。効果を持つ関数型は効果を持たない関数型と一致しない。
    • 型に書いたスロットの関数型(record 型の +: { Int | Effect(Int, Io) } など)が効果を述べるとき、またはスロットの型が EffectConduit(F) のとき — effect-on-operator-slot になる。位置はスロットの名前。型の別名を経た形も、展開した型で判定する。
  • 見るのは 8 ラベルのすべてである。 Mut も Susp も例外にしない。スロットの本体の中で作って閉じた可変状態への書き込みは、もともと Mut にならない(§2.15「Mut の判定とスコープ吸収」)。
  • 効果は呼び先まで追うので、判定はスロット本体に直に書かれた葉に限らない。
  • Any の値への ! は操作できない。 Future か関数へ明示的に絞ってから使う。
  • なぜ規則にするか: 演算子は式のどこにでも現れ、== と compare は入れ子の等価や sort・contains のように組込の内側からも呼ばれる。呼ぶ位置で効果を採ると、組込が要素のスロットを呼ぶ位置まで効果を通す規則が要り、受け手の型がスロットを見せない位置({ x: Int |} として受けた値の a == b)では採る手掛かりも無い。置く位置で求めれば、どの位置で呼んでも演算子は効果を足さないと言い切れる。比較については、中断しうると a == b を含む式のすべてが中断点になる、という理由も加わる。
  • どのリテラルのスロットにも掛かる。 ファイルのトップレベルと本体を持つリテラルのスロットも含む。どちらも中置から届く(language-spec.md §8.1・§13.1)。
  • 効果を伴う演算が要るなら名前を付けたメソッドとして定義する。効果を伴う比較なら、比較の結果を先に求めてから sort_by / sort_with(prelude.md §6)へ明示コンパレーターとして渡す。そちらは呼び出しなので効果を持ってよい。

導出形が定まっている演算子はスロットにできない

!= < <= > >= の名前でスロットを宣言したとき報告する(language-spec.md §9.1・§9.4)。位置はスロット宣言。

  • なぜ規則にするか: != は == の否定として、< <= > >= は compare の結果から導かれる。実行系はその綴りのスロットを参照しないので、宣言しても期待どおりには動かない。知らせずに無視すると書いた人はエラーに気づけないため、定義した地点で止める。
  • 代わりに何を書くか: < <= > >= の代わりに compare を、!= の代わりに ==(または compare)を定義する。導出はそこから走る。
  • 算術(+ - * / % **)は対象外。 language-spec.md §8.1 が受け手の同名スロットによる差し替えを明示的に認めている。- は単項が negate からの導出を持つが(§8.6)、- という綴りのスロット自体は二項の減算として正当なので報告しない — 宣言だけを見て単項を差し替えるつもりだったかは判別できず、報告すれば正しい二項の宣言を誤検出することになる。

== と compare の同居は禁止

1 つのオブジェクトリテラルが == スロットと compare スロットを両方持つとき報告する(language-spec.md §9.4)。位置はオブジェクトリテラル — 悪いのはどちらか一方のスロットではなく、2 つを同居させたリテラルそのものである。

  • なぜ規則にするか: == は compare から導出されるため、両方を書けると等価と順序がずれた受け手を作れてしまう。§9.4 が「一貫性を構造的に保証する」と述べているのはこの禁止のことで、知らせずにどちらかを選ぶのではなく禁じる。
  • 単独の定義は正当。 == だけ・compare だけを持つ受け手は引き続き書ける。禁じるのは同居だけである。
  • 判定は 1 つのリテラルのスロット集合で閉じる。 別々のリテラルが片方ずつ持つ形は同居ではない。
  • 禁止は静的検査が持つ。 実行の手前で塞ぐので、同居した受け手がどの実行系にも届かない。

universal method と同じ名前のスロットの契約

上書きできる組込操作(inspect・copy・compare・reference_equals・apply_when・-> と宣言可能な演算子)は
名前で公開されている必要がある。非公開にすると private-builtin-override になる。
公開位置分解へ含めることだけでは名前公開の条件を満たさない。
matches は上書きできず、通常スロットとしての宣言は reserved-slot-name になる。

データオブジェクトのリテラル(body を省略したリテラル)と、ファイルの公開スロットが対象である。
universal method または names・values・has_name と同じ名前のスロットが、
組込の契約(language-spec.md §2.5 の表)を満たさないとき、
type-mismatch として報告する。位置はスロット宣言の名前。

演算子の名前のうち == と -> も同じ規則に従う。
受け手が型変数か record 型なら、== はスロットを見せない位置でも Bool に型が付き、-> は受け手が型変数なら (受け手の型, 実引数の型) に型が付くからである。

  • ==: どの値も 1 つ受け、Bool を返す。!= は == から導くので、同じ契約が守る。
  • ->: メソッド自身が量化する無境界の型変数のパラメーター(y: b)を 1 つ受け、(受け手の型, b) を返す。
    入力と結果の b は同じ型であり、受け手の型はそのスロットを除いた record である。
  • copy: 引数なしで呼べ、overlay を高々 1 つ受け、受け手の型を返す。
    1 つのパラメーターを持つ形は、通常または派生ごとのデフォルト値を持たなければならない。
o := { == := { x: Any | "s" } |}  # 報告する: Bool を返さない
p := { == := { x: Any | true } |}  # 通る
  • なぜ規則にするか: 受け手の型がスロットを見せない位置では、メンバー解決は組込のシグネチャを使う(§2.7)。
    実行時に呼ばれるのはスロットなので、契約を満たさないスロットを置けると静的型が値について誤る。
    値がどの型として受けられるかは使う側から分からないので、スロットを置く側で求める。
  • 受け手の型がスロットを見せる位置では、スロットの型を使う。 契約を満たす範囲で、スロットの型は組込の形と違ってよい(compare のパラメーターを受け手の型に絞る)。
  • 対象外: ファイルの非公開スロットと、関数リテラルのスロット(パラメーター)。
    型を持たない必須スロットは判定しない。
  • 型変数の値は契約を満たさない。 どの値でもありうるうえ境界に関数型を書けないので、契約を満たさないものとして報告する。
  • + は通常の演算子スロットとして検査する。 受け手の静的型がそのスロットを宣言しない位置では、組込のオブジェクト演算として型を付けない(§2.8)。
  • compare の判定は Comparable の照合と同じである(language-spec.md §17.5)。
    本体が Any の操作で止まり結果型が決まらないスロットは、そちらの診断に任せて報告しない。

OR パターンは全枝で同じ名前を束縛する

OR(カンマ区切りのパターン列、prelude.md §8.4)の各枝が違う名前を束縛するアームを報告する。どの枝が当たっても body から見える名前が同じでなければ、body は自分が読める名前を静的に決められない。

  • 対象: match subject { arms }(照合対象を持つ形)のアームで、OR の枝が 2 つ以上あるもの。枝ごとに「その枝が一致したとき body へ入る名前の集合」を求め、集合が全枝で一致しなければ報告する。
  • 名前を集める位置: レコードパターンの field({ a } / { a := v } / { a: T })・値コンストラクターパターンの payload 位置にある小文字始まりの bare 識別子(Some(x))・型付き束縛(name: T)。_ は束縛しないので数えない。
  • 束縛の無い枝同士は制約を受けない。 0, 1, 2 / None, Empty のようにどの枝も何も束縛しない形は「全枝で一致」である(空集合同士)。
  • 値つきスロット name := v も束縛である(prelude.md §8.4。{ a := 1 } => a は 1 を返す)。束縛を body で読まない分岐でも規則はかかる — 読むかどうかで規則が変わると、body を書き換えただけでパターンが合法になったり違法になったりする。値で振り分けたいだけなら アームを分ける({ a := 1 } => … と { b := 2 } => …)。
  • 診断はアームの位置に出す。 報告文は不足している名前を挙げる(variable 'b' is not bound in all patterns と同型)。
  • 機能を削るのではなく未定義の穴を塞ぐ規則である — 現状この形は、当たった枝によって body の名前参照が実行時 undefined になったりならなかったりする。

2.10 代入と可変状態

再代入とコンテナーへの書き込みは、確立した型を保つ必要がある。

slot 代入

recv.x := v はスロットを追加する形なので closed-object-slot-add になる。
要素の位置への代入は immutable-slot-assign になる。
recv.x = v は、そのスロットが静的型に存在し、可変かつ値が完成していると示せる場合だけ許す。
存在しない名前は no-such-member、不変スロットは immutable-slot-assign、
未束縛スロットを持つコンストラクターへの代入は unbound-slot-assign になる。
inner 名は派生元を指すため、本体の関数や不変な別名を経ても同じ制約を受ける。
束縛済みの可変スロットを更新するには、inner_bound 名か完成値を使う。
重ねて同じ位置へ診断を出さない。

「スロット集合が確定する」範囲

受け手の静的型が record なら、推論・注釈・mutable・import 越境の別を問わず、
操作できる名前をその型のメンバー集合に閉じる。
値が型より多くのスロットを持っていても、静的型に無い名前への書き込みはできない。

可変性や完成状態が静的型だけでは保証できない場合は、リテラルやその不変な別名をたどって証明する。
証明できない書き込みは受理しない。
動的なキーの recv.[k] は Int キーによる要素アクセスであり、スロット書き込みには使えない。

束縛の重複と immutable への代入

ローカル束縛(language-spec.md §6.1)のうち、スコープの構造だけで
確実に成立しないと分かる
ものを報告する。値の型も受け手の shape も要らないので、上の slot
代入と違って「スロット集合が確定する」のような制限はかからない。

式 状況 エラー
name := expr / mutable name := expr 同じ呼び出しフレーム / 同じリテラルのスロット宣言内に既に同名がある 'name' is already declared in this scope
a, b := expr / { a, b } := expr(mutable 前置を含む) 分解宣言が導入する名前にも同じ判定を掛ける(language-spec.md §6.3 —「各 name を導入」)。= 形は代入なので対象外 同上
name = expr / a, b = expr / { a, b } = expr スコープチェーンを遡って見つかるのが既存 immutable 束縛(分解代入は名前ごとに見る) cannot assign to immutable binding: name
name = expr スコープチェーンを遡っても束縛が見つからない。= は名前を導入しないので(language-spec.md §6.1)、宣言の綴り落ちか打ち間違いである undefined: name
a, b = expr / { a, b } = expr 分解代入も代入なので名前を導入しない(language-spec.md §6.3)。束縛の無い名前を名前ごとに報告する 同上
type Name := … / enum Name := … 型宣言も Name をスコープに載せる := なので同じ判定を掛ける(language-spec.md §17.4 —「普通の束縛(§6.1)と同じ規則」) 同上

外側スコープの同名は衝突ではない(language-spec.md §6.1)。別の
オブジェクトリテラルの同名を結果として隠すのは正当なので、重複の判定は同一スコープに
限る
。slot-list 領域と body 領域は同じリテラルに属するので
(language-spec.md §13.1)、両者にまたがる同名は重複である。

スコープチェーンには prelude が含まれる。 prelude の束縛は最外スコープの immutable 束縛
なので(language-spec.md §6.1)、println = f / max = 0 は表の 3 行目に
当たり cannot assign to immutable binding: name を報告する。prelude 名だけの特別規則では
なく、x := 1 の後の x = 2 と同じ行である。prelude は利用者のトップレベルより外側の
スコープに置くので、if := 5 / mutable max := 0 のような被覆は 1 行目の重複判定にかからない —
同じスコープへ混ぜると正当な被覆が再宣言に見えるため、チェーンに 1 段挟んで別スコープにしておく
必要がある。

ワイルドカード _ は環境に入らないため対象外 — 同一スコープで何度でも書けて、_ = expr は表の
4 行目(束縛が見つからない)にも当たらない(language-spec.md §6.1)。

スコープの解決を決められない代入も受理しない。

可変ローカルの型安定性

mutable x := v は初期値または注釈から型を確立する。
その型に Never が残る場合は mutable-never-initializer として、期待型を要求する。
ローカルと可変スロットのどちらにも適用する。

mutable acc: List(Int) := []
acc = acc + [1]
mutable pending: Option(String) := None

mutable acc := [] と mutable pending := None は要素型を決めないので受理しない。
再代入しない xs := [] は許す。

再代入 x = v は type(v) <: type(x) を静的に証明する。
分解代入 a, b = v も名前ごとに同じ証明を課す。分解元の型から要素型を引けなければ、
収まると示せないので unknown-value-type として受理しない。
複合代入 x op= v は x = x op v として検査する(language-spec.md §6.4)。
演算 x op v には中置と同じ operator-type-mismatch の規則を当て、書き込む値の型へ上の証明を課す。
型を確立した後は、クロージャからの更新も同じ型へ検査する。
違反は mutable-type-instability になり、違反を報告しても束縛の型を変えない。
型不明の右辺も受理しない。enum のタグから推論する mutable の型は親 enum へ広げて確立できるが、
明示してタグ型へ注釈した位置を再代入のために広げない。

スロット代入の型安定性

可変スロット recv.name = v は、受け手の静的型が定めるスロット型へ静的に検査する。
値の由来に依らず、収まると示せなければ mutable-slot-type-instability を報告する。
複合代入 recv.name op= v は recv.name = recv.name op v として、ローカルの複合代入と
同じく演算と書き込む値の両方を検査する。
存在・可変性・完成状態の診断とは重ねない。Any を具体型へ暗黙に下方変換しない。

可変コンテナー位置の不変性

record の型付きフィールドと、std の可変なコンテナーの型引数は不変に照合する。
Array(e) の e、ScratchMap(k, v) の k と v が対象である。
等しいと証明できなければ mutable-position-variance を報告する。
Any・Unknown・Never を wildcard として扱わない。

可変な位置の Never は確定した型であり、同じ位置の別の型と一致しない。
この規則は、式自体が値を返さない Never の代入や、不変な List(Never) の共変性を制限しない。

record は幅部分型を持つが、型付きフィールドの深さ部分型を持たない。
既存の { x: Int |} は { x: Any |} へ渡せない。
union やコンテナー・payload・関数型の内側にもこの規則を適用する。

その位置で新しく組むリテラルは期待型に従って各スロットを検査できる。
p: { x: Any |} := { x := 1 |} は新しいスロットを Any として構築するので許す。
既存の値をそのフィールドへ置く場合は、既存の値の型を不変に照合する。

アスクリプションも可変な位置の不変性を守る。実行時に安全な一致を確認できない
可変な型引数の変更を、下方変換で許すことはない。

可変なコンテナーへの書き込みの要素型照合

Array の set / push / update、ScratchMap の set / update は、
受け手の型引数が定めるキー・値・要素型へ実引数を静的に検査する。
update はブロックの結果型も検査する。型が決まらない引数を受け入れない。

不変なコンテナーの insert / merge は、新しい値の結果型を単一化で決める。
型が割れるときは期待型を要求し、暗黙の Any へ倒さない。

可変な位置への Any を含む値の書き込み

型が Any を含む値を、そこからの下方変換が必要な具体型の可変な位置へ書き込む場合は、
implicit-any-write を報告する。可変ローカル・可変スロット・可変コンテナーに同じ規則を適用する。
同じ書き込みに型安定性などの診断を重ねない。

期待される位置の型が Any なら、すべての型の値を受け取れる。
ネスト位置ではコンテナーの変性とフィールドの不変性も満たす必要がある。
Never の残る可変初期値は許さず、Unknown は値の型決定エラーになる。

下方変換には、書き込む値自身へアスクリプションを書く。
内側の式は有効な型を持つ必要があり、型が割れた計算を包むだけでは推論失敗を隠せない。

可変状態と健全性

可変ローカルとスロットは、確立した型へ書き込みを検査する。
可変コンテナーは、その型引数が定める位置へ書き込みを検査する。
さらに可変な位置を不変にすることで、同じ値へ両立しない型の視点が立つことを防ぐ。

この 2 つを合わせて、書き換えの後も静的型が値について誤らないことを保証する。
Any を経由することを、書き換えや不変性の例外にはしない。
スロット集合は宣言時に固定され、動的なキーで増やせない。

2.11 非ゼロと添字の検査

NonZero(T)(language-spec.md §17.7)の境界と、ゼロ除算・範囲外の添字という実行時エラーを実行前に見せる診断。算術・区間・値同士の関係は追わない — 見るのは定数と静的型だけである。

NonZero(T) の境界

NonZero(T) の値を要求する束縛・分解・実引数・デフォルト値・結果型・enum 原型の通常スロット では、値が次のどちらかでなければ <label> expects NonZero(Int), got Int を報告する(type-mismatch)。部分適用で渡した実引数も、型変数の実体化で NonZero(T) が入った位置も同じである。

  1. 非ゼロの定数 — 下の「除数の非ゼロ義務」と同じ線引きである。
  2. 静的型が NonZero(T) の式 — 宣言型・§2.3 の絞り込み・式アスクリプションの結果を含む。

内側に NonZero(T) を持つ List・タプル・record・variant payload・std の不透明型の型引数・Future の結果・関数の結果は、構成要素ごとに同じ規則で検査する。
リテラルなら内側の式を、変数経由なら静的型を見る。
関数の引数は不変なシグネチャとして照合し、呼び出し時の強制に任せない。
期待型を受けた分岐(if・when・match)と関数の結果では、各枝の値・末尾の値・return の値がそれぞれ境界を負う。

NonZero(T) を確立した可変ローカル・可変スロットへの再代入も境界である。再代入は確立済みの型を変えないので、照合しないまま値を入れると以降の読み出しが静的型について誤る。複合代入(p -= 1)が書き込む値は算術の結果なので NonZero(T) ではない。

  • 確かめていても報告する位置がある。 どの形が当たるかと直し方は、下の「除数の非ゼロ義務」の同じ箇条と同じである。
  • 重ねない位置: 値の静的型が Unknown(型決定のエラーが出ている)・Never(値を渡さない)のとき、基底型の不一致が報告済みのときは重ねない。Any の値は NonZero(T) へ静的に代入できない。
  • 必ずゼロの値: ゼロの定数を式アスクリプションで NonZero(T) にする形は、評価すれば必ず panic するので NonZero(Int) is never satisfied by this value を報告する(type-mismatch)。

診断には条件で確かめる形(if (x != 0) { … })とアスクリプション(expr: NonZero(Int))の 2 つの解消の道を載せる。境界で照合できた位置は、型消去が実行時照合を消す。

除数の非ゼロ義務

/ と % の除数は、0 でないと分かる式でなければならない。除数の静的型(多重度・効果の覆いを剥がした型)が Int / Float のとき、除数の式が次のどちらでもなければ cannot prove divisor is non-zero を報告する(divisor-not-proven)。ゼロ除算は実行時エラー(language-spec.md §7.1・§16.2 のバグ層)で、本規則はその実行時契約を実行前に見せる。

  1. 非ゼロの定数 — 0 でない数値リテラル(Float は 0.0 でも -0.0 でもないもの)・その単項マイナス・初期値が非ゼロの定数である不変な束縛の名前(別名の連鎖を含む。ファイル直下の束縛も含む)。算術は評価しない — K := 2 * 3 の K も (n - 1) も定数ではない。
  2. 静的型が NonZero(T) の式 — 宣言型(d: NonZero(Int))・§2.3 の絞り込み・式アスクリプション((e: NonZero(Int)))の結果を含む。NonZero(T) は prelude が持つ(prelude.md §3.3)。

Float の除数は 0.0 と -0.0 の両方を除かなければならない。-0.0 での除算も実行時エラーで、-0.0 と 0.0 は language-spec.md §9.4 の全順序では別の値だからである。

解消の道は 3 つある。 条件で確かめる(if (d != 0) { a / d }。Float なら if (d != 0.0 && d != -0.0) { a / d })・上流で宣言型を絞る(d: NonZero(Int) := …)・式アスクリプションで実行時へ委ねる(a / ((n - 1): NonZero(Int)))。診断の文言はこの 3 つを載せる。

  • 確かめていても報告する位置がある。 条件の葉にならない形(path・算術・2 つの名前の比較)で確かめた除数や、絞り込めない名前(入れ子リテラルで代入される可変ローカル・ファイル直下の公開された可変メンバー)は報告する。名前へ束縛してから確かめるか、アスクリプションで委ねる。
  • 対象は除数だけである。 被除数には義務を課さない(値に関わらずゼロ除算は起きない)。複合代入 n /= d・n %= d の右辺も除数である。
  • ** の負指数は対象外。同じ実行時エラーの族だが、被検査項が指数である(language-spec.md §7.1 のローカル節)。
  • 対象外の除数: Any・型変数・型が決まらない除数は対象外である(Any の演算は §2.2 の規則が先に拒む)。基底型の診断がある場合は重ねない。

確定した範囲外

要素アクセス(recv.[i] / recv.N。language-spec.md §3.2・§3.10)の範囲外は実行時エラー(同 §3.10・§16.2 のバグ層)である。

静的検査が報告するのは、範囲外が実行前に確定する形だけである。受け手がリストリテラルを束ねた不変な名前(xs := [10, 20, 30]。ファイル直下の束縛も含む)で、添字が整数の定数(上の「非ゼロの定数」と同じ線引きで、0 も含む)か位置アクセス recv.N の N のとき、その値が 0 未満か長さ以上なら index <i> is out of range for a list of length <n> を報告する(index-out-of-range)。

  • 添字が変数の形・受け手がパラメーターや可変な名前の形は、静的には何も報告しない。範囲は実行時に確かめる。
  • 要素型とキーの型は、範囲と関係なく必ず検査する。

2.12 Future

Future のブロックは別フローで遅延起動され、payload の値は await 前に読めない。この 2 つの性質から 2 つの診断が立つ。

Future ブロック内の脱出

レシーバー型が Future に確定する .map / .and_then のブロック本体に、外側関数から確実に脱出する return または ? bail があれば return is not allowed in a Future block: the block runs after the outer function has returned を報告する(? は bail (?) is not allowed in …)。

Future のブロックは別フローで遅延起動され、評価される時点で外側の関数は既に戻っているため脱出が成立しない。実行時は制御値を外側へ渡さず panic にする(language-spec.md §18.2 / prelude.md §9.6)ので、到達すれば確実に panic する不一致として §2 の対象になる。

脱出点の収集は §2.6「宣言結果型と全脱出経路の整合」(宣言結果型を全脱出経路で照合)が使う収集器と同一で、制御透過な経路だけを追う — if / when / while のブロック、match のアーム body、conduit{…} / loop{…} 関数のブロック引数、レシーバー型が確定する反復メソッドのブロック。

本体を持たないリテラル(リスト・record)の要素とスロットの値、文字列補間の埋め込み式は構築したその場で評価されるので、そこに書いた脱出も数える。

報告しない:

  • Future 以外の型の呼び出し。Any の操作と Unknown は、それぞれの診断で拒む。
  • 不透過なユーザー高階関数へ渡したブロック内の return — その return はブロック自身の関数境界で取り出されるため Future ブロックからは脱出せず、panic に至らない
  • 値として格納される関数リテラル内の return — 構築時には評価されない
  • break / continue — 字句的に囲うループとの関係が別軸(language-spec.md §18.1)のため静的には扱わない。この制御上の誤りは実行時のバグ層の panic になる

§2.6「宣言結果型と全脱出経路の整合」が Future ブロックを脱出経路に数えないこととは両立する — 「脱出が成立しない」という同じ事実から、§2.6「宣言結果型と全脱出経路の整合」は「宣言結果型に寄与しない」を、本規則は「書いてはならない」を導く。

Future payload の照合

Future(T) を要求する位置は、生成元の計算と静的 payload 型が T へ収まることを証明する。
示せなければ future-payload-mismatch を報告する。
payload が NonZero(T) を含むときも、他のコンテナーの要素と同じく §2.11 の境界を負う。
payload 型が Unknown なら型決定の診断になり、Any からの暗黙の下方変換はできない。

2.13 値位置の未定義参照

値の位置で名前がどのスコープにも解決しなければ undefined-ref を報告する。
prelude・トップレベル・ローカル・分解・import member・inner-name の束縛を解決する。
前方参照は宣言へ解決する。名前の解決や型を決められない値の使用も受理しない。
ワイルドカード _ と型文脈の型変数は、この値参照の規則の対象外である。

spawn に渡すブロックと、そこから名前で捕獲する関数について、同じ評価フレームにある束縛前の名前を捕獲すると unbound-capture を報告する。
不変の別名で渡すブロックも同じである。遅延する外側フレームの束縛や、帰着先を追えないブロックは、language-spec.md §10.1 の実行時検査で、捕獲から到達する名前が束縛前なら拒む。

2.14 多重度型の消費追跡

多重度型(language-spec.md §17.8)についての診断。同節が型語彙・部分型関係・複製と捕獲・実行時の扱いを定めるのに対し、本節はどう検査するかを定める — 何を追跡し、どの操作が値を消費し、消費済みの値への出現・消費状態の割れ・未消費をどう報告するかである。

多重度の消費規律は静的に証明する。通常の実行時照合へ判定を委ねない。
診断はすべて Error であり、ExactlyOnce の義務も必須である。

本節が繰り返し使う前提を先に置く。個別の規則ではこれを前提に簡潔に書く。

  • 消費追跡は束縛のフロー状態である。 対象は裸の識別子で、それが指す束縛ごとの状態は生存 / 消費済みの 2 値である。同じ名前を束縛し直した内側の束縛は、外側の束縛とは別の状態を持つ — 答えは、内側の名前を別の綴りにしたときと同じである。
  • 借用は消費状態を持たない(Borrowed(T) は多重度型ではない。§17.8)。借用についての診断(下記「借用は保存できない」「借用したレシーバーでの Consuming 呼び出しを禁じる」)は式の形と静的型だけで決まり、フロー解析を要さない。その分対象も裸の識別子に限らず式へ広がる。
  • 移譲と複製は別である。 別フローで走り起動が高々 1 回のブロックへの捕獲は所有権の移譲で、親側が消費済みになるので値へ届く経路が増えない。copy は複製で、親側に元の値が残るので経路が 2 本になる。この違いが「捕獲は許すが copy は禁じる」の根拠である(§17.8「複製と別フローへの捕獲」)。
  • 消費と借用の判定も証明する。 消費義務がある値について判定できない使用は受理しない。
    型不明や解析の予算不足を理由に義務を消さない。規律を渡せない位置は
    pass-of-multiplicity-value、追跡へ載せられない値の使用は対応する多重度の診断にする。

追跡の対象と消費する操作

追跡するのは、静的型が AtMostOnce(T) / ExactlyOnce(T) に解ける裸の識別子だけである。束縛(:=・mutable := による mutable ローカルの宣言・パラメーター束縛・分解束縛・match のアームパターン束縛)が作る名前が対象である。名前を作るのは宣言だけなので(language-spec.md §6.1)、= による再代入は追跡対象へ載せ直さない。再代入は名前が指す値を差し替え、新しい値は生存として始まる。差し替えられた旧値の扱いは下記「再代入は旧値を捨てる」が定める。

アームは排他なので、アームが束縛した名前の追跡はそのアームの中だけで有効である。兄弟のアームにも match の後ろにも持ち出さない(下記「分岐は消費状態の収束を要求する」)。

消費する操作は次のとおりである。

操作 例
Consuming メソッドの呼び出し f.close()!
多重度型の関数値の完全適用(基底が関数型のとき) k(()) / p(1)
別の名前への束縛 g := f
再代入の右辺に置く s = f
関数・メソッドの引数位置へ渡す(受け側が Borrowed でない) use(f) / o.m(f)
コンテナーへ入れる [f] / { mutable h := f |}
List 連結 + の被演算子に置く(追跡対象の包みのとき) xs + [g]
関数の外へ出す return f / 末尾式
別フローで走り起動が高々 1 回のブロックへの捕獲 spawn {| f.close()! } / fork {| … } / fut.map { v | … }
中身を所有で束縛する match の照合対象に置く match o { Some(t) => t.commit(); None => () }
多重度型へのアスクリプションの被演算子に置く(多重度を持たない名前なら資源を作る) t: Txn / raw: Txn

これ以外の出現はすべて借用である。消費後の出現は、借用であってもエラーになる(use-after-consume)。報告には消費が起きた地点を位置で添える。

アスクリプションで資源を作った名前は、追跡対象でなくても消費済みになる(language-spec.md §17.8「アスクリプションは資源を作る」)。
同じ名前から資源をもう一度作る形(a := raw: Txn の後の raw: Txn)も、名前を直に使う形(raw.commit())も、消費後の出現である。

return f が消費になるのは、f が return の直接の実引数のときだけである。 並置は段階的なカリー適用なので(language-spec.md §3.5)、return use f は (return use) f になる。関数の外へ出るのは use そのもので、f は評価されないので消費にならない。use(f) の結果を出すなら return use(f) と書く。

List 連結 + の被演算子が消費なのは、結果が被演算子の要素をそのまま持つからである。 被演算子を生かしたままにすると、同じ資源へ結果と被演算子の 2 本の経路ができる。

f := fs.open("a.txt")!.unwrap_or_else { e | panic e.message }
a := f.read_at(0, 4096)!  # 借用
b := f.read_at(4096, 4096)!  # 借用(何度でもよい)
f.close()!  # 消費
f.sync()!  # エラー: use-after-consume

ExactlyOnce の値を関数へ渡した場合、消費義務は呼び先へ移る — 呼び先ではパラメーターの宣言型が ExactlyOnce(T) なので同じ規則がその本体にかかり、呼び出し側には義務が残らない。

引数位置の消費・借用は受け側のシグネチャで決める。
部分適用も渡したパラメーターごとに判定する。
規律を渡せると示せないパラメーターへ多重度の値を置く形は pass-of-multiplicity-value になる。

捕獲を 1 回の消費とみなせるのは、ブロックが別フローで走り、かつ起動が高々 1 回のときに限る。 spawn / fork(prelude.md §9.1 / §9.9)と Future の map / and_then(同 §9.6)がこれを満たす。std:parallel の map / filter / fold(std/parallel.md)は別フローで走るが fn を要素ごとに起動するので満たさず、下記「ブロックの起動回数」の起動回数が不明な側として扱う。fork も借用にはできない — 協調フローで親子が同時には走らないが、子が消費の後に走る可能性を静的に排除できないためである。

移譲が使えるのは追跡対象の値に限る。 追跡の外にある構造に入った多重度型の値の捕獲は下記「複製と別フローへの捕獲の禁止」が塞ぐ。spawn は静的に移譲と判定した捕獲について非 Copyable 検査を省く。可変な構造は隔離複製し、共有するのは非 Copyable な実体だけである(prelude.md §9.9)。

本節は借用の行き先を追わない。 安全性が「借用したレシーバーでは Consuming メソッドを呼べない」の 1 本で立つ(§17.8)ため、借用が呼び先から漏れて生き延びても、そこから消費は起こせない。

自己参照(inner-name。language-spec.md §4.2)は、そのメソッド本体における受け手の扱いに一致させる — Consuming メソッドの本体では所有、それ以外の本体では借用。放置すると受け手の規律を迂回できるためである。

分岐は消費状態の収束を要求する

分岐の枝で消費状態が割れたとき、使用地点ではなく分岐そのものを報告する(divergent-consumption)。§2.9「分岐の結果型に収束を要求」と同じ立て付けで、書き手は両枝で消費を揃えるか、どちらの枝でも消費しないことで解消できる。

if c {  # エラー: divergent-consumption
  f.close()!
} {
  ()
}
f.read_at(0, 10)!

割れを報告するのは ExactlyOnce だけである。 AtMostOnce は使い残しを咎めない(language-spec.md §17.8)ので、分岐では報告せず合流点の状態を消費済みへ寄せ、その後で使われたときにだけ use-after-consume を報告する。ExactlyOnce では寄せられない — 消費していない枝が持つ消費義務を、寄せると気づかれないまま帳消しにしてしまうためである。

ブロックリテラルでない枝(if c { … } g)は、外側の名前を消費しない枝として合流する。 関数値の本体で外側の値を消費する形は、その定義の位置で、起動回数が不明なブロックの中の消費として禁じられている(下記「ブロックの起動回数」)ので、見えない本体が外側の名前を消費することは無い。したがって片方の枝だけで ExactlyOnce を消費すれば割れる。

Never に倒れる枝(return / break / continue / panic)は合流に寄与しない。 その枝は合流点に到達しないためで、§3.3 が Never を分岐合流の恒等元として扱うのとまったく同じ規則である。

t := begin_txn()  # t の静的型は ExactlyOnce(Txn)
when (invalid row) {
  t.rollback()
  return Err(error("bad_row", "invalid row"))  # 発散する枝。合流に寄与しない
}
t.exec "UPDATE …"  # 借用
t.commit()  # 合流後、t は生存している

ブロックの起動回数

Hikari の制御構造は予約語ではなく prelude 束縛の普通の関数(philosophy.md §2.2)なので、反復駆動とユーザー定義高階関数は構文上どちらも「ブロックを渡す呼び出し」である。したがって外側の値を消費できるかは、ループかどうかではなくそのブロック位置が高々 1 回しか起動されないと仕様が定めているかで決める。

「高々 1 回」の側は次の表で全部である。この表に無いブロック位置は prelude・std・ユーザー定義のいずれであっても「不明」へ倒す。一覧がこの向きに閉じているので、ブロックを取る関数・メソッドが将来増えても健全性は保たれる。

ブロック位置 起動回数 出どころ
if の then / else、when の then、match(照合対象を持つ形と持たない形の両方)のアーム body 分岐 prelude.md §8
Option / Result の map / and_then / filter / map_err / or_else / unwrap_or_else 0 か 1 回 prelude.md §12
Ordering の then(Equal のときだけ起動する) 0 か 1 回 prelude.md §13.2
apply_when の f(条件が真のときだけ起動する) 0 か 1 回 prelude.md §16
db.transaction(トランザクションを開けなければ起動しない) 0 か 1 回 std/db.md §9
term.raw_mode(raw mode に切り替えられなければ起動しない) 0 か 1 回 std/term.md §1
arr.build / arr.collect / a.update 丁度 1 回 std/array.md
m.insertion.build / h.update 丁度 1 回 std/map.md

これらの位置では外側の値の消費を許す。消費した名前は、起動回数に応じて次のように合流する。

  • 分岐 — 分岐の枝と match のアーム body は、上記の収束規則で合流する。
  • 丁度 1 回 — ブロックの中の消費は、呼び出しの位置で外側の名前を消費したのと同じである。呼び出しの後ろでその名前を使えば use-after-consume になる。
  • 0 か 1 回 — 起動しない経路を持つので、ブロックを 1 つの枝とし、何もしない枝を補った分岐として合流する。したがって ExactlyOnce の値をブロックの中だけで消費すれば、呼び出しそのものを divergent-consumption として報告する — 起動しなかった経路でその義務が気づかれないまま消えるためである。AtMostOnce は分岐と同じく合流点の状態を消費済みへ寄せ、呼び出しの後ろで使えば use-after-consume になる。

「丁度 1 回」と「0 か 1 回」のどちらでも、ブロックの本体が Never に倒れるなら、分岐の枝と同じく合流に寄与しない。

panic(Error を含む)で止まる経路は、起動しない経路として数えない。a.update の範囲外添字はそこで止まるので「丁度 1 回」に入る。

表の行は、ブロックを渡す呼び出しが完全適用のときに限る。 部分適用の実引数に置いたブロック(k := if(c, { … })・k := if c { … })は、結果の関数値が何度でも呼べ、1 度も呼ばれないこともあるので、起動回数は不明である。部分適用した値へ後からブロックを渡す形(k({ … }))も同じである。

t := begin_txn()  # t の静的型は ExactlyOnce(Txn)
o.map { v | t.commit() }  # エラー: divergent-consumption(o が None なら t の義務が消える)

a := arr.array(2, 0)
u := begin_txn()
a.update 0 { x | u.commit(); x }  # 丁度 1 回。ここで u は消費済みになる
u.commit()  # エラー: use-after-consume

w := begin_txn()
k := if(c, { w.commit() })  # エラー: consume-in-unknown-arity-block(k は何度でも呼べる)

表のほかに、宣言で開く行が 1 つある。 呼び先の関数型が引け、ブロックが現れた実引数に対応するパラメーターの宣言型が ExactlyOnce(基底が関数型)に解けるなら、そのブロック位置も「高々 1 回」の側で、起動回数は「丁度 1 回」である(language-spec.md §17.8「ブロックの起動回数を宣言する」)。db.transaction と構造が同じ自前の bracket(with_conn(pool) { c | … })がこれで書ける。その宣言は呼び先の本体で本節自身が検証する — ブロックを 1 度も呼ばなければ never-consumed、2 度呼べば use-after-consume になる。

AtMostOnce と Borrowed は開かない。 宣言で開くのは、呼び先の本体が丁度 1 回の起動を検証できる宣言だけである。AtMostOnce は 0 回の可能性を残すので、その保証にならない。Borrowed は消費義務を持たないので起動回数について何も述べていない。

残りはすべて起動回数が不明(0〜n 回)で、外側の値の消費を禁じる(consume-in-unknown-arity-block)。代表を挙げる。

ブロック位置 出どころ
while の条件ブロックと本体ブロック prelude.md §8.3
Sequence の each / map / filter / fold / find / any / all / count(List / String / Bytes / Range) language-spec.md §7.4
List 固有の flat_map / partition / sort_by / sort_with / take_while / drop_while / max_by / min_by prelude.md §6 / §13.4
std:map / std:set の each / map / filter / fold、std:parallel の map / filter / fold std/map.md / std/set.md / std/parallel.md
loop{…} と capture language-spec.md §18.4
test("name", {block}) のブロック(test は Trial を構築するだけで、起動するのは run) std/test.md
serve の handler と応答の stream の sink std/http/server.md
ユーザー定義高階関数へ渡したブロック(conduit 注釈を持つものを含む)。対応するパラメーターを ExactlyOnce で宣言したものは上記の開く行になる language-spec.md §18.3

別フローで走り、かつ起動が高々 1 回のブロック(spawn / fork・Future の map / and_then)だけはこの軸に乗らない — 起動を待たず、捕獲の時点で消費になる(上記「追跡の対象と消費する操作」)。

借用はどのブロック位置でも自由である。 実用上のループはほぼ借用なので、制限が刺さる場面は限られる。パラメーターを取る std の bracket は、そのパラメーターを Borrowed(T) で宣言する — ブロックがハンドルを消費できず bracket 自身の後始末が壊れないようにするためである(std/array.md)。

f := fs.open_rw("log")!.unwrap_or_else { e | panic e.message }
xs.each { x | f.write_at(0, x)! }  # 借用。何周でもよい
f.close()!  # 消費はループの外

xs.each { x | f.close()! }  # エラー: consume-in-unknown-arity-block

xs.each { x |
  g := fs.open(x)!.unwrap_or_else { e | panic e.message }
  g.close()!  # ブロック内で束縛しブロック内で消費 — 通る
}

break / continue による運び出しの禁止

break / continue の実引数の式の静的型が追跡対象(多重度型そのものか、多重度を伝播する包み)に解けるとき、escape-of-multiplicity-value として報告する。 break value はループ式全体の戻り値を value にする(prelude.md §8.5)ので、値はループの外へ出て同じ関数の中に残る。return と違い関数の外へ出ないので消費ではなく、かといって追跡はループのスコープで切れるため、外へ出た値が規律の外で生き延びる。

対象は発火する適用の実引数だけである。並置は左結合の適用なので(language-spec.md §8.3)、break use t は (break use) t と読まれ、発火するのは break use で、外側の t は評価されないままループを抜ける。外側の実引数は運び出しにも消費にも当たらず、消費しないまま抜けた経路として下の消費義務が報告する。return use t の外側の t も同じで、関数の外へ出ないので消費ではない。

実引数は裸の識別子に限らない。 その場で作った値(break begin())・包んだ値(break Some(t))・コンテナーリテラル(break [t])・パス(break r.held)も同じに報告する。名前を経ない値でも、ループの外へ出れば規律の外で生き延びる。パスはルートのコンテナーから取り出す形なので、報告しないとルートの義務まで気づかれないまま消える。

報告した名前は消費義務の判定から外す。 1 つの誤りに報告は 1 つである。運び出しは消費ではないので消費とも記録せず、後でその名前を使っても use-after-consume にはならない。

r := while { true } {
  break begin_txn()  # エラー: escape-of-multiplicity-value
}

ExactlyOnce の消費義務

義務を果たす期限はその値を束縛したスコープの終わりで、全脱出経路(break / continue / return / ? の bail。§2.6「宣言結果型と全脱出経路の整合」と同じ経路列挙)で消費されていなければ never-consumed を報告する。

xs.each { x |
  t := begin_txn()  # t の静的型は ExactlyOnce(Txn)
  t.exec "insert …"
}  # エラー: never-consumed(どの脱出経路でも t が消費されない)

トップレベル束縛にも同じ期限がかかる。 そのスコープの終わりはファイル評価の終わりなので、そこまでに消費されなければ never-consumed になる。多重度型の値は export できない(下記「モジュール境界とトップレベル束縛」)ので、義務がファイルの外へ出ることはない。

panic 経路には義務を課さない(そこでプログラムが終了するため。language-spec.md §16.2)。キャンセルで止まったフロー(root の完了による放棄を含む。language-spec.md §10.3・§13.3)も、panic と同じ巻き戻しの経路で止まるので義務を課さない。捕獲した値を消費しないまま止まっても使い残しではない。Hikari はスコープ離脱フックを持たないので、未消費の値が自動で消費されることはない。

式だけの文は値を捨てる

式だけの文の値の静的型が ExactlyOnce を含む(ExactlyOnce そのものか、それを中身に持つ包み)なら、その文に never-consumed を報告する。 式だけの文の値は名前に束縛されず、どこへも渡らないまま捨てられる。束縛した名前なら期限で義務を問えるが、名前を持たない値には問う先が無い。

begin_txn()  # エラー: never-consumed(値が捨てられる)
t := begin_txn()  # 通る — 義務は t が負う
t.commit()
  • 本体の末尾の式だけの文は捨てる位置ではない(下記の、結果を捨てるブロックを除く)。関数リテラルの本体の末尾は結果として外へ出る(上記「追跡の対象と消費する操作」の「関数の外へ出す」)。分岐の枝と match のアーム body の末尾は、分岐の値として合流先へ渡る。
  • トップレベルの文列の末尾は捨てる位置である。 ファイル評価の値はどこへも渡らない。
  • ワイルドカードへの束縛(_ := e / _ = e)は式だけの文と同じである。 右辺を評価して何も束縛しない(language-spec.md §6.1)ので、値は同じく捨てられる。
  • 式だけの文やワイルドカードへの束縛に名前・パスを置く形(t だけの行・_ := t・r.held だけの行)は値を移さない。 名前がまだ値を持っているので、義務は名前に残る。後で消費しなければ、その名前の束縛に never-consumed が出る。
  • 結果を捨てるブロックの本体の末尾は捨てる位置である。 呼び先がブロックの結果を捨てる位置では、末尾の値はどこへも渡らない。そうした位置は次のとおりである。
    • 組込の each(Sequence・std:map・std:set ほか、受け手が record でないもの)と while の本体。record のスロットとして定義した each は、次の項目が宣言型で決める。
    • 呼び先の関数型が引け、ブロックが現れた実引数に対応するパラメーターの宣言型が、結果型 Unit の関数型に解ける位置。結果型 Unit は discard コンテキストである(language-spec.md §17「宣言結果型が Unit」)。

末尾の式の静的型が ExactlyOnce を含むなら、その式に報告する。末尾が名前でも同じである — 名前を末尾に置く形は関数の外へ出す消費として記録されるが、出した先で捨てられる。ブロックリテラルでない関数値(xs.each(mk))をこの位置へ渡すときは、その関数型の結果型で判定して実引数に報告する。

  • AtMostOnce だけを含む値は報告しない。 使い残しを咎めない(language-spec.md §17.8)。
  • Never は値を生まず消費の対象が無い。捨てる結果の Unknown は型付けの対象外だが、
    その部分式は検査する。Any にして多重度の義務を消すことはできない。
_ := begin_txn()  # エラー: never-consumed(値が捨てられる)
xs.each { x | begin_txn() }  # エラー: never-consumed(each はブロックの結果を捨てる)
run := { f: {| Unit } | f() }
run { begin_txn() }  # エラー: never-consumed(結果型 Unit の位置)

名前の無い値を借用で使い捨てない

名前を持たない式の値の静的型が ExactlyOnce を含むとき、その式を借用の位置に置いたら、その式に never-consumed を報告する。 借用の後にその値を持つ者がいないので、値はそこで捨てられる。式だけの文と同じ理由である。借用の位置は次の 2 つである。

  • メンバー参照の受け手 e.x のうち、e を消費しないもの。 消費するのは次の 3 つで、それ以外(非 Consuming のメソッドの呼び出しと取り出し・universal method・多重度型を含まないスロットの参照)は借用である。
    • Consuming のメソッドの呼び出し(begin_txn().commit())。
    • 中身をコンテナーの外へ出す組込メソッドの呼び出し(上記「コンテナーの中身を所有で受けるブロック」)。
    • 多重度型を含むスロットの参照(mk().held)。取り出した値は、置いた位置の文脈で扱う — それを借用の位置に置けば(mk().held.ping())、そこで報告する。
  • Borrowed で宣言したパラメーターへの実引数。

名前を持つ値では義務がその名前に残り、「ExactlyOnce の消費義務」が期限で問う。
AtMostOnce だけを含む値の使い残しは診断しない。Never は値を生じない。
Unknown の部分式は型決定の診断とし、Any への変更でも多重度の義務を消さない。

begin_txn().exec "UPDATE …"  # エラー: never-consumed(借用の後で値が捨てられる)
println [begin_txn()].length()  # エラー: never-consumed
println begin_txn().commit()  # 通る(Consuming のメソッドの呼び出しは消費)

再代入は旧値を捨てる

再代入 s = v は、s がそれまで指していた値(旧値)をその時点で捨てる。捨てた値が自動で消費されることはないので、旧値が未消費の ExactlyOnce なら義務を果たす手立てはそこで失われる。これを再代入の位置に never-consumed として報告する。スコープの終わりまで待たないのは、そこで問われるのは新しい値の義務であって、旧値の義務ではないためである。

mutable t := begin_txn()
t = begin_txn()  # エラー: never-consumed(最初の値は消費されないまま捨てられる)
t.commit()

mutable u := begin_txn()
u.commit()
u = begin_txn()  # 通る — 旧値は消費済み
u.commit()
  • 右辺は代入より先に評価される。 右辺が旧値を消費する形(t = renew(t))では、捨てる時点の旧値は消費済みなので報告しない。右辺に裸の識別子を置く形(s = t)は t の消費である(上記「追跡の対象と消費する操作」)。
  • 分岐は上記「分岐は消費状態の収束を要求する」に揃える。 枝の中の再代入はその枝の状態で判定する — 旧値が生存したまま枝の中で差し替える形(if c { t = begin_txn() } { () })は、その再代入を報告する。片側の枝だけで消費した名前は分岐そのものが divergent-consumption として報告済みで消費義務の判定から外れているので、合流後の再代入では重ねて報告しない。
  • AtMostOnce は報告しない。 使い残しを咎めない(language-spec.md §17.8)ので、旧値を捨てても義務は破れない。
  • 判定できない使用: 再代入で旧値の消費義務を果たしたと示せなければ診断する。
    外側の値をブロックから更新する形も、起動回数と消費状態を証明する必要がある。

包みは多重度を伝播する

失敗しうるコンストラクターはすべて包みを通る(fs.open は Future(Result(File)) を返す)ため、包みが多重度を継承しないと主要な入口が丸ごと追跡の外に出る。線引きは個別のコンテナー名ではなく構造で決める。

  • 伝播する(包み自体を 1 つの追跡対象にでき、中身を出す形をその包みの消費として記録できる): 組込タグの payload・ユーザー定義 enum の通常スロット・タプル・Future・List・record。Option / Result は組込 enum(language-spec.md §17.4)なので、この規則はそれらを特例にせずユーザー定義 enum も自動的に含む。Future はタグを持たないが「0 か 1 個を包み取り出しが 1 回きり」の側なので同じ扱いとする。record は下記「record はコンテナーである」が定める。
  • 解析の上限: 包みの内側を追いきれない場合、規律を持つ値として安全に使えると
    示せない操作は受理しない。多重度が無い型へ変えて追跡を消すことはしない。

中身が多重度型なら包み自体を追跡し、unwrap・?・!・分解・要素とスロットの取り出し・
中身を束縛する match を消費として扱う。ハンドルの実行時の封印も残るが、静的な証明の代わりにはしない。

r := fs.open("a.txt")!
a := r.unwrap_or_else { e | panic e.message }
b := r.unwrap_or_else { e | panic e.message }  # エラー: use-after-consume(r は 1 度目で消費済み)

効果の層はこの線の外である。 線を引いているのはコンテナーについてであり、Effect(T, …) はコンテナーではない(language-spec.md §17.9)。効果の層を挟んだ位置に在るのは基底の値そのものなので義務はそのまま届き、Effect(ExactlyOnce(T), …) を結果型に宣言した関数の返り値を束縛した名前は追跡対象になる。層と包みが重なる Effect(Future(Result(File)), Fs, Susp) も同じである。

List が伝播する側なのは、追跡するのがコンテナーであって要素ではないからである。 要素は恒久的に対象外のまま(§17.8「規律を課さないと決めたもの」)で、追跡対象に載るのはコンテナーを束縛した裸の識別子 1 つである。コンテナーを外すと、コンテナーから取り出すたびに新しい追跡対象が生まれる一方でコンテナーの側からは何も減らないため、1 つの資源に対して独立に果たせる義務が人数分できる。タプルと違って長さが静的でないので、取り出しはコンテナーごと 1 回きりになる — 複数の要素を扱うなら借用で回す(下記「コンテナーの中身を所有で受けるブロック」)か、(要素, 残り) を返す形で取り出す(hit, rest := xs.partition { l: Borrowed(Lease) | … } はコンテナーを消費して 2 つのコンテナーを返す)。

要素アクセスを消費とするのは、下記「追跡の適用範囲」のコンテナー単位での追跡である。例外の対象はタプルの要素・variant payload・List の要素・record のスロットに限る。

コンテナーの中身を所有で受けるブロック

追跡対象の List / Option / Result を受け手とする組込メソッドが、その中身をコンテナーの外へ出す形はコンテナーの消費である。 組込型メソッドは呼び先の関数型が引けない(上記「追跡の対象と消費する操作」)ので、呼び出しそのものからは借用か消費かが決まらない。しかし外へ出したかどうかは型から決まるので、判定はそこに置く。次の 2 つのどちらかに当たる呼び出しがコンテナーの消費である。

  • 結果型が多重度型を含む。 xs.first! は Option(Lease) を返すので要素をコンテナーの外へ出している。含まないもの(xs.count! の Int・xs.is_empty! の Bool・o.is_some! の Bool)はコンテナーを覗いただけなので消費ではない。
  • 実引数のブロックのパラメーターが、所有の多重度型である。 xs.each { e: Lease | … } の e や o.map { t: Txn | … } の t は書き手が所有で受けると書いた位置で、そのブロックは中身の消費義務を引き受ける。注釈の無いパラメーター(o.map { t | … })は流れてくる型(§2.2「注釈の無いブロックパラメーターへ型を流す」)で決める — ブロックの中でその名前は流れてきた型を持つので、所有の多重度型なら消費できるためである。Borrowed で受けるブロック(xs.each { e: Borrowed(Lease) | … })は消費状態を持たないのでコンテナーを消費せず、何度書いてもよい。

消費かどうかを列挙ではなく型で決めるのは、std にメソッドが増えても穴が開かないようにするためである。消費した呼び出しが中身を取りこぼさないかは、下記「コンテナーから取り出すときは中身を取りこぼさない」が一覧で定める。

xs := [l]  # l: Lease(ExactlyOnce)
xs.each { e: Borrowed(Lease) | e.ping() }  # 通る(借用はコンテナーを消費しない)
xs.each { e: Lease | e.done() }  # コンテナーの消費。各要素の義務はブロックが負う
xs.each { e: Lease | e.done() }  # エラー: use-after-consume(xs は 1 度目で消費済み)

record はコンテナーである

多重度型を含むスロットを持つ record は、List と同じくコンテナーとして追跡する。 多重度型を含むスロットとは、静的型が追跡対象(多重度型そのものか、多重度を伝播する包み)に解けるスロットである。追跡対象に載るのは record を束縛した裸の識別子で、スロットは追跡対象にならない。基底が record の多重度型(type Box := AtMostOnce({ held: Lease |}))も、多重度型を含むスロットについては同じに扱う。

スロットの参照 r.held は r の出現として数える。 数え方は、r.held の値を束縛した名前をその位置に置いたときと同じである。

  • 消費になる位置(束縛・実引数・コンテナー・return・捕獲・Consuming メソッドの受け手・取り出しの 5 形)に置けば r の消費である。
  • 借用になる位置(Consuming でないメソッドの受け手・Borrowed のパラメーターへの実引数)に置けば r の借用である。
  • 多重度型を含まないスロットの参照(r.n)は借用である。タプルの p.1 と同じである。
  • ルートが裸の識別子のパス(r.box.held)も、ルート r の出現として同じに数える。

複数のスロットを取り出すときは名前分解で一度に取る。 { held, spare } := r は r の消費で、束縛した各名前が追跡対象になる。

r := { held := l, n := 1 |}  # l: Lease(ExactlyOnce)。r は ExactlyOnce を含むコンテナーになる
r.held.ping()  # 借用
m := r.n  # 借用(多重度型を含まないスロット)
a := r.held  # r の消費。a が追跡対象になる
b := r.held  # エラー: use-after-consume(r は 1 度目で消費済み)

多重度型を含むスロットへの代入は assign-of-multiplicity-slot として報告する。 差し替え(r.held = l2)を許すと、次のどちらでも規律が破れる。

  • 取り出して消費済みになったコンテナーへ新しい値を入れると、差し替え後の参照が use-after-consume の誤検出になる。
  • 取り出す前に差し替えると、捨てた旧値の義務が気づかれないまま消える(上記「再代入は旧値を捨てる」と同じ理由)。

判定は代入先のスロットの静的型で決める。スロットの値を入れ替えたいときは、名前分解で取り出してから record を作り直す。

コンテナーから取り出すときは中身を取りこぼさない

コンテナーから取り出すときは、ExactlyOnce を含む中身をすべて受けなければならない。 取り出しはコンテナーごと 1 回きりなので、受けなかった中身へはもう届かず、その義務は気づかれないまま消える。これを取り出しの位置に never-consumed として報告する。

  • 分解束縛 — 位置分解の _(a, _ := p)と、名前分解が名指さないスロット({ held } := r の後に残る spare)が ExactlyOnce を含むなら報告する。List の位置分解も同じである — 名前の数と要素の数が合わなければ実行時に止まるので、_ 以外の要素はすべて受けている。
  • 要素アクセス・スロットの参照(p.0 / v.0 / r.held を消費の位置に置く形。v は variant)— 取り出したもの以外に ExactlyOnce を含む要素・スロットがコンテナーに残るなら報告する。中身を複数持つコンテナーからは分解で取り出す。List の要素アクセス(xs.0)は残りの要素があるかを静的に決められないので、要素型が ExactlyOnce を含むなら常に報告する。
  • 組込メソッドによる取り出し(上記「コンテナーの中身を所有で受けるブロック」が消費とする呼び出し)— 下の表の「引き渡す」に無いメソッドは報告する。表はこの向きに閉じているので、std にメソッドが増えても穴は開かない。
  • match — 下記「match はコンテナーからの取り出しである」が定める。
  • AtMostOnce だけを含む中身は報告しない。 使い残しを咎めない(language-spec.md §17.8)。
  • 借用の位置は取り出しではない(r.held.ping())ので対象外である。
受け手 中身をすべて引き渡す(報告しない) 中身を落としうる(報告する)
List 所有で受けるブロックを取る each / map / fold / flat_map、要素を減らさない partition / reverse / sort / sort_by / sort_with / flatten / to_list それ以外すべて(first / last / find / filter / take / drop / zip / unique ほか)
Option map / and_then / or_else / unwrap_or_else / unwrap / or / ok_or / flatten filter / zip(Some の中身を落としうる)、それ以外すべて
Result map / and_then / map_err / or_else / unwrap_or_else / unwrap / unwrap_err ok / or(Err の中身)・err(Ok の中身)、それ以外すべて

Option / Result の「落としうる」メソッドのうち、落とす側を名指したもの(filter / zip / ok / or / err)は、落とす側が ExactlyOnce を含むときだけ報告する — fs.open(p)! の Result(File) に ok を呼んでも、落ちるのはエラーの値だけである。名指していないメソッドは、どちらかの側が ExactlyOnce を含めば報告する。

p := (t1, t2)  # t1, t2: Txn(ExactlyOnce)
a := p.0  # エラー: never-consumed(p.1 の義務が消える)
a, _ := p  # エラー: never-consumed(_ に置いた義務が消える)
a, b := p  # 通る(中身をすべて受ける)

xs := [t3, t4]
f := xs.first!  # エラー: never-consumed(残りの要素の義務が消える)
xs.each { t: Txn | t.commit() }  # 通る(すべての要素をブロックへ渡す)

match はコンテナーからの取り出しである

アームのパターンが中身を所有で束縛する match は、照合対象の消費である。 どれか 1 つのアームのパターンが、静的型が追跡対象に解ける名前を束縛すれば(Some(t) の t が Txn)、その match はここに当たる。所有は照合対象からアームの名前へ移るので、t := o! と同じく照合対象を消費済みにする。

  • 消費は照合対象の位置に記録し、どのアームの中でも照合対象は消費済みである。アームごとに消費状態を分けないのは、中身を持たない variant(None)のアームだけ照合対象が生存し、正しい match が divergent-consumption になるためである。
  • 照合対象がパス(match r.held { … })なら、ルートの消費として数える(上記「record はコンテナーである」)。
  • 照合対象が起動回数の不明なブロックの外で束縛した名前なら、他の消費と同じく consume-in-unknown-arity-block になる。

消費する match は、照合したのに受けなかった中身を報告する(never-consumed)。分解束縛の _ と同じ理由である。

  • パターンの中のワイルドカード _(Err(_))が、ExactlyOnce を含む中身に当たるなら報告する。record パターンが名指さないスロットも同じである。
  • アーム全体のワイルドカード _ は、それより前のアームが拾い切っていない variant をすべて拾う。そのうち ExactlyOnce を含む中身を持つ variant があれば報告する。拾い切ったと数えるのは、ガードを持たないアームが、その variant の中身をすべて名前か _ で受けるパターン(Some(t) / Err(_))を置いたときだけで、判定できない形は報告する側へ倒す。

中身を束縛しない match は借用である。 アームのパターンが追跡対象を 1 つも束縛しない形(Some(_) / None だけ)は照合対象を覗くだけなので、照合対象は生存したままで、義務も照合対象に残る。後で照合対象を消費しなければ、照合対象の束縛に never-consumed が出る。

照合対象が名前でない式(match mk() { … })は、常に消費する側として扱う。 match の後にその値を持つ者がいないので、受けなかった中身は上の規則で報告する。

o: Option(Txn) := Some(begin_txn())
match o {
  Some(t) => t.commit()
  None => ()
}  # o の消費。t が義務を負う
# 次の match の o がエラー: use-after-consume(o は消費済み)
match o {
  Some(t) => t.commit()
  None => ()
}

r: Result(Txn, Txn) := Ok(begin_txn())
match r {
  Ok(t) => t.commit()
  Err(_) => ()  # エラー: never-consumed(Err の中身の義務が消える)
}

p: Option(Txn) := Some(begin_txn())
# 中身を束縛しない match は借用
match p {
  Some(_) => println "has"
  None => ()
}
p.unwrap_or_else {| begin_txn() }.commit()  # 通る — 義務は p に残っていた

関数値へ閉じ込める経路を塞ぐ

メソッドはスロットに入った普通の関数なので値として取り出せるが、取り出した時点で受け手との関連が切れて追跡が終わる。取り出した関数値はコンテナーにも別フローにも別モジュールにも渡せるので、多重度型のメソッドは呼び出し形(f.close() / f.close!)でのみ使えるとする。Consuming メソッドの取り出しは cannot-extract-consuming、非 Consuming メソッドの取り出しは受け手への借用を保存する形なので cannot-bind-borrowed である。

Consuming のメソッドの取り出しは、受け手の形を問わず報告する。 裸の識別子に限らず、式(mk().close・r.held.close)から取り出す形も cannot-extract-consuming になる。式の値は名前を持たないので消費追跡の対象ではない(下記「追跡の適用範囲」)が、取り出した関数値は何度でも呼べるので、1 つの値を何度でも消費できる。基底が record の多重度型には実行時の封印も無いので、ここで塞がないとどこも止めない。非 Consuming のメソッドの取り出しは受け手の形で分かれたままである — 借用の受け手なら上記の cannot-bind-borrowed で、所有の式の受け手(mk().ping)なら報告しない。

引数側は事情が違う。auto-curry(language-spec.md §3.6)で作った部分適用は何度でも適用できるので、素朴には「値は 1 回消費されたことになっているのに本体は呼ばれた回数だけ走る」ことになる。これは結果の側に多重度を載せることで解ける — 追跡対象の実引数を埋めた部分適用の結果は多重度型になり(language-spec.md §17.8「関数値の多重度」)、その関数値を呼ぶことが上の表のとおり消費だからである。2 回呼べば use-after-consume、ExactlyOnce を埋めて 1 度も呼ばなければ never-consumed になる。部分適用のための専用の規律は要らない。

  • 載せる多重度は「強い方が勝つ」。 埋めた実引数(および包みの内側)に ExactlyOnce が 1 つでもあれば結果は ExactlyOnce、無く AtMostOnce だけなら AtMostOnce である。弱めると「丁度 1 回消費する」義務が、結果を呼ばないことで消えてしまう。
  • 借用の引数は多重度を載せない。 借用は消費できないので果たすべき義務が無い。
  • 部分適用そのものは消費ではない。 本体が走らない(§3.6)ので資源も使われず、回数の規律は結果の側へ移る。呼び先が既に多重度型なら、そこへの部分適用の結果もその多重度を引き継ぐ — これにより多段の部分適用(u3(l) の後の p(1))でも義務が落ちない。
  • 明示的 kick(use(f)! / use(f)())は部分適用ではないので報告しない。 未束縛スロットへデフォルト値が入るのは明示的 kick に固有の意味論なので(§3.6)、残りのスロットがデフォルト値を持つならその呼び出しで本体が丁度 1 回走り、多重度型の値も丁度 1 回消費される。残りのスロットにデフォルト値が無い形は到達すれば実行時の arity panic であり、そちらは arity 不一致の管轄に留まる。

規律が届かない位置へ多重度型の値を渡せない

実引数の式の静的型が追跡対象(多重度型そのものか、多重度を伝播する包み)に解けるとき、渡した先にその多重度が届かないなら pass-of-multiplicity-value として報告する。 届かない位置は 3 つあり、どれも渡した先に規律を課す先が無いという 1 つの理由の現れである。

  • 受け手が std の不透明ハンドルに解けるメソッド呼び出しの実引数。 組込型メソッドは呼び先の関数型が引けないので(上記「追跡の対象と消費する操作」)、渡した値が消費されたのか借用されたのかを判定する材料が無い。検査せずに許すと、名前を渡した形では呼び手側でもその名前が生きたままになり、渡した先(コレクションの中)と呼び手の両方から同じ資源へ届く経路ができる。language-spec.md §17.8 が「コレクション要素は恒久的に対象外」と定めている以上、入った先で拾い直す道は無い。
  • 呼び先の関数型は引けるが、対応するパラメーターの宣言型が多重度型に解けない位置。 型の照合は多重度の層を剥がして基底同士で行う(§17.8)ので、この形は型としては通る。渡すこと自体は消費として記録されるため呼び手の側の名前は使えなくなるが、受け側の名前が追跡対象にならない — その中では同じ資源を何度でも使える。宣言型が Any の位置もここに入る(println t を含む)。Any の値をアスクリプションで取り出すたびに新しい義務が生まれるからである。
  • 呼び先の関数型は引けるが、対応するパラメーターの宣言型が型変数に解ける位置。 型変数にはスロットも多重度も無いので規律を課す先が無く(§17.8「基底に型変数を置く」)、消費とも借用とも決められないので呼び手の側の名前まで生きたまま残る。境界の有無は問わない — 境界は確定できる型を絞るだけで、多重度の規律を課す先を作らないからである。

多重度型の値を、注釈の型が多重度を持たない束縛・スロット・結果へ置く形と、そうした型へのアスクリプションも同じ理由で報告する。 注釈が型を決めるので、置いた先の名前は追跡対象にならない。
a: Any := t・xs: List(Any) := [t]・r: { ping: {| Int } |} := t・結果型が Any の関数から t を返す形・use(t: Any) がこれにあたる。
アスクリプションは名前の無い値(use(mint(): Any))にもかかる — 義務を持つ値が名前を経ずに規律の外へ出るからである。
置くこと自体は元の名前の消費として記録される。Never の位置は値を受け取らないので対象外であり、Borrowed の注釈は「借用は保存できない」の管轄である。

2 つ目は狙って書かなくても起きる。基底型そのもので受ける形だけでなく、構造的に狭い record 注釈でも幅部分型で落ちる。基底が record のユーザー定義多重度型には実行時の封印が無い(§17.8「規律が届かない位置」)ため、検査せずに許すと実行時にも捕まらない。

type Lease := ExactlyOnce({ ping: {| Int }, done: Consuming({| Unit }) |})

peek := { x: { ping: {| Int } |} | x.ping(), x.ping() }

l: Lease := new_lease()
n := peek l  # エラー: pass-of-multiplicity-value

実引数は裸の識別子に限らない。 その場で作った値(h.set("a", new_lease()))・包んだ値(h.set("a", Some(l)))・コンテナーリテラル(peek [l])・パス(h.set("a", r.held))も同じに報告する。名前を経ない値は呼び手の側に 2 本目の経路を残さないが、渡した先で規律が消えることは変わらない — コレクションに入れた値は h.get で何度でも取り出せ、多重度の無いパラメーターで受けた値は何度でも使える。

逃げ道はパラメーターの宣言型である。 多重度型で受ければ規律はそのまま続き({ x: Lease | … })、基底に型変数を置く形({ x: AtMostOnce(a) | … }。§17.8「基底に型変数を置く」)でも続く。触るだけなら借用で受ける({ x: Borrowed(Lease) | … })。Hikari 側のコンテナーへ入れる形は本規則の対象ではなく、入れることが消費として記録される。

dup := { x: a | x, x }
h := m.insertion.scratch()

h.set("a", lease)  # エラー: pass-of-multiplicity-value(組込型メソッド)
h.set("a", Some(new_lease()))  # エラー: pass-of-multiplicity-value(包んだ値も同じ)
p, q := dup lease  # エラー: pass-of-multiplicity-value(型変数)
box := { mutable held := lease |}  # 通る(コンテナーリテラルへ入れる形は消費として記録される)

次の形は対象外である。

  • 値コンストラクターの実引数。 Ok(x) / Err(x) やユーザー定義 enum の原型は通常スロットの型に型変数を持てるが、包みが多重度を伝播する(上記「包みは多重度を伝播する」)ので規律が消えない。3 つ目が対象にするのは、包みを作らない普通の関数の型変数パラメーターだけである。
  • 緩い向き。 多重度を持たない値を多重度型のパラメーターへ渡す形と、ExactlyOnce の値を AtMostOnce のパラメーターへ渡す形(§17.8「多重度型の部分型関係」)は、受け側の規律が同じか強まるだけである。この規則が禁じるのは規律が消える向きだけである。箱を持つ値を資源を作る位置(基底が Consuming のスロットを持つ record)へ置く形は、下記「資源はアスクリプションだけが作る」が受ける。
  • Any のパラメーター: 多重度の値を規律なしで Any へ渡すことはできない。
    Unknown は型決定のエラーになる。基底の型変数は、多重度を残す型に包んで受け取る。
  • 追跡に載せられない構造: 規律を保つと示せない値を渡すことはできない。解析の上限を超えた場合も、多重度が無い値として扱わない。
  • serve の設定レコード。 状態を引き渡す位置(std/http/server.md §13)で、state へ置いた値の規律は serve が状態の型で特殊化したハンドラーと結果へ続く。

資源はアスクリプションだけが作る

多重度を持たない値が、基底が Consuming のスロットを持つ record の多重度型の位置へ入ると、そこで資源が 1 つ作られる(language-spec.md §17.8「アスクリプションは資源を作る」)。
同じ値から資源を 2 つ作れると、それぞれを 1 度ずつ消費しても実体は 2 度消費されるので、資源を作れる位置を明示のアスクリプションに限る。

  • implicit-resource: 箱を持つ値(record・関数値)を、アスクリプション以外の注釈(束縛・再代入・パラメーター・結果)で資源を作る位置へ置く形。a: Txn := raw と use raw(use のパラメーターが Txn)がこれにあたる。raw: Txn と書いて資源を作る。その場で書いた関数・record のリテラルは毎回新しい値なので、一番外の位置では報告しない。
  • mixed-resource-ascription: すでに資源を含む値の一部から、アスクリプションで資源を作る形((t, raw): (Txn, Txn)。t がすでに Txn)。資源を作る位置と作らない位置が混ざると、評価地点の判定(下記)がすでに資源である値と区別できない。新しい部分だけを先にアスクリプションする。

資源を作るアスクリプションの被演算子が名前なら、その名前は消費済みになる(上記「追跡の対象と消費する操作」)。
名前を経ずに同じ値へ 2 度目のアスクリプションが届く形(同じ値を返す関数を 2 度呼ぶ形ほか)は、静的には見分けられないので、アスクリプションの評価地点で止まる。

基底が境界の無い型変数の値のメンバーは参照できない

静的型が多重度型に解け、その基底が境界の無い型変数である値へのメンバー参照を cannot-call-on-type-variable-base として報告する。 呼び出し形(x.done())も取り出し(r := x.done)も対象である。型変数にスロットが無いので、そのメンバーが Consuming かどうかを引く先が無く、消費とも借用とも決められない。

close_it := { x: ExactlyOnce(a) | x.commit() }  # エラー: cannot-call-on-type-variable-base

型付けを保証する必要がある。 境界を持たない型変数にはメンバーを数え上げる先が無いので、この位置のメンバー参照は型検査を一つも受けていない — 存在しないメンバー(x.nonexistent())でも no-such-member が出ない(§2.7)。検査せずに許すと、ExactlyOnce の義務がその名前から静かに消える。

逃げ道は 2 つある。 基底を具体型で書く({ x: Lease | x.done() })か、基底の型変数へ interface 境界を付ける。境界がメンバーを数え上げられるときは報告しない — 境界が(多重度の層を剥がしたのち)record または既知の不透明型に解けるなら Consuming を引く先ができる(§17.8「基底の型変数へ境界を付ける」)。そのときメンバーの解決は境界を基底とみなして行い、境界の宣言に無い名前は具体 record 基底のときと同じく no-such-member になる(§2.7)。閉じた union や原始型のようにメンバーを列挙できない境界では報告する側のままで、条件は「境界が付いていること」ではなく「境界がメンバーを数え上げられること」である。

Borrowed(a) は対象外である。 Borrowed は多重度型ではなく消費義務を持たないので、メンバーが解けなくても消える義務が無い。

借用から取り出した値は借用である

language-spec.md §17.8「借用から取り出した値は借用である」を、取り出す式の静的型で実現する。
受け手の静的型が Borrowed(T) に解け、取り出した値の型が多重度型を含むなら、取り出した値の型を Borrowed で包む。

  • スロットと要素の読み出し(b.t・b.0)と分解({ t } := b)は、読んだ値の型を包む。
  • match の照合対象が借用なら、record のスロット・タプルとコンテナーの要素・タグの payload を包んでからパターンへ束縛する。
  • 組込メソッド(List・Option・Future・Result・タプル)は、受け手の要素の型を包んでから結果の型とブロックの要素の型を決める。
    b.items.filter { … } の結果は List(Borrowed(Txn)) であり、ブロックの要素も Borrowed(Txn) である。

包んだ後は既存の規則が判定する。消費は「借用したレシーバーでの Consuming 呼び出しを禁じる」が、束縛と所有のパラメーターへの受け渡しは「借用は保存できない」が報告する。
所有で受けるブロックを渡す形は、要素の型との不一致として type-mismatch になる。

借用は保存できない

language-spec.md §17.8「借用は保存できない」の表の各行を cannot-bind-borrowed として報告する。

  • 対象は静的型が Borrowed(T) に解ける式である。裸の識別子に限らず、借用を返すメソッドの呼び出し(a.set(0, 1))もアスクリプションもその位置に現れればかかる。基底 T が多重度型かどうかは問わない。
  • 例外は 1 つ — 連鎖のルートが名前を持たない所有の式のとき(arr.array(2, 0).set(0, 1) の arr.array(2, 0))は報告しない。 借用の式から受け手の連鎖を遡り、借用でなくなった地点の式をルートとする。ルートが識別子なら報告する(その名前が資源を持ったまま 2 本目の経路になる)。ルートまで遡っても借用のままなら所有者は式の外にあるので報告する。ルートがそれ以外(その場で作られ名前に束縛されていない所有の式)のときだけ、その資源へ届く経路が連鎖そのものしか無いので見逃し側へ倒す(§17.8「例外 — 連鎖のルートが名前を持たない所有の式のとき」)。
  • 「関数の結果」の行は、宣言結果型があり、それが Borrowed(…) でないときだけ報告する。 宣言が無い結果型では報告しない — 結果型を宣言せず Borrowed(T) を返す連鎖メソッドの正当な形を巻き込まないためである。
  • 「別フローへの捕獲」の行は名前だけを見る。 捕獲されるのはブロックが参照する外側の名前なので、この位置には式の形が無い。

呼び先が宣言するブロックパラメーターの型は、注釈の無いブロックパラメーターへ流す。 これにより std:array の arr.build や std:map の m.insertion.build のようにブロックパラメーターを借用として宣言するメソッドでは、書き手が { h | … } と注釈無しで書いても借用の規律が働く。詳しくは §2.2「注釈の無いブロックパラメーターへ型を流す」。

借用したレシーバーでの Consuming 呼び出しを禁じる

language-spec.md §17.8「安全性は 1 本の規則で立つ」— 借用したレシーバーでは Consuming メソッドを呼べない — を cannot-consume-borrowed として報告する。借用が漏れて生き延びても閉じられないことが、借用を region なしで安全にしている土台である。

  • 対象は静的型が Borrowed(T) に解ける式をレシーバーに、Consuming で宣言されたスロットをメソッドとして呼ぶ形(h.close() / h.close! の dot 形と h close() / h close の中置形の両方)。裸の識別子に限らず、a.set(0, 1).frozen() のように借用を返すメソッドの結果をそのままレシーバーにした形も含む。
  • 報告しない条件(この消費診断の対象外である)。
    • 受け手の基底が record にも std の不透明ハンドル型にも解けない(多重度が両者以外を包む形。Borrowed(AtMostOnce(Int)) 等)。std の不透明ハンドル(arr.Array / fs.File ほか)は record ではないがメソッドの一覧を持つので、そこから Consuming かどうかを引く(§17.8「可変ホスト資源はすべて多重度を持つ」)。
    • 受け手の連鎖のルートが名前を持たない所有の式である(arr.array(2, 0).set(0, 1).frozen())。借用が漏れて生き延びる先が無いためで、上記「借用は保存できない」の例外と同じ判定である。
    • その名前のスロットが宣言されていない(universal method・打鍵エラー)。
    • スロットの型が Consuming(F) と確定しない(型を持たないメソッドフィールド { ping |} の bare 形)。
    • 受け手が借用でない(所有 AtMostOnce / ExactlyOnce のレシーバーでの Consuming 呼び出しは正当な消費である)。
show := { h: Borrowed(Handle) | h.close() }  # エラー: cannot-consume-borrowed

複製と別フローへの捕獲の禁止

§17.8「複製と別フローへの捕獲」が静的な型エラーと定める次の 2 つを、affine-not-copyable として報告する。2 つは対象の範囲が違う(移譲と複製の違い。本節冒頭の前提)。

  • copy — 多重度型の値と、それをスロット・要素に持つあらゆる構造(上記「包みは多重度を伝播する」で伝播する包みも含む)。
  • 別フローで走るブロックへの捕獲 — 多重度型の値を追跡に載らない構造(上記「包みは多重度を伝播する」の対象外の位置)に入れた形だけ。捕獲を許せるのは捕獲が消費として記録される値だけで、追跡に載らない構造へ入れた時点で追跡が切れ、そこから先の捕獲では親側が値を使い続けられる。

捕獲側は「別フローで走るブロック」という性質で決める — 起動回数は問わない。禁じる向きなので、起動が高々 1 回の spawn / fork / Future のメソッドも、要素ごとに起動する std:parallel の map / filter / fold(std/parallel.md)も等しく対象になる。移譲を許す側の性質はこれより狭く「別フローで走り、かつ起動が高々 1 回」であることに注意する(上記「追跡の対象と消費する操作」)。

実行時の失敗はどちらの禁止も肩代わりしない。 実行時の v.matches(type Copyable) も copy のディスパッチも spawn の非 Copyable 捕獲 panic も基底型の判定でしかないので(§17.8・prelude.md §9.9)、基底型が record である多重度型(type Txn := ExactlyOnce({ … |}) の形)を含む構造はそのまま複製・捕獲されて通ってしまう。ユーザー定義型には std ハンドルのような実行時の封印も無い。本規則だけが塞ぐ。

r := fs.open("a.txt")!  # Result(File)。伝播する包みなので追跡対象
spawn {| consume r }  # 通る(移譲。r はここで消費済みになる)

o := { h := f |}  # record はコンテナー。f はここで消費済みになり、o が追跡対象になる
p := o.copy!  # エラー: affine-not-copyable(複製はどの構造でも不可)
spawn {| o.h.use() }  # 通る(移譲。o はここで消費済みになる)

状態を引き渡す位置へ置く値

std が状態をブロックへ引き渡すために定める位置(std/http/server.md §13 の serve の設定レコードの state)に、多重度型の値を含むが自身は追跡対象でない値(多重度型そのものでも、多重度を伝播する包みでもない値)を置いたら state-not-owned を報告する。

理由は所有が 2 つになることである。そこへ置いた値が多重度型でなければ、置くこと自体が消費として記録されない(上記「包みは多重度を伝播する」)。すると呼び手の手元に同じ構造が残り、そこから抜き出した資源と引き渡した先の資源が同じ実体を指す。引き渡した先は後から走るので、上記「複製と別フローへの捕獲の禁止」が捕獲について述べたのと同じ危険がここに開く。置いた値が多重度型なら、置くことが消費になって呼び手の側の名前が使えなくなる。多重度型を 1 つも含まない値は対象外である。

record・List はコンテナーとして追跡される(上記「包みは多重度を伝播する」)ので、置けば消費として記録される。包みの深さだけを理由に追跡対象から外すことはない。型に消費義務を見つけても、その値へ義務を渡せない位置を報告する。

serve({ port := 8080, state := { held := [lease] |} |}, handler)!  # 通る(record はコンテナー。置くことが消費になる)
serve({ port := 8080, state := 0 |}, handler)!  # 通る(多重度型を含まない)

モジュール境界とトップレベル束縛

export した名前の静的型が多重度型に解けるなら export-of-multiplicity-value を報告する。型と関数(結果型が多重度型のものを含む)の export は許す — 型は値ではない(language-spec.md §17 冒頭)ので該当しない。

複数の importer が同じ値へ届くため、export すると所有の消費義務の持ち主を定められない。
多重度の値を直接公開せず、生成する関数や適切な借用の操作を公開する。

export が無いファイルは全トップレベル束縛を公開する(language-spec.md §13.2)ので、多重度型の値をトップレベルに束縛すればこの診断が立つ。単体で走らせるプログラムがそうしたいときは export {} と名乗る — 公開メンバーが無くなるので本項の対象が無くなり、消費の期限は上記「ExactlyOnce の消費義務」のとおりファイル評価の終わりのまま残る。

ファイル内のトップレベル束縛は追跡する。 ユーザー定義関数の本体は「起動回数が不明なブロック」(上記)なので、その中で外側の値を消費するのは consume-in-unknown-arity-block になる。したがってトップレベル束縛を消費できるのはトップレベルの文列だけで、そこは 1 回だけ順に評価されるため追跡できる。

conn := sqlite.open(url)!.unwrap_or_else { e | panic e.message }  # トップレベル束縛
shutdown := {| conn.close()! }  # エラー: consume-in-unknown-arity-block

Consuming の宣言位置

Consuming(F) を書ける位置の制限(language-spec.md §17.8)に反する宣言を consuming-on-non-multiplicity として報告する。他の診断と違い使用地点のフロー解析ではなく型宣言の検査なので、追跡が 1 つも走らないファイルでも効く。

判定は書かれた位置の構文だけで決まる。 許すのは 2 つで、どちらも多重度型コンストラクター(AtMostOnce / ExactlyOnce)の直接の基底に書いたものである — record のスロットと、そこへ型変数を書いたときその場で添えた境界 record のスロット(§17.8「基底の型変数へ境界を付ける」)である。それ以外の位置に現れた Consuming(F) はすべて報告する。境界を名前で書いた形が 2 つ目に当たらないのは、そう書かれた名前が Consuming を持つことがそもそもありえないからである — その名前を宣言する側が 1 つ目に当たらず報告される。

追跡の適用範囲

消費義務がある値は、所有・借用・取り出し・捕獲・保存の各位置で規律を証明する。
裸の識別子を直接追跡し、コンテナーの中身はコンテナー自身の消費として追跡する。
式を受け手にした使用にも、取り出しと借用の規則を適用する。
追跡できないことを受理の根拠にしない。

Any へ広げた値や明示のアスクリプションでも、多重度の義務を消せない。
型変数は規律を保持する包みか借用として受け取る。
Unknown の使用は値の型決定エラー、Never は値を渡さない位置である。

2.15 効果の推論と検査

関数が起こす効果(language-spec.md §17.9)を推論し、宣言と食い違う位置を報告する。効果は注釈が無くても本体から決まるため、本節は §2.5 の Any 規律や §2.6 の宣言型と違って「注釈を書いた箇所だけ」を対象にしない — 書き手が効果を一切書いていないコードでも、純粋を宣言した位置へ効果を持つ関数を渡せば報告する。

効果の決め方

  • 葉は組込だけである。 効果を生むのは prelude / std の組込呼び出しに限られ、どの組込がどのラベルを持つかは prelude.md と std 各書のメンバー表を単一情報源とする。ユーザーコードは葉を持たない。
  • 関数の効果は本体で起こる効果の和集合である。 分岐・ループ・match のアームはすべて和に寄与し、到達可能性は問わない(実行されうる位置に書かれていれば計上する)。
  • 効果は、その計算を起動した地点に帰属する。 fork(block) / spawn(block) はその地点で block の効果を計上するので、f! が同じ効果を二重に計上することはない。フローについて述べる分は子フローの外へ出ない(language-spec.md §17.9「伝播と部分型」)— 別フローで起動したブロック(fork / spawn・Future の .map / .and_then・std:http/server の serve)の Susp は計上せず、ブロックの中の操作は名前を持たない葉として計上する。! そのものは中断点なので Susp を足す。
  • std:parallel のコールバックの Susp は透過する。 呼び出しは結果のコレクションを返すまで待つため、呼び手も中断しうる。
  • EffectConduit を宣言したパラメーターの効果を加える。 その位置に渡された値の効果が、呼び出し地点の効果に入る。宣言が無いパラメーターの効果は加えない(渡されたブロックは呼ばれないかもしれないため、加えると誤検出になる)。
  • ユーザー定義の関数スロットは、その型が宣言する効果と透過の位置で答える。 組込の透過メソッドと同じ綴り(map・each ほか)でも、受け手の型がその名前のスロットを宣言していれば組込の規則を当てない。
  • 関数値を呼ぶ位置は、その値の静的型から採る。 本体まで字句で届く呼び先(下記「Mut の判定とスコープ吸収」の 3 つの形)だけは本体の効果を採り、それ以外 — 別名・コンテナー・スロット・戻り値・部分適用・分解・パラメーター・import 先のメンバーを経た関数値 — は、静的型が関数型ならその結果型の効果集合を Mut も含めて採る。値の出どころはたどらない。静的型が EffectConduit(F) の値は、8 つのラベルすべてを上限として採る — 透過の効果は渡した実引数が決めるので型は述べず、宣言したリテラルの中でパラメーターそのものを呼ぶ位置だけがマークで答える(下記「透過のパラメーターの使い方」)。
  • 適用スパインは、段ごとに部分適用の続きか戻り値の呼び出しかを関数型で決める。 スパイン・先頭・段の語は language-spec.md §3.5 が定める。どちらかは綴りではなく型で決まる — スパインの先頭(mk(1)(n) なら mk)の関数型のパラメーターの数に、手前までの段に渡した実引数の合計が達していれば完全適用である(引数ゼロの明示的 kick の段を含めば達したとみなす)。先頭が効果透過の組込やメソッドと同じ綴りでも変わらない(if(c, { f }, { g })(n) の (n) はブロックを渡す段ではない)。戻り値の呼び出しなら、手前の段の静的型が述べる効果を採る。部分適用の続きなら、その段で最後のスロットが埋まるときだけ先頭の本体が走るので、手前の段の値(部分適用)の関数型が述べる効果を採る。埋まらなければ本体は走らないので、何も足さない。名前へ退避した h := mk(1); h(n) と同じ答えにするための規則である(「出どころで答えが変わってはならない」)。段が 1 つだけの呼び出し(two := { a: Int, b: Int | … } の two(n))も同じで、最後のスロットが埋まらなければ本体の効果を足さない — 足すのは、その部分適用を後で呼んで最後のスロットを埋めた位置である。
  • 再帰は最小不動点で解く。 §2.2 が結果型の再帰を扱うのと同じ枠に乗せ、初期値を空集合として増加方向へ収束させる。効果集合は有限(8 種)なので必ず停止する。

import 先モジュールの効果は §2.2「import 先モジュールの型」で決まる。
import 先のメンバーは、import 先の推論型が運ぶ効果をそのまま持つ。
相対 import と pkg: は同じ検査を行い、std: は公開シグネチャから採る。
循環・解決不能な import は静的エラーになり、Any のモジュールとして受理しない。

宣言との照合

契約系の規則である(§2.1)。破れが現れるのは宣言した位置ではなく、その関数を純粋だと信じた呼び出し側だからである。

  • 定義側: 結果型を宣言した関数の宣言効果集合が本体の効果を包含しないとき undeclared-effect を報告する。判定は 3 形(束縛注釈・内部名注釈・body 末尾アスクリプション、language-spec.md §17.3)すべてにかかる。
  • 使用側: 引数位置・束縛位置で、渡す値の効果が宣言型の許す効果集合に収まらないとき effect-mismatch を報告する。効果集合の部分型は上向きにだけ緩む(language-spec.md §17.9)ので、判定は「収まるか」という方向のあるものであり、§2.4 の注釈照合・§2.10 の型安定性と同じ向きを使う。
  • 結果型の宣言は束縛位置である: 結果型を宣言した関数では、末尾式と return の値を宣言した結果型へ束縛する位置として使用側と同じく照合する。判定は定義側と同じく 3 形すべてにかかる。本体の効果を見る定義側とは別の照合で、本体が純粋でも返す値の効果が宣言を破れば報告する。呼び出し側は宣言型から戻り値の効果を採る(上記「効果の決め方」の宣言された型から採る位置・import 先のメンバーの戻り値)ので、ここで照合しないと偽りの宣言が境界の向こうへ届く。
apply_twice: { { Int | Int }, Int | Int } := { f, x | f (f x) }

apply_twice({ n | n + 1 }, 3)  # 通る
apply_twice({ n | println n; n + 1 }, 3)  # effect-mismatch

inc: {| { Int | Int } } := { { n | n + 1 } }  # 通る
noisy: {| { Int | Int } } := { { n | println n; n } }  # effect-mismatch(本体は純粋でも、返す値が宣言を破る)

渡す値の効果は、呼ぶ位置と同じく 2 つの出どころの片方から採る。 値が字句のまま届く関数リテラル(下記「Mut の判定とスコープ吸収」)ならその本体の効果を、それ以外は値の静的型が運ぶ効果を採る。出どころで答えが変わってはならない — 字句のまま届く値の本体の効果は、そのリテラルの推論型が運ぶ効果と同じである。違うのは Mut の帰属だけで、本体から採れば書き込み先が渡した側のフレームの内側かを見られる。

推論した関数型は効果を運ぶ(language-spec.md §17.9「推論した関数型は効果を運ぶ」)。結果型を宣言しない関数の静的型は本体の効果を結果型に載せるので、静的型は書き手の注釈に限らない — 別名・戻り値・分解束縛・合流を経た値や、コンテナーの要素・payload として持ち運んだ値の静的型も、元の関数の効果を持つ。Mut も載る。載るのは書き込み先が本体の外にある分で、借用パラメーターを通した書き込みは載らない。import 先の推論型も同じ走査で効果を運ぶ。

  • 効果を解いてから型を付け直す。 効果は本体から決まり、本体の効果は、値として届いた関数を呼ぶ位置では、呼んだ値の静的型に依る。そこで走査を繰り返し、前の走査が解いた効果を関数リテラルの推論型へ載せて次の走査を行う。効果は増える向きにしか動かず集合は有限なので、必ず止まる。
  • 合流は効果の和を採る。 パラメーター・結果型が不変に一致する関数型同士では効果の和を採る。
    型が割れた合流は、期待型を要求し、各枝をその型へ検査する。
  • 注釈の位置ではコンテナーの中身の型まで照合する。 宣言型が List(F)・Option(F)・Result(F, E)・Future(F)・タプルのように関数型を内に持つとき、渡す値の静的型を同じ形でたどり、関数型の位置ごとに照合する。束縛・引数・メソッドのブロックパラメーター(パラメーターに書いた型と、呼び先のシグネチャが受け手の型から決めてそこへ渡す型)で同じである。
  • 可変な位置へ書く関数値は、確立した型へ照合する。 可変な名前・可変スロットへの書き込みは、受け手の静的な型へ検査する。型や効果を保証できない値を受理しない。

透過を宣言したパラメーター(EffectConduit)へ渡す値は使用側の照合の対象外である — 透過は「渡された値の効果が呼び出し地点に通る」という宣言で、上限を述べない。

宣言時の形の検査

いずれも書かれた位置の構文だけで決まり、型の解決を要さない。

状況 診断
Effect(T, …) を関数型の結果型位置以外に書いた effect-not-in-result-position
EffectConduit(F) の基底が関数型でない effect-conduit-on-non-function
効果の位置に効果ラベル以外の名前を書いた not-an-effect

基底が解決できない名前は型式の診断になる。型変数を基底に置く形では、その境界が必要な形を保証することを要求する。

透過のパラメーターの使い方

EffectConduit(F) の透過は、宣言した関数の中でそのパラメーターを呼ぶ位置に効く(language-spec.md §17.9「効果多相」)。判定は Mut の所有者と同じ形で、透過のパラメーターを呼ぶ効果に「そのパラメーターを宣言したリテラル」のマークを付け、そのリテラルの出口で消す。マークを持ったまま型になる値は、8 つのラベルを上限の効果として述べる。

  • パラメーターそのものを呼ぶ・透過の位置へ渡す位置はマークで答える。 名前がそのパラメーターの宣言へ解決する識別子だけが対象で、別名・取り出し・部分適用を経た値は型で答える。デフォルト値を持つか mutable なパラメーターも、値が実引数とは限らないので型で答える。型が EffectConduit(F) の値を呼ぶ位置は上限の効果を持つ
  • 入れ子のリテラルの型はマークを上限に置き換える。 字句のまま呼ぶ位置は型ではなく本体の効果を採るので、マークは外側へ運ばれて宣言したリテラルの出口で消える。その場で引数を埋め切って起動するリテラルと、透過の位置へ直に渡したリテラルは型も上限にしない。判定はリテラルの直前の 1 段の構文と内部名の使い方だけで決まり、値の流れは追わない
  • 部分適用の結果の型は上限の効果を持つ。 呼び先が透過の値のとき、または透過のパラメーターをその段で埋めたとき、残りの関数型の結果に 8 つのラベルを載せる
  • 子フローへ渡した分は上限である。 fork・spawn・serve のハンドラーの中のマークは、起動した地点で上限の効果に置き換える
  • 覆いは値の型として運ぶ。 型変数で受けて返した透過の値(id(f)・fold の初期値)、純粋な関数との合流(分岐・match・リスト)、メソッドが返した値は EffectConduit(F) のまま運ばれる。剥がすのは評価の効果の層(Effect(T, …))だけである
状況 診断
EffectConduit(F) を関数のパラメーターの型以外(束縛の注釈・アスクリプション・record 型の欄・データオブジェクトのスロットの型、型の中の関数型の結果・コンテナーの要素ほか)に書いた effect-conduit-outside-parameter

持ち出しは診断の対象ではない。持ち出した値を呼ぶ位置の宣言が上限を許さなければ undeclared-effect か effect-mismatch になり、純粋な上限を書いたパラメーターへ透過のパラメーターを渡せば渡した位置で effect-mismatch になる。保存して後で呼ぶコールバックは、基底の関数型に効果の上限を書いて受ける。

Mut の判定とスコープ吸収

Mut は「自分の呼び出しフレームの外にある可変状態への書き込み」である(language-spec.md §17.9)。書き込みは字句で書き込み先へ帰属させ、帰属したリテラルの出口で吸収する。判定に要る解析は本書に揃っている。

  • ローカル束縛への代入: 代入先の名前を宣言したリテラルが所有者である(宣言の探索は §2.10「束縛の重複と immutable への代入」と同じくスコープチェーンを遡る)。所有者が自フレームなら Mut を起こさず、外側なら起こす。
  • スロット代入 recv.name = v: §2.10「スロット集合が確定する」の判定を使う。受け手が自フレームのリテラルに帰着するなら Mut を起こさず、そうでなければ起こす。判定できない受け手は起こす側に倒す(純粋と誤って言わないため)。パラメーターで受け取った値のスロットへの書き込みは Mut である。
  • inner_bound 名を通した書き込み: 受け手が inner_bound 名なら、所有者はそれを宣言したリテラルである。inner_bound が指すのはそのリテラルの派生値で、派生のたびに新しく作る値だからである。デフォルト値が作るメソッドの本体からの書き込みは、メソッドのフレームの外への書き込みなので Mut を起こす。別のメソッドを経て同じ状態へ書くメソッドも、呼んだメソッドの型が Mut を運ぶので Mut を起こす。

帰属を使えるのは、書き込みを含む関数リテラルが字句のまま届くときだけである。 届くのは 3 つの形 — その関数リテラル自身の本体、呼び出しの位置にその場で書いた関数リテラル(ブロック引数・EffectConduit のパラメーターへの実引数)、呼んだ側の本体で関数リテラルを := で直接束ねた不変なローカル名 — に限る。3 つ目は名前から宣言の右辺のリテラルへの 1 段だけを見る。それ以外の関数値を呼ぶ位置は、値の静的型が運ぶ Mut を採り、どのフレームでも吸収しない。

借用パラメーターを通した書き込み: 受け手が Borrowed(T) のパラメーターなら、所有者は呼び手である。その関数の型の Mut には入れず、呼んだ位置で借用のパラメーターへ渡した実引数に帰属させる — 実引数が呼んだ側の局所なら呼んだ側で吸収し、呼んだ側の借用パラメーターならさらにその呼び手へ委ね、それ以外は呼んだ側の Mut にする。判定に使うのは呼び先の関数型のパラメーターが Borrowed であることだけで、名前で直に呼んでも値として呼んでも、実際に書き込まない関数でも同じである。部分適用で借用のパラメーターを先に埋めたときは、埋めた位置で帰属させる。引数ゼロの kick がデフォルト値で埋めたときは、外側への書き込みにする。

スコープ吸収: EffectConduit なブロック引数を取る関数がそのブロックへ Borrowed(T) を貸し出すとき、ブロック内の可変操作がすべて「貸し出された借用」か「ブロック内で生まれた束縛」に解決するなら、そのブロックの Mut はその関数の外へ出ない。上の借用の帰属の特別な場合で、判定も同じ解析で決まる。

吸収が成立しない形は診断ではなく、単に Mut が外へ出るだけである。

mutable counter := 0
r := arr.build(3, 0) { a |
  counter = counter + 1  # 貸し出された借用でもブロック内の束縛でもない
  a.set(0, 1)
}
# 吸収されず、この式は Mut を持つ

効果の保証と対象外

受理に必要な関数型を示せない呼び出しは静的エラーになる。
Any は操作できず、値の位置の Unknown と呼び出し後の未確定の型変数も受理しない。
型変数のパラメーターから、呼び出しや効果についての保証を新たに得ることはない。

Mut もほかの 7 ラベルと同じく型で運ぶ。型に載った Mut は書き込み先を述べないので、どのフレームでも吸収しない。
吸収するのは、字句で届く書き込みと借用パラメーターを通した書き込みだけである(上記「Mut の判定とスコープ吸収」)。
効果の透過を宣言しないパラメーターは、渡した計算の効果を運ばない。

この範囲で、関数値の効果は使用先の宣言の許す集合へ収まることを静的に検査する。
関数値は検査器が決めたシグネチャを持つ。
Any から関数型へ戻すアスクリプションで、シグネチャに載った効果を純粋へ偽ることはできない。

universal method と names・values・has_name のスロットの効果は、受け手の型がそのスロットを見せる位置でだけ採る。
受け手の record 型がスロットを見せない位置({ a: Int |} として受けた値の r.inspect!・r.copy!)は組込の形で読むので、実行時に呼ばれるスロットの本体の効果は呼ぶ側の効果に載らない。
演算子のスロットは効果を持たない(§2.9「演算子のスロットは効果を持たない」)ので、==・compare を含む演算子にこの欠けは無い。
スロットの契約(§2.9「universal method と同じ名前のスロットの契約」)は型だけを見る。

実行時は肩代わりしない

実行した計算の効果を、評価の後で照合することはない。
関数値の matches とアスクリプションは、値が持つ検査済みのシグネチャを照合する。
通常の関数呼び出しへ、効果を強制する包み直しは加えない。

例外は == / compare スロットの本体の中断である(§2.9)。これは効果の照合ではない — 比較は中断できない位置で走るので、実行系は中断に出会った時点で続きを持てず、その地点で panic する(language-spec.md §9.1)。

2.16 自動推論の対象外

以下の項目は、型や証明が足りない値の使用を受理する例外ではない。

  • 任意の関数をまたぐ完全な型推論。ローカルな推論で決まらなければ、期待型・注釈を要求する。
  • 一般のループの停止性判定。発散と示せないループを Never と主張しない。
  • §2.3 の未対応の条件や path の事実。
    事実を得られなければ元の型を保ち、必要な証明を別の注釈や明示のアスクリプションで補う。

バグ層の失敗と外部資源の失敗は、完全静的な型付けでも起こりうる。

3. 多相な組込シグネチャと単一化による結果型推論

組込関数(if など)と一部の原始型メソッド(map / filter / first / last / fold / unwrap など)、および std のコレクション(Array(e) / SortedMap(k, v) / InsertionMap(k, v) / ScratchMap(k, v) / OrderedSet(e)。std/array.md §3・std/map.md §4.2・std/set.md §3.1 のシグネチャ表)のメソッドは、結果型が引数やレシーバーの要素型に依存する多相な型を持つ。静的型検査はこれらの結果型を「型変数」と「単一化」で推論する。

3.1 単一化の基本方針

呼び出しでは、シグネチャの型変数を実引数と期待型から解く。
無境界の型変数へ Any を渡したときは Any に束縛する。
境界付きの型変数へ Any を渡しても、その境界への適合を証明できないので受理しない。
dbl(a: Int) のように明示のアスクリプションが必要である。

同じ型変数に複数の制約が来る場合、部分型と変性に従って一致させる。
型が割れたまま暗黙の Any に束縛しない。型の食い違いは type-mismatch、
呼び出し後も値の位置に残る型変数は unresolved-type-argument として報告する。
期待型か型引数の注釈を書くよう案内する。

組込の immutable なコンテナーは共変、ユーザー定義 enum と可変な位置は不変とする。
型変数のインスタンス化と、本体での剛な型変数の検査は区別する。

不変な位置(record の欄・可変なコンテナーの型引数。§2.10)に現れた型変数は、
実引数のその位置の型そのものに確定する。ほかの出現との上界へは広げない。
ほかの出現の実引数はその型へ代入できなければならず、食い違いは type-mismatch として報告する。

set := { r: { v: a |}, x: a | r.v = x }
o := { mutable v := 1 |}!
y: OneOf(Int, String) := "s"
set(o, y)  # type mismatch: argument 2 expects Int (type variable a), got OneOf(Int, String)

実引数そのものが record リテラルなら、その欄は不変な位置に数えない。
リテラルの record はその場で作られ、狭い型を主張する別名を持たないためである。

剛な型変数

書き手がシグネチャに書いた型変数 — パラメーターの注釈・束縛注釈・内部名注釈に現れるもの — は、その関数の本体の中では剛である。剛な型変数 a は何にも当てはまらず、a 自身とだけ等しい型として検査する。

a は呼び出しごとに型へ確定するので、本体では特定の確定先を仮定しない。
その同一性と境界だけを使って型付けする。通常の注釈を実行時照合へ任せることはない。

cast := { v: a | x: Int := v; x }  # type mismatch: x expects Int, got a
inc := { v: a | v + 1 }  # operator '+' not defined for a and Int
報告する位置

a の値を次の位置へ置く形を、各規則の診断として報告する。

位置 例 診断
注釈位置(束縛・分解・スロットのデフォルト値) x: Int := v type-mismatch(§2.4)
具体型のパラメーターへの実引数 g(v)(g := { x: Int | … }) type-mismatch(§2.4)
宣言結果型(末尾の値・return) f: { a | Int } := { v | v } type-mismatch(§2.6)
原始型メソッドの引数 "ab".repeat(v) method-arg-type-mismatch(§2.7)
演算子の被演算子 v + 1 / 1 + v / v < w operator-type-mismatch(§2.8)
短絡の左辺 v && c non-bool-operand(§2.8)
メンバー参照の受け手 v.length! no-such-member(§2.7)
適用の呼び先 v(1) not-callable(§2.8)
動的アクセスのキー xs.[v] type-mismatch
可変な位置への書き込み tmp = v(mutable tmp := 0) mutable-type-instability ほか(§2.10)

向きは問わない。 具体型と剛な型変数、または異なる剛な型変数を同一として扱うことはできない。
コンテナー・payload・record・関数・union の内側も、変性と部分型に従って検査する。
明示のアスクリプションは、その式の評価地点で所属を照合する。

当てはまる位置

次の位置には a の値を置いてよく、報告しない。

  • Any の位置と、同じ a の位置。
  • 型変数を取る多相な関数・メソッド・値コンストラクターの引数(Some(v)・[v]・xs.contains(v)・id(v))。呼び先の型変数はその呼び出しで a へ確定するだけである。
  • 全値に定義される操作: == / !=、universal method(language-spec.md §2.5。v.inspect!・v -> w・v.matches(type T))、全値が満たす空の構造型({|})の位置、表示と補間(print(v)・"${v}")。compare を求める位置は除く — compare は universal method だが、全順序を持たない値(List・タプル)では止まる。Comparable の位置・max(v, w)・v.compare(w)・要素が a の xs.sort! には境界 a: Comparable が要る(§3.2)。
  • matches で絞り込んだ枝(§2.3。短絡の右辺も左辺の事実で絞る)。if (v.matches(type Int)) { v + 1 } の枝の中の v は Int であり、a でもある — a の位置へそのまま返せる。絞り込むのは §2.3 が事実を作れる条件だけである。その場に書いた record 型(v.matches(type { x: Int |}))も、名前を付けた型(type P := { x: Int |} の v.matches(type P))と同じ事実を作る。本体を持つリテラル(v.matches(type { x: Int | x }))は関数なので record の事実を作らず、枝の中の v は剛なまま残る。

Copyable の位置には保証が必要である。 無境界の a はこの型を保証しない。
a: Copyable の境界か、明示の判定による絞り込みを要求する。

境界付き型変数

境界付き型変数(§3.2)も剛である。境界が数え上げるメソッド・演算子は使ってよく({ x: a: Number, y: a | x + y })、境界がそのまま収まる位置へは置ける({ v: a: Number | x: Number := v })。境界が収まらない位置へは置けない — { v: a: Number | x: Int := v } は a が Float に確定しうるので報告する。

剛に見ない型変数

呼び先のシグネチャから生じた推論変数は、実引数と期待型で解く。
呼び出しを終えても値の位置に残れば unresolved-type-argument になる。
関数本体の剛な型変数を wildcard として扱わない。

呼び先の型変数の帰属

型変数は宣言の位置で同定する。同じ綴りでも、剛な a の本体から、同じ綴りの a をシグネチャに持つ関数を呼ぶ形がある。呼び先の a がこの関数と共有のものか、呼び先自身が量化したものかは、呼び先の束縛で決める。

  • 共有する: この関数(かその内側の関数リテラル)のパラメーターを名前で呼ぶ形(g: { a | b } の g(1))。入れ子の関数型は自分の型変数を量化しない(higher-rank を持たない。language-spec.md §17.2)ので、g の a は囲む関数の a そのものであり、g(1) は a の位置へ Int を置く形である。
  • 呼び先自身が量化する: それ以外の呼び先。関数リテラルに帰着する名前(トップレベルの関数・本体で束縛した補助関数 h := { x: a | … }・自分自身や内部名による再帰)と、prelude・std・import の名前がこれにあたる。h(5) は h の a を Int に確定するだけで、本体の a とは別である。
  • パラメーターの別名・メンバー経由・適用の結果も、元の型変数の帰属を保つ。
    同じ綴りであることを理由に、別宣言の変数を同一視しない。
    共有する型変数を、呼び出しの推論変数として解き直さない。

3.2 境界付き型変数の診断(単一化の例外)

境界付き型変数は、確定した型がその境界へ収まることを証明する。
同じ型変数に来る制約を一貫して解けない場合と、境界を満たすと示せない場合は type-mismatch になる。

型集合の境界は、宣言された選択肢の包含で判定する。
interface は、必要なメンバーの存在とシグネチャの一致で判定する。
record と関数の型にメンバーが無ければ、値が余分な欄を持つ可能性を受理の根拠にしない。
std の不透明型はメソッド表で interface に一致する。
名前だけのエントリは存在、シグネチャ付きエントリは不変な一致を要求する。

剛な型変数の値は自分の境界の保証で判定する。
無境界の変数を Comparable などの具体的な境界へ暗黙に渡せない。
Any も境界への適合を示せないので、具体型へ明示的に絞ってから渡す。

組込メソッドの受け手・実引数・ブロック結果にも同じ制約を適用する。
sort / max / min は Comparable、join / unlines は String、flatten は List を要素に要求する。
sort_by / max_by / min_by のブロック結果も Comparable とする。
sum は要素型が Int か Float に確定する必要がある。空の構築や Number の境界だけでは
どちらの型の 0 を返すか定まらない。総称関数での総和には fold の初期値を使う。
未確定の型引数と Unknown は、それぞれの型決定の診断になる。

3.3 Never(ボトム型)の扱い

Never は値を持たず、すべての型の部分型である。
合流では join(T, Never) = join(Never, T) = T となる。
発散する経路は別の経路の型を変えない。

不変な空の構築 []・None は List(Never)・Option(Never) として扱える。
可変な位置では型の内側に Never が残る初期化を許さず、期待型で要素型を定める。
Never を可変な位置の wildcard にしない。

発散として扱う return・break・continue は prelude の束縛を指す場合だけである。
同名を覆った呼び出しは、その束縛の結果型を採る。

3.4 分岐合成 join

合流は、すべての経路の値を静的に受け取れる型を求める。
型が割れて期待型が無い場合はエラーにする。Int と String を暗黙の Any へ合流させない。

期待型 T がある場合は、各枝・各要素を T に照らして検査する。
値を捨てる位置は結果の合流を要求しないが、使用する部分式は検査する。

  • 同一の型はその型へ合流する。型変数は宣言の同一性も含めて一致させる。
  • Never は合流の恒等元である。
  • 同種の共変な組込コンテナーは、要素型を同じ規則で合流できる。
    Some(1) と None は Option(Int)、[1] と [] は List(Int) になる。
    Ok(()) と Err("x") は成功型とエラー型を合わせて Result(Unit, String) になる。
  • 同一 enum の異なるタグは、その親 enum 型へ合流できる。
    ユーザー定義 enum の型引数は不変なので、Box(Int) と Box(String) を Box(Any) にしない。
  • record は幅部分型に従い、型が不変に一致する共通スロットの型へ合流できる。
    共通フィールドの型が割れる場合と、有効な共通の型を決められない場合には期待型を要求する。
  • 宣言された union とその部分型は、広い側へ合流できる。
    宣言されていない union を、割れた型を隠すために合成しない。
  • NonZero(T) 同士は NonZero(T) を保ち、NonZero(T) と基底型 T は T へ広げられる。
  • 関数型はパラメーターと結果が不変に一致する場合に、効果の和を採る。
  • 明示した Any の型を狭めない。Any とその部分型の合流は top 型の Any となる。
    ネスト位置でも、共変な位置で同じ規則を使う。不変な位置の一致を Any で代用しない。
  • Unknown を合流の型にしない。値の位置の型決定失敗として診断する。

可変ローカルは初期化で確立した型を保つ。枝の再代入を合流して型を広げることはしない。

3.5 if / match の結果型

if の then/else と match の各アームの結果は、期待型があればその型へ検査し、
無ければ §3.4 に従って合流する。
型が割れる場合は divergent-result、型不明と未確定の型変数はそれぞれの診断になる。

アームのパターンが束縛する名前は、照合対象の型から解いた型で本体へ置く。
値コンストラクターの payload 型は、その結果型と照合対象の型を単一化して決める。
修飾形も同じであり、所属しないタグは解決しない。
解けない payload 型を Any で補わない。

網羅を静的に証明できず catch-all が無い match は、フォールスルーする Unit も結果へ含める。
照合対象を持たない形も同じである。String と Unit のように結果が割れるなら、
値の位置では期待型が必要である。ガードの無い true と false の両アームは Bool を網羅する。
closed variant の網羅性の診断は §2.9 に従う。

record の関数スロット・import した関数も、同じ単一化で実引数と結果型を解く。

4. 末尾位置マーキング(TCO)

末尾呼び出し最適化(language-spec.md §18.5)のため、各関数リテラル本体を走査し、末尾位置の self 完全適用呼び出しを静的にマークする。マークは型検査とは独立で、実行時のトランポリン(language-spec.md §18.5)が参照する。

このマーキングはパース直後の純粋パスとして走らせる。prelude(prelude.hika)と import 先モジュールは静的型検査(§2 / §3)とは別の経路でパースされて実行へ渡るため、全経路が通るパーサー直後に置くことで prelude の self-host ドライバー(stop_at 等)も一様にマークされる。パース後・評価前の単一スレッド実行なので fork との競合は無い。

  • 末尾位置の判定は language-spec.md §18.5 の再帰的定義に従う。関数本体の最後の文の式を末尾位置とし、末尾位置の if / when / match の各分岐 body 末尾式・conduit / loop 本体末尾式へ伝播する(条件・照合対象・ガード・非末尾の文は末尾でない)。この位置集合は §2 / §3 が return 脱出経路の収集で走査する制御構文と同一で、末尾位置マーキングはその精緻化(結果へ流れる ∧ 以降評価が残らない ∧ self 完全適用)である。
  • self の同定: 呼び出しの callee が inner-name(inner 宣言。§4.2)を指し、完全適用(部分適用でない)である CallExpression をマークする。
  • 健全性は保守側: 判定は unshadowed な標準制御構文(if / when / match と conduit / loop)を前提とし、判定できない構文(rebind・ユーザー定義の非透過高階関数)を通した位置はマークしない。過剰マークは避ける(マークは実行時に TailCall 制御値を末尾位置でのみ発行させるため、非末尾位置を誤ってマークすると制御値が値位置へ漏れる)。未マークは呼び出しごとに深さを 1 段使う形へフォールバックするだけで、呼び出しの深さの上限(language-spec.md §16.6)の内側なら結果は正しい(定数スタック保証を失うのみ)。この前提集合は §18.1 / §18.2 の透過が同じく標準制御構文を前提とするのと同一。
  • lint への再利用: 同じ末尾位置マーキングを hikari lint の non-tail-recur ルール(lint.md「ルール」)が再利用する。loop 関数の反復ドライバー(lexically 内側の inner-name 自己再帰)の self 完全適用のうち末尾マークが付かないものを「TCO が効かず深い反復で呼び出しの深さを消費する」書き方の問題として警告する。トリガーを loop に限るのは、非末尾の自己再帰が一般には正常(fact / fib 等)で一律警告が誤検出になるためである。

5. 診断コードと重大度

静的解析の各診断は安定した識別子(診断コード)を持つ。コードは内容で名付けた小文字ケバブケースの短い語で、本書の節番号や規則番号とは独立している。節の再編でコードが変わらないようにするため、また利用者がコードを検索語として使えるようにするためである。

hikari check はテキスト出力の各行末にコードを括弧書きで添える。LSP は診断の code フィールドに載せる。

重大度

重大度は次の 1 本の規則で決まる。

Error はその検査でプログラムの評価・ビルドを止める診断(hikari check の終了コード 1 に寄与する)。止めないものは Warning 以下。

構文層(§1)・静的型検査(§2)の診断はいずれも hikari check を失敗させ、hikari <file> の評価開始を止める。したがってすべて Error とする。契約系の規則(§2.1)も評価を止める点は変わらないため Error とする。ここを警告に落とすと「警告なのに実行できない」という乖離が生まれる。

hikari lint は評価・ビルドを行わず書き方を指摘するだけなので、この規則の対象外(診断があっても評価・ビルドを止めない)であり Warning 以下を割り当てる。lint 自身の終了コード(検出があれば 1。lint.md が定める)は、この規則が言う「hikari check の終了コード 1」とは別の契約である。lint 内部の割り当ては lint.md が定める。

構文層のコード(§1)

code 意味
syntax-error パースエラー(動的 import・import / type / enum の配置違反を含む)
duplicate-export-name export の列挙内に同名の重複がある
export-unknown-member export が挙げた名前がその定義領域の member として未定義
unknown-std-module std:<name> が標準ライブラリに無い
unresolved-import import パスを解決できない、または到達ファイルに効くマニフェストが不正(pkg: のマニフェスト不在・deps に無い・キャッシュ未取得を含む)
import-file-not-found 解決したパスにファイルが無い
import-cycle import が自分自身へ戻る循環を作った(解決した先が、今追っている import チェーンの上にある)
uncalled-control prelude 束縛のままの break / continue / return を呼び出しの先頭以外に書いた
curried-control prelude 束縛のままの break / continue / return の呼び出しを、さらに実引数へ適用した

静的型検査のコード(§2)

code 意味 出どころ
any-operation Any の値へ型テスト以外のメンバー参照・演算子・呼び出しを書いた §2.2 / §2.7
unknown-value-type 値の位置の型を決められない §2.2
unresolved-type-argument 呼び出し後に値の位置へ未確定の型変数が残る §3.1
mutable-never-initializer 再代入できるローカル・スロットの初期型に Never が残る §2.10
unnameable-exported-type 公開値の型に現れる名目型を import した側が名前で書けない §2.7
type-mismatch 値を宣言型へ静的に代入できない、呼び出しで型変数が割れる、剛な型変数の同一性を破った、または universal method と同じ名前のスロットが組込の契約を満たさない §2.4 / §3.1 / §3.2 / §2.9
undefined-ref 値位置の未定義参照 §2.13
unbound-capture spawn 時点で確実に束縛前となる名前の捕獲 §2.13
private-member-access 定義ファイルの一致と内部表現の特定を証明せず、非公開名を読み書き・名前分解した §2.7
invalid-enum-definition タグ原型と定義領域・タグ集合の条件を満たさない §2.7
invalid-public-decomposition 公開分解列が宣言順の通常スロットの非空の部分列でない、または未宣言の列を使った §2.7
reserved-slot-name 固定された matches と同名の通常スロットを宣言した §2.7
private-builtin-override 上書きする組込操作のスロットを名前で公開しない §2.9
restricted-structural-operation 名目的な所属または非公開通常スロットを持つ実体に非空の overlay を渡す組込 copy §2.7
no-such-member メソッド集合の閉じた型(本体で剛な型変数を含む)に無いスロット・メソッドを参照した §2.7 / §3.1
unbound-slot-read 値を持つと静的に示せないスロットを読んだ(+ の被演算子・スロット分解の右辺を含む) §2.7
sequence-method-on-block ブロックリテラルへ Sequence のメソッドを書いた §2.7
copy-unknown-slot copy overlay のキーが受け手のスロットに無い、またはキーの集合を確定できない §2.7
immutable-slot-assign immutable スロット・Sequence の要素へ代入した §2.10
unbound-slot-assign コンストラクター(未束縛スロットを持つ値)のスロットへ代入した §2.10
already-declared 同一スコープで同名を二度束縛した §2.10
immutable-assign immutable 束縛へ代入した §2.10
inner-name-in-default デフォルト値の中の inner-name から、その位置で読めないものを読んだ §2.7
inner-bound-in-default デフォルト値・分解元に inner_bound 名が現れた §2.7
per-derivation-default-sibling-read デフォルト値の式から派生ごとのデフォルト値を持つスロットを裸の兄弟名で読んだ §2.7
per-derivation-default-effect 派生ごとのデフォルト値が効果を持つ §2.7
per-derivation-default-multiplicity 派生ごとのデフォルト値が多重度型の値を名指した §2.7
closed-object-slot-add closed object へ := でスロットを足した §2.10
arity-mismatch 完全適用の実引数が多い/値コンストラクターパターンの分解個数が宣言と合わない/タプル分解の名前の個数がタプルの要素数と合わない §2.8 / §2.15 / §2.7
non-positional-destructure タプル分解の右辺に位置分解できる要素の並びがない §2.7
non-name-slot-destructure スロット分解の右辺がスロットを持たない型に確定した §2.7
operator-type-mismatch 二項算術・順序比較の被演算子型が不一致 §2.8 / §3.1
not-callable 呼び出せると静的に示せない値を適用した §2.8 / §3.1
method-arg-type-mismatch 原始型メソッドの引数型が不一致 §2.7 / §3.1
future-block-escape Future ブロックの中から外側の関数を脱出した §2.12
non-bool-operand 短絡の両辺・真偽値文脈の値を Bool として受け取れない §2.8 / §3.1
not-a-type 型注釈位置に未定義型名・型になり得ない式が来た §2.4
type-in-value-position 値の位置に型の名前(型適用・モジュールの型メンバー・呼び出しで埋めた型スロットを含む)を置いた §2.4
type-argument-to-value-slot type T と明示した型引数を、静的に分かる値スロットへ渡した §2.4
type-arity-mismatch 型コンストラクターへ渡した型引数の個数が宣言と食い違う §2.4
nonzero-type-argument NonZero(T) の型引数が Int でも Float でもない §2.4
invalid-type-bound 境界付き型変数の左辺または境界の形が不正 §2.4
borrowed-nested-multiplicity 多重度型コンストラクターが別の多重度型を包んでいる §2.4
implicit-any-result 名前付き関数の結果型が暗黙に Any へ倒れた §2.5
any-result-ascription body 末尾アスクリプションで結果型を Any と書いた §2.5
untyped-parameter 名前付き関数のパラメーターが無型 §2.5
implicit-any-binding 値束縛の型が暗黙に Any へ倒れた §2.5
divergent-result 期待型が無い分岐・関数結果・コンテナー要素の型が割れる §2.6 / §2.9
non-exhaustive-match closed variant の match が網羅していない §2.9
unreachable-match-arm 到達しえないアームがある §2.9
redundant-catch-all catch-all・default アームが冗長 §2.9
inner-name-mismatch inner-name 型が slot・結果型・実体シグネチャと食い違う §2.6
mutable-type-instability 可変ローカルへ確立時の型に収まらない値を再代入した §2.10
mutable-slot-type-instability 可変スロットへ宣言型に収まらない値を再代入した §2.10
mutable-position-variance 可変スロット位置・可変なコンテナーの型引数に厳密でない型を置いた §2.10
implicit-any-write Any を含む値を、下方変換が必要な具体型の可変な位置へ書き込んだ §2.10
future-payload-mismatch Future payload の型が宣言と食い違う §2.12
divisor-not-proven / % の除数が非ゼロの定数でも NonZero(T) の式でもない §2.11
index-out-of-range リストリテラルを束ねた名前を、範囲外の整数の定数で引いた §2.11
use-after-consume 消費済みの値への出現 §2.14
divergent-consumption ExactlyOnce の消費状態が分岐で割れている §2.14
consume-in-unknown-arity-block 起動回数が不明なブロックの内側で外側の値を消費した §2.14
pass-of-multiplicity-value 規律が届かないパラメーター・束縛・スロット・結果へ多重度型の値を渡した §2.14
cannot-call-on-type-variable-base 基底が境界の無い型変数の多重度型の値のメンバーを参照した §2.14
never-consumed ExactlyOnce が全脱出経路で消費されていない、消費される前に再代入で捨てられた、またはコンテナーから取り出すときに取りこぼされた §2.14
affine-not-copyable 多重度を持つ値を copy した/追跡に載らない構造に入れた値を別フローへ捕獲した §2.14
cannot-bind-borrowed 借用を保存位置に置いた §2.14
export-of-multiplicity-value 多重度型の値を export した §2.14
cannot-extract-consuming Consuming メソッドを値として取り出した §2.14
cannot-consume-borrowed 借用したレシーバーで Consuming メソッドを呼んだ §2.14
consuming-on-non-multiplicity 多重度型コンストラクターの直接の基底となる record のスロット以外に Consuming を書いた §2.14
escape-of-multiplicity-value 多重度型の値を break / continue の実引数に置いた §2.14
state-not-owned 多重度型を含むが自身は追跡対象でない値を、状態を引き渡す位置へ置いた §2.14
assign-of-multiplicity-slot 多重度型を含むスロットへ代入した §2.14
mixed-resource-ascription すでに資源を含む値の一部から、アスクリプションで資源を作った §2.14
implicit-resource 箱を持つ値を、アスクリプション以外の注釈で資源を作る位置へ置いた §2.14
or-pattern-binding-mismatch OR パターンの枝ごとに束縛する名前が違う §2.9
derived-operator-slot 導出形が定まっている演算子をスロットとして宣言した §2.9
mixed-function-type-entries function 型の slot-list で名前付きと位置を混ぜた §2.4
equal-with-compare-slot 1 つのリテラルが == と compare を同居させた §2.9
undeclared-effect 本体が起こす効果を宣言結果型が許していない(演算子のスロットの本体の効果を含む) §2.15 / §2.9
effect-mismatch 渡す値の効果が宣言型の許す効果集合に収まらない §2.15
effect-not-in-result-position Effect(T, …) を関数型の結果型位置以外に書いた §2.15
effect-conduit-on-non-function EffectConduit(F) の基底が関数型でない §2.15
effect-conduit-outside-parameter EffectConduit(F) を関数のパラメーターの型以外に書いた §2.15
not-an-effect 効果の位置に効果ラベル以外の名前を書いた §2.15
effect-on-operator-slot 型に書いた演算子のスロットの関数型が効果を述べた(型が EffectConduit のときを含む) §2.9

診断コードの一覧は本節が持つ。各節は診断する位置でコード名を示す。

診断の範囲

診断は発生位置の綴り全体を範囲として持つ。識別子・キーワード・型名・リテラルはその字句の終端までを指す。式全体(a + b のような複数字句にまたがる範囲)を指す診断は無い。

診断に載せる型の綴り

診断の文面に載せる型は、型注釈と同じ綴りで書く。別名を通して得た型は別名で書く(type Pair := (Int, Int) の値は Pair)。

別々の同名の型が並ぶときは出自を添える。 enum と不透明型は宣言した位置で識別する(language-spec.md §17.4)ので、名前が同じでも別の型がありうる。1 つの診断に同名の別の型が並ぶときだけ、宣言したモジュールを添えて書く(Board(board.hika) と Board(legacy/board.hika))。

1 つの型の綴りは長さに上限を持つ。 型は同じ部分を何か所でも共有できるが、綴りは共有した部分を現れる位置ごとに書き出す。したがって共有を段に重ねた型の綴りは段数の指数の長さになる(下の例は dup を n 段重ねると構成要素が 2^(n+1) − 1 個になる)。そこで 1 つの型を綴るときに書き出す型の構成要素を 1,000 個までとし、使い切った後の部分を … と書く。書き出しは外側から深さ優先で進むので、残るのは型の外形で、… は内側に現れる。

dup := { x: t | x, x }
a: Int := dup (dup (dup (dup (dup (dup (dup (dup (dup (dup (dup (dup 1)))))))))))

この 12 段の型は構成要素が 8,191 個あるので、診断は a expects Int, got ((((… の形で外形だけを書き、内側を … で打ち切る。普通の型は上限に届かない。hover(lsp.md)など、処理系が型を綴る他の位置も同じ規則に従う。

静的検査の診断は抑制できない。 lint の指示 # hikari:allow は静的検査には適用されない(lint.md)。