本文へ移動
Hikari 仕様

言語仕様

本書は実装の合意基準である。本書から逸脱する場合は本書を改訂する。設計の動機・思想は別文書 philosophy.md を参照。

各構文要素の形と実行例の一覧は、doc コメントから自動生成される reference/syntax.md にもある。本書はそれらの意味論・文法・優先順位・設計根拠を規範として定める(reference が形の索引、本書が意味の定義)。

1. 字句構造

1.1 コメント

# これは行コメント、行末まで
# 多くの例で出てくる #> 5 は「直前の式の値が 5」を意味する慣例表記であり、
# 言語が特別扱いするものではない

複数行コメントは持たない。

字句上の特例は無い: # で始まる行はファイル先頭でも同じく行コメントである。ファイルが mode を宣言する先頭行は持たない (§13.1)。#{...} も # 行コメントとして処理される。

1.2 識別子

通常の識別子は ASCII 英字または _ で始まり、英数字または _ が続く (ASCII のみ)。

オペレーター記号 (+、-、*、/、==、!=、<、<=、>、>= ほか) もスロット名として有効。{ + := {...} |} のように書ける。これがユーザー定義オペレーターの実体で、既存演算子の意味を型ごとに差し替える (§8.2)。

記号スロット名に使えるのは、演算子表 (§8.3) の項目のうちメソッド呼び出しに脱糖するもの (§8.6) だけである。表は閉じており、新しい記号列 (++・<>・<=> 等) を作ることはできない。記号と英字の混在 (+!・add+ 等) も不可。脱糖しない記号 (=・:=・&&・|| ほか。§8.6) はスロット名にならない。

表を閉じておくのは、記号列の追加を許すと優先順位と結合性を決める仕組み (宣言させるか、先頭文字から導くか) が必要で、読み手が知るべき規則がその分増えるためである。閉じている限り「中置になれるのは表にあるものだけ」の単一の規則で済む。

1.2.1 大小文字の慣用 (casing)

字句解析は大文字・小文字を区別する (Foo と foo は別の識別子)。一方、言語は通常の束縛名の casing を強制しない。予約語 (§1.2.2) を除き、型名も値と同じスコープに載る普通の名前である (§17.2)。以下は慣用であり、spec / prelude の表記と整形・検査ツールがこれに従う。

  • 小文字始まり — 通常の値・関数・束縛・メソッド名、prelude の大域 (print / range / if …)。2 語以上は snake_case (to_int / sort_by / read_bytes)。
  • 大文字始まり (UpperCamelCase) — 次の 2 種。複合語は区切り無しで各語頭を大文字にする (OneOf / ユーザー定義の RingBuffer など)。
    • 型の名前: 原始型・型コンストラクター・type 名 (Int / String / Option / Result / Ordering / Comparable / Copyable / ユーザー定義型。§17)。型は値ではなく、型式の位置でだけ引ける (§17.1)。
    • 値コンストラクター: タグ付きデータの各タグに対応する名前。組込の Some / Ok / Err は payload 入力を取る関数値で、None / Less / Equal / Greater は呼び出さず使う完成値である。ユーザー定義 enum の Tag は通常スロットを持つ原型であり、操作のデフォルト値も入力に数え、型引数と全必須入力を確定して完成する(§17.4.2)。型ではないが大文字側に置く。タグは型の下の E.Tag で引き、公開したタグを名前分解で裸にできる。prelude は組込タグの裸の名前も提供する。
  • 例外 (小文字の組込リテラル): 真偽値リテラル true / false は小文字 (原始リテラルであって値コンストラクターではない。§7)。

この慣用にツールが依存する: hikari format は「大文字始まりの callee = 値 / 型コンストラクター」を単一引数でも括弧付きに保ち、小文字始まりの関数適用は並置化する (format.md「整形規則」)。match のアームでも、大文字の値コンストラクター (None / Less / Some(…)) はタグ照合として読め、小文字の束縛 (Some(x) の x) と視覚的に区別できる (prelude.md §8.4)。

型コンテキストでは casing が役割を分ける。ただし分け方は位置で 2 通りある(§17.2)。型式の位置(注釈・type の右辺・型コンストラクターの引数)は 大文字始まり=具体型参照 / 小文字始まり=型変数。構造型の slot-list に置く bare エントリは 大文字始まり=埋め込み / 小文字始まり=メソッドフィールド(型変数にはならない)。どちらも「大文字は型を名指す・小文字は名指さない」点で値位置の慣用と整合する。

1.2.2 予約語

字句解析が識別子として認識せず、束縛名・スロット名に使えない予約語は次の 12 語である。真偽値リテラル true / false(§7)と、宣言・照合の構文形 type / enum / match / import / export / loop / conduit / inner / inner_bound / mutable(構文と対象の形は §1.4)。@ 記号はコア言語のどの位置にも登場しない(§1.4)。

true := 5   # エラー: true は識別子ではなくリテラルなので束縛対象にできない
type := 5   # エラー: type は予約語(構文形)なので束縛対象にできない

制御構造 if / when / while と自己参照名 self / me / super は予約語ではない。
prelude 束縛または書き手が選ぶ普通の名前なので、再束縛やユーザー名としての利用ができる。
matches も普通の識別子である。
通常スロットの宣言名には使えず、本体のローカル束縛と型契約の要求名には使える(§2.5)。

if := 5  # OK: if は普通の名前(prelude 束縛を覆う局所束縛)
self := 5  # OK: 自己参照名は予約語ではない(宣言子 inner だけが予約語。§4.2)

1.3 行の扱い

改行は文脈によって意味が変わる。区切りトークン (改行 / ; / ,) は文脈ごとの規則に従って「区切り」または「空白」として働く。

  • {...} 本体 (body 領域) とファイル全体 (§13.1): 改行はシーケンス区切り (; と同じ)。; も使えるが、改行があれば省略可。区切りが連続・末尾にあっても無視する (末尾 ; 可、空行可)。, はここでは区切りではなく多値 (タプル) 構築を表す (§11.2)。
  • {...} のスロット宣言領域 (先頭〜body 前のパイプまで): 改行・,・; は等価なスロット区切り。, で区切っても、, を省いてスロットを縦に並べてもよい。区切りが連続・前後・末尾にあっても無視する (末尾 , / ; 可、空行可)。
  • (...) の内側: 要素区切りは , または改行 (両者は等価)。区切りが連続・前方・末尾にあっても無視する (末尾改行可)。ただし 末尾 , は不可 — カンマは後続要素を要求する中置区切りで、(x,) は 1 要素タプル (3,) と誤読されうるため許さない (§3.3)。; は () 内では区切りにならない。これにより (\n a\n b\n) のようにタプル要素を縦に並べられ、従来の if(cond,\n {then},\n {else}) も引き続き書ける。ただし、ある行の最後の有意トークンが右オペランドを要求する二項演算子 (+ - * / % ** == != < <= > >= && || ->。§8.3) であるとき、直後の改行は区切りとして働かず吸収され、式は次行へ継続する。二項演算子で終わらない行の改行は要素区切りとして働くため、(a &&\n b) は単一式 a && b、(a\n b) は 2 要素タプルと明確に区別できる。

ファイル全体は slot-list 領域だが (§13.1)、区切りは上の body 側の規則に従う。その領域は文を受けるので (§1.5)、, をスロット区切りにすると同じ字面が場所で意味を変える — f(), g() がファイルでは文 2 つ・関数本体では 2 要素タプルになる。, の意味は「文が書ける場所ではタプル構築」の 1 つに揃え、トップレベルのスロットは改行 (または ;) で区切る。

いずれの文脈でも、1 つの式 (スロットのデフォルト値・本体の各式・括弧内要素) は改行をまたげない — 改行はその式を終える。例外は上記の (...) 内での二項演算子継続のみで、行末が二項演算子のときに限り式は次行へ続く。複数行に分けたいときは式の途中ではなく区切りの位置で分ける。

文の後には区切りが要る。 body 領域とファイル全体では、1 つの文を読み終えた位置に改行・;・その領域の閉じ (} / EOF / ファイルレベルの |) のいずれかが無ければ構文エラーである。区切り無しで次の文が始まることは無い — 1 行が気づかれないまま 2 文に割れると、書いたつもりの式が評価されないまま値を捨てられる。とくに構文形の予約語 (§1.4) は並置の引数になれないので、println match x { … } は println と match x { … } の 2 文ではなく構文エラーとして止まる。match の結果を引数に渡すならグルーピング括弧で囲む (println (match x { … }))。例外は型引数 type T だけで、呼び出しの実引数として並置に置ける (§17.4.1)。

構文解析の深さ: 式を読む構文解析の再帰深さには 10,000 の上限がある。
上限に達した入力は構文エラーとして拒否する。この上限は AST 全体の深さや入力のバイト数ではない。
左結合の連鎖は構文解析の再帰を増やさずに読めるため、同じ段数の入れ子と区別する。

1.4 予約語(構文形)

宣言・照合の構文形は予約語である — prelude 束縛の値(if / while 等)とは別系統で、識別子として束縛名・スロット名には使えない(真偽値リテラル true / false と併せた予約語の全体は §1.2.2)。構文形は次の 12 個:

形 意味 参照
mutable name := expr 可変の宣言(ローカル束縛・スロット宣言の両領域) §6.1 / §2
inner name inner-name(自己参照名)宣言。slot-list 領域限定 §4.2
inner_bound name 束縛を写した自分に届く名前の宣言。slot-list 領域限定 §4.2.1
conduit{...} 制御透過関数(return/break/continue を境界で trap せず素通し) §18.3
loop{...} ユーザー定義ループ(break/continue の捕捉境界。return は素通し) §18.4
import <対象> := "path.hika" モジュール読込(宣言形。import m := "x" / import { a, b } := "x") §13.2
type Name := <型式> 型定義(型エイリアス)。ファイルトップレベルと本体の文に限る §17.4
type name 呼び出しで埋める型スロット。slot-list と関数型のエントリ限定 §17.4.1
type <型式> 呼び出しの型引数。直接の実引数限定(括弧呼び出し・並置のどちらでも) §17.4.1
enum Name := { Tag := { … |}, … | OneOf(Tag, …) } タグ付きデータ定義(直和型)。ファイルトップレベルと本体の文に限る §17.4
match subject { pattern => body } 構造照合による分岐 dispatch(+束縛・述語ガード)。照合対象を省くと述語チェーン prelude.md §8.4
export { name, … } ファイル・値・タグ定義領域の公開名を限定(省略は全名前公開) §13.2

キーワードと対象の間の空白は任意 (type Name:=T / type Name := T は等価。import は from 相当を持たず import m := "x" の形)。予約語であるため、これらの語は関数適用の並置 (f x) と曖昧にならず、パーサーは構文形として確定できる。

後続リテラルの読み方を変える前置予約語 2 語 (conduit / loop) は、表示上の正準形をキーワードと開き括弧の間に空白を 1 つ置いた形 (conduit {...} / loop {...}) に統一する — hikari format の出力・エラーメッセージ・Inspect はこれに揃える (format.md)。上表の「形」列は構文が要求する最小要素を示すラベルであり、この表示規則を左右しない。

各構文形は 要求する対象の形が構文で固定 されており、合致しなければ 構文エラー (パース時に検出、static-analysis.md §1)。具体的には:

  • mutable は mutable <束縛の左辺> := expr を要求する。左辺は 1 個の識別子 (型付きは mutable name: T := expr)・タプル分解の名前リスト (mutable a, b := expr)・スロット分解の名前リスト (mutable { a, b } := expr) のいずれか (§6.3)。slot-list 領域と body 領域の両方に書けるが、:= を欠く (mutable x = 1 / mutable x)・スロットアクセスを左辺に取る (mutable obj.x := 1。スロットは宣言時に固定されるため。§2.4)・部分式の位置に現れる → 構文エラー
  • inner は inner name (name は 1 個の識別子、型付きは inner name: T) を要求し、slot-list 領域限定 (§1.5)。name を欠く・body/部分式の位置に現れる・1 リテラルに 2 個以上 → 構文エラー
  • inner_bound は inner_bound name (name は 1 個の識別子) を要求し、同じく slot-list 領域限定。name を欠く・body/部分式の位置に現れる・1 リテラルに 2 個以上 → 構文エラー。型注釈を持たない ため inner_bound name: T も構文エラーで、inner と同じ識別子を宣言するのも構文エラー (§4.2.1)
  • conduit の後が { 以外 → 構文エラー。透過は呼び出し挙動にかかる修飾なので、オブジェクトリテラルの綴りである {...} に固定する
  • loop の後が { 以外 → 構文エラー(conduit と同じく関数リテラルの正準の綴り {...} に固定する)。捕捉境界の宣言は §18.4
  • import は <対象> := "path" を要求する。対象が bare 名でも名前リスト {…} (§6.3) でもない・:= が無い → 構文エラー。:= 右辺が 文字列リテラル以外 (変数・補間 "${...}"・bare 識別子・任意式) → 構文エラー (動的 import 禁止)
  • match は「任意の照合対象式(省略可)+ アームブロック {...}」を要求する。照合対象位置では末尾ブロックの juxtaposition 適用を無効化し、match と { の間に式があれば照合対象を持つ形、無ければ照合対象を持たない形とする。波括弧で始まる/末尾に波括弧を持つ照合対象は括弧化する (match ({...}) {...})。アームブロックに => を欠く・照合対象位置が解釈不能 → 構文エラー

import の path をリテラル限定にすることで、モジュールグラフを実行前に静的確定できる。

@ 記号はコア言語のどの位置にも存在しない。

1.5 文と式

構文形は式 (expression) と文 (statement) に分かれ、別枠として宣言 (declaration) がある。区別の軸は書ける位置(文法上の出現位置)であって、評価値の種類ではない。

式は値を生み、任意の式の位置に書ける — body の要素、部分式(引数・(...) 内・レシーバー)、:= / = の右辺、スロットのデフォルト値など。ほとんどの構文形は式である。制御構造(if / when / while)は prelude 値への適用にすぎず(§3.9)、conduit(§18.3)・loop(§18.4)・match(prelude.md §8.4)も式。

文は body 領域(§1.3)とファイルレベルの slot-list(§13.1)の要素の位置にのみ書ける。部分式の位置(引数・:= / = の右辺・(...) 内など)に現れると構文エラー。文は次の代入族(§6)のみ:

文 参照
ローカル束縛 name := expr / mutable name := expr / name = expr(型注釈付き name: 型 := expr を含む) §6.1 / §17
スロット代入 recv.slot := expr / recv.slot = expr §6.2
タプル destructure a, b := expr / mutable a, b := expr / a, b = expr §6.3
スロット destructure { a, b } := expr / mutable { a, b } := expr / { a, b } = expr §6.3
複合代入 lhs op= expr(+= 等) §6.4

文も評価されると値を持ち、その値は常に unit ()(§6.1)。body 末尾に文を置くこともでき、そのとき body の値は () になる(§2.2)。つまり Hikari は文を持つが、文も含めすべての構文形が評価値を持つ。

unit を返すこと ≠ 文であること: 区別は出現位置であって評価値ではない。print(...) / each / else 無し when は unit を返すが式であり、部分式の位置に書ける(x := print("hi") は valid で x は ())。代入族が文であるのは unit を返すからではなく、名前の導入・変更という操作を式の合成の外に置く設計だからである(§6.1)。

同じ表面形でも領域で役割が変わる: slot-list 領域の name := expr / mutable name := expr はスロット宣言である。
スロット destructure { a, b } := expr も同じ二相を持つ。
slot-list ではスロット宣言、body ではローカルを導入する文になる(§6.3)。
タプル destructure は body とファイルトップレベルに書ける(同節)。

import はファイルトップレベル、type / enum の定義はファイルトップレベルと body に限る。
明示した slot-list の type a は、型定義ではなく呼び出しで埋める型スロットである(§17.4.1)。

inner name(§4.2)と inner_bound name(§4.2.1)は slot-list に限る。

宣言は import / export / type / enum の宣言形(§1.4)を指す。式ではないため部分式の位置には置けず、配置は各節の規則に従う — import はファイルトップレベルのみ(§13.2 / §13.4)、export はファイル・値の slot-list とタグ定義領域のみ(§13.2)、type / enum の定義位置は §17.4。宣言が文の位置で評価されたときの値も unit () — 代入族の文(§6.1)と同じく、名前を導入する操作は値を生まない。定義した型は次の文から型式の位置で名前(T 等)を書いて引く。

2. オブジェクト (値の統一形)

2.1 構文

オブジェクトリテラルの正規形はパイプ1 個で2 つのセクションを区切る:

{ slot-list | body }

各セクションはそれぞれ独立に空にできる。

  • slot-list: スロットの列。区切りは ,・改行・; のいずれか (すべて等価、連続・前後・末尾を無視。§1.3)。エントリの形は次で閉じている — 下記のいずれにも当たらない綴りは構文エラーである:
    • name: 必須スロット (デフォルトなし)。値は immutable (caller が bind した後は書換不可)
    • name := expr: デフォルトあり (immutable)
    • mutable name := expr: デフォルトあり (mutable)。本体内・slot アクセスで = 更新できる
    • 上記いずれも、名前の直後に 型注釈 : 型 を前置できる (name: 型 / name: 型 := expr / mutable name: 型 := expr)。意味論は §17「型注釈」を参照(注釈への代入可能性は静的に検査する)
    • inner name (型付きは inner name: T): inner-name (自己参照名) 宣言 (§4.2)。本体内でこの名前を通じて値自身に到達できる。データスロットではない (obj.name では引けず、等価・shape に影響しない)。slot-list 領域限定の特別形 (§1.5) で、1 リテラルに高々 1 つ。inner は予約語 (§1.4)、name は書き手が選ぶ識別子で常に immutable
    • inner_bound name: 束縛を写した自分に届く名前の宣言 (§4.2.1)。同じく slot-list 領域限定
    • { a, b } := expr: スロット destructure のスロット相 (§6.3)。抽出した各名前を immutable なスロットとして宣言する
    • 呼び出しで埋める type a と、この値の公開名を定める export { … }。export は入力に数えない。
    • ファイルの暗黙 slot-list だけは type / enum 定義と import も持てる (§13.1)
    • bare identifier は常にスロット宣言 として解釈される (関数構文 { x, y | x + y } を保つため)
    • 必須 / デフォルトあり immutable / デフォルトあり mutable は任意の順序で混在できる
    • 必須スロットは常に immutable (必須 mutable は表現しない。回しながら使いたければ body 内で mutable local にコピーするか default を与える、§6.1)
    • slot-list 全体を空にできる (= スロットなし)
    • スロットの可変性 (mutable / immutable) と、スロット集合がリテラル宣言時に固定されること (§2.4) は別の話である
  • body: 任意の本体コード。複数式は ; または改行で区切る。空可 (= 空 body)。

オブジェクトが持つ軸は 1 つである。 スロットは名前で宣言し名前で引く (recv.name)。整数添字で引く並びを持つのは List (§7.4)・Tuple (§7.3)・String (§7.2)・Bytes (§7.2.2)・range (§7.6) であって、オブジェクトではない。オブジェクトに xs.0 / xs.[i] の軸は無い。

オブジェクトの種類は一つしかない。すべての {...} リテラルは同じ「オブジェクト」を生成し、body はその object の属性にすぎない。record と function という値の種別は無く、呼び出しも等価も body の有無で分岐しない。

  • body を評価すると最後の式の値を返す。末尾の要素が代入族の文 (:= / = / スロット代入 / 分解代入 / 複合代入。§1.5) のときは、その文の値である unit () が body の値になる (§6.1)
  • body を省略したリテラルは、「その literal の inner_bound を返す本体」を持つものとして読む (§2.2)。省略した綴りと、inner_bound を宣言して裸で返す綴りは同じ値を生む

リテラルを評価すると object ができる。body はそのとき評価しない — 走るのは呼び出しのときで、規則は §3.6 の一本だけである。

呼び出しの binding 対象は未束縛のスロットである (デフォルト値の有無は問わない。§3.5 / §3.6)。

正規形の空・非空の組み合わせはすべて意味を持つ:

slot-list body 例 用途
空 省略 {} (≡ {|}) 空オブジェクト
空 あり {| body } (≡ { body }) 無引数ブロック
あり 省略 { x := 0 |} スロット持ちオブジェクト (慣用に「データオブジェクト」)
あり あり { x | body } 関数として使うオブジェクト

用途の列は慣用の呼び名であって値の種別ではない。どの行も同じ 1 種類の object である。

inner-name (inner name) と inner_bound name は宣言なので上のどの行にも足せる: { inner self, x \| body } は inner-name を持つ関数、{ inner self, x := 0 \|} は inner-name 付きデータオブジェクト。

字句上の注意: パイプ2 個がスペースなしで連続する || は論理 OR 演算子トークンとして読まれる。空 slot-list と空 body を明示する形は区切りが 1 個の {|} であり、パイプを 2 個続けた {||} は構文エラーである (空オブジェクトは {} とも書ける)。

ファイルレベルとの関係: ファイル全体も暗黙にリテラルだが、持つのは slot-list 領域だけである (| も body も inner 宣言も持たない)。詳細は §13.1。

2.1.1 省略表現 (shorthand)

頻出する形には短い表記を許す。意味は正規形と完全に同じ:

パイプ数 短い形 同等な正規形 備考
0 { body } {| body } body 非空のブロック
0 {} {|} 空オブジェクト (call で self)

正規形 { slot-list | body } (1-pipe) は各セクションを独立に空にできるため、{ slot-list \|}・{\| body }・{\|} はいずれもそのまま正規形である (省略形ではない)。{\| body } および {\|} の先頭 \| は「空 slot-list セクションの区切り」であり、{ と \| の間、\| と続く要素の間の空白は任意 ({\|body} も同じトークン列)。inner-name は inner name をスロットに書く (§4.2)。

2.2 body を省略したオブジェクト

body セクションを省略したリテラルは、「その literal の inner_bound を返す本体」を持つものとして読む (§4.2.1)。「データ」として使うオブジェクトはこの形で書く:

{ slot-list |}              # 正規形 (slot-list 非空、body 省略)
{ inner name, slot-list |}  # 内部名付き
{ inner name |}             # 内部名付き・他スロットなし
{|}                         # スロットなし (= `{}` と等価)
{}                          # 同上 (0-pipe 省略形)

慣用的にこの形のオブジェクトを「データオブジェクト」と呼ぶことがある。値の種別ではなく呼び名で、文法的にも意味論的にも他のオブジェクトと同種である (§2.1)。

省略は綴りの省略である。 省略した綴りと、inner_bound を宣言して裸で返す綴りは同じ値を生む。等価が 2 つを見比べて一致と判定するのではなく、処理系が値を組む前に 2 つの綴りを同じものへまとめる — したがって等価だけでなく、検分表示・値の種別・持ち物のすべてが一致する。スロットの構成に依らない:

{ x, y |}   == { inner_bound b, x, y | b }     #> true
{ x: Int |} == { inner_bound b, x: Int | b }   #> true   型注釈が付いても同じ
{|}         == { inner_bound b | b }           #> true   スロットが無くても同じ

まとめるのは裸の参照 1 つだけの body である。 括弧・アスクリプション・スロットアクセス・呼び出しが 1 つでも付けば別の綴りであり、別の値になる (§9.1.1 の崖)。整形はどちらの綴りもそのまま保ち (format.md)、省略形で書けることの指摘は hikari lint が担う (lint.md)。

コンストラクターとしての data object: 未束縛スロットを残したこの形は、呼び出しで残りを束縛した完成値を返す (§3.6)。定数の判別子 (タグ) はデフォルト値スロット (t := "int") で与える。これにより { v: Int, t := "int" |} のような data object を、関数で包まずそのままコンストラクターとして使える — 入れ子も同名スロットへの転記 (v := v) も不要になる。

デフォルト値スロットは宣言順の後ろに置く。 デフォルト値の有無に依らず未束縛スロットは束縛対象なので (§3.5)、{ t := "int", v: Int |}("+", 1) は先頭の t から埋まる。タグのように呼び出しで埋めたくないスロットを前に置くと実引数に乗っ取られるため、必須スロットを先に並べる。hikari lint がこの順序を勧告する (lint.md)。

可変スロットを持つリテラル

可変スロット (mutable) も束縛対象である。 { mutable count := 0 |} は arity 1 のコンストラクターで、呼び出しが count を束縛し、明示 kick (! / ()) がデフォルト値を補完してから可変スロットを持つ完成値を組む。スロット宣言も本体の束縛と同じ綴りで、宣言は :=・可変は mutable が担う (§6.1)。

c := { mutable count := 0 |}  # コンストラクター (派生元)
i := c!  # 可変スロット count を持つ完成値
i.count = 5  # 通る。書き込む先は完成値のスロット
c.count = 5  # 静的エラー: 未束縛スロットに現在値は無い (unbound-slot-assign。§4.1)

可変性は束縛済みスロットの属性である。 コンストラクターの側のスロットはデフォルト値の有無に依らず未束縛なので (§3.5)、現在値を持たない。書き込みを許せば以後の全派生へ漏れるため、コンストラクターへの代入はエラーである。

デフォルト値の中の裸の兄弟参照は完成値に届かない。 相互可視 (§6.3) が見せるのはリテラル評価時の値そのものなので、inc が捕獲するのは 0 であって完成値のスロットではない。

{ mutable count := 0, inc := { count += 1 } |}  # inc はリテラル評価時の 0 を捕獲する

完成値の可変状態へ届く名前は inner_bound (§4.2.1) である。「状態 + メソッド」を持つオブジェクトはこの形で書く。

counter := { inner_bound b, mutable count := 0, inc := { b.count += 1; b.count } |}!
counter.inc!  #> 1
counter.inc!  #> 2

デフォルト値は派生をまたいで共有される。 デフォルト値はリテラル評価時に 1 度だけ確定するので (§12)、同じコンストラクターから 2 回派生させると、デフォルト値が可変な値であれば両方が同じものを掴む。inner_bound 名を含むデフォルト値 (派生ごとのデフォルト値) は派生のたびに評価するので、この共有の外にある (§4.2.2)。hikari lint の shared-mutable-default がこれを勧告する (lint.md)。

型スロットを持つリテラル

リテラルの slot-list に書ける型のエントリは、呼び出しで埋める型スロット type a だけである (§17.4.1)。type a は必須スロットと同じく arity に数え、呼び出しが型引数で埋める。

型の宣言 (type Name := …・enum Name := …) はリテラルの slot-list には書けず、構文エラーである (§17.4「出現位置」)。

ok := { type a, x: a |}  # arity 2 (a と x)
ng := { type Pos := { a: Int |}, x: Int |}  # 構文エラー — 型の宣言はリテラルの slot-list に書けない

2.3 例

# 関数: スロット + 本体
add := { x: Int, y: Int | x + y }

# データオブジェクト: スロット (デフォルトあり) + body 省略
point := { x := 0, y := 0 |}

# 内部名 (inner) + スロット + 本体
fact := { inner self: { Int | Int }, n: Int |
  if(n <= 1, { 1 }, { n * self(n-1) })
}

# 無引数ブロック (制御構造に渡す用)
block := { "hello" }

# 内部名のみの無引数ブロック (他スロット無し)
ref: {| Bool } := { inner self | self.reference_equals self }

# 必須とデフォルトの混在
mix := { x: Int, y := 0, z: Int | x + y + z }    # x, z が必須、y はデフォルトあり

# スロットなしデータオブジェクト (= {})
empty_data := {|}

2.4 スロット集合はリテラル宣言時に固定される

リテラル宣言後にスロットを追加する手段は言語に無い。 obj.x := expr / obj.x = expr で新しい名前を作ることはできない。名前でキーを引く辞書が要る場合は標準ライブラリの std:map を使う (§7.5)。

これはレイアウトを静的に決められるようにするための制約である。record は幅構造型なので、スロットが後から生えると静的型が知らないスロットが存在しうることになり、固定オフセットの構造体へ低レベル化する前提が壊れる。

slot 規則:

操作 既存 slot 既存無し
obj.x := expr 静的エラー (再宣言不可) 静的エラー (slot は追加できない)
obj.x = expr mutable → 更新 / immutable → ランタイムエラー ランタイムエラー (slot は追加できない)

:= と = で報告の時期が違う。 obj.slot := expr は受け手に依らず常にエラーなので、受け手の形も型も解かずに静的に報告する。obj.slot = expr の可否 (既存 slot か否か・mutable か否か) は実行時の値の性質なので、静的に判る受け手だけを報告し (static-analysis.md §2.10)、残りは評価時に振り分ける。どちらも 構文としては valid (パース可能) で、:= を構文エラーにしない理由は §6.2。

スロット集合が固定であることと、slot 値の immutable / mutable (§4.1) は別の軸である:

slot value Hikari 用途
immutable { x := 0 |} 値型 (slot 固定 + 値固定)
mutable { mutable x := 0 |} record (slot 固定 + 値可変)
# 値型 (slot 固定 + 値固定)
# 名前でキーを引く辞書は std:map (§7.5)
import m := "std:map"
p := { x := 3, y := 5 |}
p.x = 99  # 静的エラー: immutable slot への代入 (immutable-slot-assign)

# record (slot 固定 + 値可変)。書き込むのは完成値 (§4.1)
counter := { mutable count := 0 |}!
counter.count = counter.count + 1  # OK
counter.total = 0  # 静的エラー: slot は追加できない (no-such-member)

cache := m.insertion.build { h |
  h.set("user_42", { name := "alice" |})
  h.set("user_42", { name := "bob" |})  # 同じキーを上書き
}

List は長さを変えられる別の型ではない。 List も不変で、要素を足した結果が欲しければ map などで組み直すか、可変 scratch ハンドルを frozen で List に確定する std:array を使う (§7.4・std/array.md)。

ファイルトップレベルの暗黙リテラル (§13.1) も同じくスロット集合が固定である。

2.5 全値に生える universal method

一部の method は受け手の型に依らず全ての値で解決される (原始型・コレクション・関数・タグ付きデータを問わない)。「値の統一形」の帰結で、matches 以外は受け手の公開した同名スロットで上書きできる (§8.6) — 上書きの有無にかかわらず、その名前は全ての値で解決可能なまま保たれる (受け手定義に置き換わるか組込既定のままかの違いだけ)。

method 形 役割 詳細
matches v.matches(type T) / v.matches type T 型引数で指定した型への一致を Bool で返す §17.4
compare a.compare(b) 順序比較。Ordering を返し < <= > >= を導出 §9.4 / prelude.md §13
inspect v.inspect() / v.inspect! 人間可読なデバッグ表現。String を返す prelude.md §14
reference_equals a.reference_equals(b) 参照同一性。同一インスタンスなら Bool true。== (値等価) と独立 §9.1
copy v.copy() / v.copy! 現在状態を持つ独立コピー。可変部を作り直し不変部は共有 §9.5
apply_when v.apply_when cond f 条件付き適用。真なら f v、偽なら v をそのまま返す prelude.md §16
-> a -> b / a.->(b) ペア構成。2-tuple (a, b) を返す §8.3
  • 呼び出し時の型要件は method ごとに違う。matches の引数は type T の型引数(§17.4.1)。compare の引数は受け手と比較できる型でなければ静的エラー(§9.4)。copy は複製できる値を要求する(§9.5)。apply_when は Bool の条件と、値を適用できる関数を静的に要求する(prelude.md §16)。inspect / reference_equals / -> は全値を受け取る(reference_equals は §9.1)。
  • apply_when は conduit (§18.3): 渡した f の中の return / break / continue は apply_when を貫いて呼び出し側の関数・ループへ届く。他の universal method は通常の関数境界を持つ。
  • ->: a -> b は a.->(b) に脱糖する (§8.1) universal method で、常に 2-tuple (a, b) を返す。全値がこの baseline 実装を持ち、他の universal method と同じ規則で受け手の -> スロットがあればそちらが優先される — この優先順位が働いても -> という名前自体は全ての値で解決可能なままである。結果はタプルなので位置アクセス (("a" -> 1).0) や destructure ({ k, v | … }) がそのまま効く。
  • 構造照合による分岐 dispatch は match 構文 (§1.4、prelude.md §8.4)。
    match は予約語なので、v.match の第一級取り出しや同名スロットによる上書きは持たない。
    型テストの matches は universal method で、v.matches として取り出せる。
  • 二項演算子 (+ - * / % == != < <= > >=) も同様に全値で解決される (型チェックは呼び出し時。§8)。
  • これらと別系統の読み取り method がある。要素の並びを見る Sequence (§17.5。each / map / filter / fold / first / last / positions / has_position ほか) は List・String・Bytes・range で動き、スロットの自己記述 (names / values / has_name) はオブジェクトで動く。どちらも対象が全値ではない点が universal method と異なる。タプルは位置アクセスと length を持つが、Sequence 全体は実装しない。

matches は固定された型判定である。 メソッド呼び出しと取り出した関数値は同じ判定を行う。
matches は予約語ではないが、ファイルの通常スロット(import で導入するものを含む)、
関数入力と値リテラルの通常スロットには使えない。公開・非公開、必須・デフォルト値を問わず reserved-slot-name になる。
本体のローカル束縛と構造型の要求名には使える。普通の述語関数は真を返しても型の絞り込みを保証しない。

上書きするスロットは名前で公開し、組込の契約を満たす。 inspect / copy / compare /
reference_equals / apply_when / -> と定義可能な演算子は、非公開にすると private-builtin-override になる。
位置分解で取り出せても、名前で公開したことにはならない。
データオブジェクトのリテラル (body を省略したリテラル) が、以下の組込 method と同じ名前のスロットを宣言するとき、表の契約を求める。
満たさなければ静的エラーである (static-analysis.md §2.9)。
ファイルのトップレベルの公開スロットにも同じ契約を求める。

受け手の型がそのスロットを見せない位置 ({ x: Int |} として受けた値の o.inspect!) では、静的検査が組込の形で読む。
実行時にはスロットが呼ばれるため、契約を満たさないと静的型が値と食い違う。

method スロットの契約
inspect 引数を取らず String を返す
reference_equals どの値も 1 つ受け、Bool を返す
compare 受け手の型の値を 1 つ受け、Ordering を返す (§9.4)
copy 引数なしで呼べ、overlay を高々 1 つ受け、受け手の型を返す (§9.5)
apply_when Bool と、受け手の型からそれ自身への関数を受け、受け手の型を返す
-> そのメソッド自身が量化する無境界の型変数のパラメーターを 1 つ受け (y: b)、(受け手の型, b) を返す
== (演算子) どの値も 1 つ受け、Bool を返す。!= は == から導くので、同じ契約が守る
names 引数を取らず List(String) を返す
values 引数を取らず List(Any) に適合する値を返す
has_name String を 1 つ受け、Bool を返す
p := { x := 1, inspect := {| 5 } |}  # 静的エラー: inspect は String を返さなければならない
q := { x := 1, inspect := {| "q(1)" } |}
  • copy・apply_when・-> の「受け手の型」は、そのスロットを除いた残りの欄の型である
  • ファイルのトップレベルの公開スロットも、import した値を幅の狭い型で受けられるため対象である。ファイルの非公開スロットと関数リテラルのスロット (パラメーター) は対象外である
  • + は受け手の静的型が宣言するスロットのシグネチャで検査する。型に現れないスロットへの適用を組込のオブジェクト演算として受理しない (§7.4.1)

2.6 値の公開範囲と公開操作

ファイルと明示した値リテラルは、slot-list に export { name, … } を最大一つ持てる。
省略すると全名前を公開し、export {} は名前を公開しない。置く順序は公開範囲に影響しない。
公開メンバー集合は定義した時点で固定され、適用・別名・再公開・型注釈で変更されない。
公開かどうかはスロットの入力順・arity・必須値・デフォルト値の補完にも影響しない。

公開操作は普通の関数値スロットである。スロットを取り出しても引数は増えず、
捕獲した inner / inner_bound は通常の自己参照の規則に従う。
受け手引数や内部状態の自動転送、型ごとのメソッド表、拡張メソッドは持たない。

counter := {
  export { read, inc },
  inner_bound self,
  mutable count := 0,
  read: {| Int } := {| self.count },
  inc: {| Effect(Int, Mut) } := { self.count += 1; self.count }
|}!
f := counter.read
f!  # counter.read! と同じ値を読む

非公開スロットを名前で読み書きするには、アクセスを書くコードの定義ファイルが値の定義ファイルと同じで、
その内部表現を特定できる静的な型情報が必要である。広い構造的 interface だけでは内部表現を特定できない。
同じファイル内でもレキシカルな名前の範囲は通常どおりであり、公開範囲が名前をスコープへ追加することはない。
同じパッケージの別ファイルは内部アクセス権を持たず、外部のコールバックにも呼び出し元の権限を渡さない。
関数を別名・コンテナー・部分適用経由で運んでも、アクセスを書くコードの定義ファイルを保持する。

名前付きのスロット分解とレコードパターンにも同じアクセス規則を使う。
構造型・interface・matches・式アスクリプション・型パターンは、定義元のファイル内でも公開メンバー集合だけを見る。
名目型の照合は内部の宣言型も検査できるが、その結果は非公開名へのアクセス権を与えない。
公開した可変スロットは通常の可変性・型・効果の条件を満たして読み書きできる。
分解で取り出した値は通常の参照であり、複製や読み取り専用化を行わない。入れ子の値は自身の公開範囲を保持する。

3. 呼び出しと適用

3.1 概念モデル

Hikari の関数は、未束縛スロットを引数で順に埋める値である。
単一値の適用を基本に、表層の引数列とタプル 1 個の適用を区別する(§3.5)。

  • 並置 = 関数適用: f x は f に x を適用
  • タプルは複数要素のみ: (a, b, c) はタプル、(x) は単純グルーピング、() は空タプル
  • 自動 destructure / 値束縛: 関数にタプルを適用すると、未束縛スロット総数と一致すれば destructure される。未束縛スロットが 1 つだけなら、タプルはそのスロットへ値として丸ごと束縛される(destructure しない)
  • auto-curry: すべてのスロットが埋まらない値適用は部分適用 (新しいオブジェクト) を生む。デフォルトの補完は明示的 kick (() / !) でのみ起こる
  • postfix !: v! は v() の短縮 — 「引数なしで呼ぶ」を最短で書ける
  • 引数列とタプル 1 個を区別する: f(a, b) は 2 個の引数を前から束縛し、残る入力があれば部分適用になる。
    f((a, b)) はタプル 1 個を渡す。未束縛スロットが 1 個なら両者は同義になる。
    2 個以上なら、タプルの要素数が残るスロット総数と一致するときだけ分解する(§3.5)。
f := { a: Int, b: Int, c: Int | a + b + c }
p := f(1, 2)  # 残る c を受け取る部分適用
p 3  #> 6
one := { x: (Int, Int) | x }
one(1, 2) == one((1, 2))  #> true
f := { a: Int, b: Int, c: Int | a + b + c }
f((1, 2))  # 静的エラー: タプルの要素数 2 と未束縛スロット総数 3 が不一致

3.2 構文

f x  # 並置で適用 (x を渡す)
f(x, y)  # 2 個の引数。R=1 ならタプルにまとめ、R≥2 なら前から束縛 (§3.5)
f.method x  # method を取り出してから x を適用
recv + x  # 中置演算子。演算子表 (§8.3) にある名前だけが中置になる → recv.+(x)
recv.[expr]  # 動的な要素アクセス。expr の評価値で並びの要素を引く (§3.10)
recv.[expr] = v  # 動的アクセスでの代入。mutability / open-closed 規則は §3.10 / §6.2
v!  # v() と等価 (引数なしの postfix 短縮)

並置は常に関数適用である。 f x が中置メソッド呼び出しに読み替えられることはない。中置になれるのは演算子表 (§8.3) にある名前だけで、どれが中置かは構文解析の時点で決まる — 受け手の値には依存しない。recv name x のような任意の識別子を中置に使う記法は持たないので、メソッド呼び出しは recv.name(x) または recv.name x と書く。

3.3 タプルとグルーピング

(...) の意味は要素数だけで決まる:

形 意味
(e) 単純グルーピング — 式 e をそのまま返す。タプルではない
() unit — void を表す 0 要素タプル値 (print / each / else 無し when / 代入族の文 §6.1 等の戻り)。() 単独は不活性な値で、評価を駆動するのは並置 (適用)
(e1, e2) 2 要素タプル
(e1, e2, e3, ...) N要素タプル

1 要素タプル表記は持たない。(3,) 等は字句的に許可しない。

要素の区切りは , でも改行でもよい (§1.3)。(\n a\n b\n) は (a, b) と同じ 2 要素タプル。要素が1 つだけなら、改行で囲ってもグルーピングのまま — (\n a\n) は (a) と同じ単純グルーピングで、タプルにはならない (1 要素タプルを持たないため。末尾改行は区切りとして無視される)。行末が二項演算子のとき (a +\n b 等) は式が次行へ継続する (§1.3)。二項演算子で終わらない改行はその式を終える。

3.4 例

v := { x: Int, y: Int | x + y }

v 3 2            #> 5    並置で curry: ((v 3) 2)
v(3, 2)          #> 5    タプル (3,2) を destructure
v(3)(2)          #> 5    部分適用してから 2
v 3              #> 部分適用 (y を待つオブジェクト)

t := (3, 2)
v(t)             #> 5    タプル変数を destructure
v t              #> 5    並置でも同じ

one := { value := 1, add := { other: Int | value + other } |}
one.add(2)       #> 3
one.add 2        #> 3    ドット + 並置。one add 2 とは書けない (§8.1)

3.5 引数の束縛規則

関数 f に適用するとき、f の 未束縛のスロット数を R とする (呼び出しで埋める型スロット type a も型引数を受け取るので数える。§17.4.1)。元関数を直接呼ぶときは R = スロット総数 N、部分適用ならその時点で残っているスロット数。

引数の形は 2 つある。 f(a, b) のように書いた表層の引数列 (個数を K とする) と、値としてのタプル 1 個である。両者は R = 1 のときだけ同じものになる。

表層の引数列

行は上から順に当て、最初に一致した行が勝つ(K = 2 / R = 1 は 2 行目と 5 行目の両方に当たるので、順序が意味を持つ)。

K と R 規則
K = 0(() / !) スロットを一切埋めない(明示 kick。v! ≡ v())
K ≥ 2、R = 1、すべて値引数 引数列をタプルへまとめてその 1 スロットへ丸ごと束縛({ pair |}(3, 5) は pair = (3, 5))
K = R(R ≥ 1) 各引数を未束縛のスロットへ前から順に束縛し、スロットがすべて埋まったところで本体を評価
K < R 前から順に束縛した部分適用(curry)。f(1, 2) は f(1)(2) と同じ値になる
K > R エラー (引数数不一致)。R = 0 なら「束縛先のスロットがない」

呼び出しの型引数は type T と書き、1 個の実引数として書いた位置のスロットへ対応する(§17.4.1)。型引数を含む 2 個以上の引数列は R = 1 でもタプルへまとめないので、表の K > R に当たってエラーになる。タプル型 1 個を渡すなら type (A, B) と書く。type A, type B は 2 個の型引数であり、2 個の未束縛スロットを前から順に埋める。

個数に依らず curry である。 if x {y} {z} が段階的な単一値適用で動く(1 回目で cond、2 回目で then、3 回目で else が埋まる)のと、f(1, 2) が 2 スロット分進むのは同じ規則の別の断面にすぎない。

適用スパイン。 呼び出しの結果をさらに呼ぶ並び(f(a)(b)(c)・並置の f a b c)を適用スパインと呼び、f をスパインの先頭、1 回ずつの呼び出しを段と呼ぶ。先頭の未束縛のスロットを埋めていく段は部分適用の続きで、最後のスロットを埋めた段で先頭の本体が走る。その後の段はその戻り値の呼び出しである。add := { a: Int, b: Int | a + b } の add(1)(2) は 2 段目で add の本体が走り、mk := { a: Int | { b: Int | a + b } } の mk(1)(2) は 1 段目で mk の本体が走って、2 段目はその戻り値を呼ぶ。

タプル 1 個

値としてのタプル (要素数を M とする) を渡したときは、完全な引数列として扱う。

M と R 規則
R = 1 その 1 スロットへ丸ごと束縛(destructure しない)
R ≥ 2 かつ M = R destructure: 各要素を未束縛のスロットへ前から順に束縛
R ≥ 2 かつ M ≠ R エラー (引数数不一致)
R = 0 エラー (束縛先のスロットがない)

タプルは部分適用へ倒さない。 表層の引数列と違って要素数の不足をエラーにするのは、(3, 5) を 3 スロット関数へ渡すタイポを検出するためである(明示的に選んだ厳密性)。「書き落とした引数」と「まとめて渡した引数列」を綴りで区別できるのは、この 1 点だけである。

「未束縛のスロット数」を基準とすることで、通常の呼び出しと部分適用への追加適用が同じ規則で説明できる。

R = 0 のオブジェクト (スロットを持たない、または全スロットが既に bound) に引数を渡すと、束縛先がないためエラーになる。{} 5 や [1, 2, 3] "x" がこれである (リストはスロットを持たないので R = 0 である。§7.4)。() または ! を使えば引数 0 個として正しく扱われ、body を省略したオブジェクトなら自身と等しい値が返る (§3.6)。

注 (引数の可変性): caller から bind される値は called frame の必須スロット (immutable、§2.1) に入るため、本体内で引数を = で再代入することはできない。引数を回しながら使いたい場合は n = arg + 1 のように mutable local へコピーする (§6.1)。
注 (タプルの位置づけ): 未束縛スロットが 1 つの関数 { pair |} に (3, 5) を適用すると、タプルが値として pair に丸ごと束縛される(R=1)。f(a, b) がタプル (a, b) の適用と同義になるのは R = 1 のときだけで、{ pair |}(3, 5) も { pair |}((3, 5)) も pair = (3, 5) になる。R ≥ 2 では両者が分かれる — { x, y, z |}(3, 5) は前から 2 つを埋めた部分適用だが、{ x, y, z |}((3, 5)) は要素数が合わないタプルなのでエラーである。タプルを destructure したいときは未束縛スロットを要素数丁度にする({ x, y |}((3, 5)) で x=3, y=5)。
注 (ワイルドカード _): slot パラメーターの bare な _ は引数を 1 つ受け取って捨てる (束縛しない、§6.1)。{ _, x | x } は第 1 引数を無視して第 2 引数を返す。_ は未束縛スロット数 R に算入されるため arity / 部分適用の判定は通常スロットと同じ ({ _, _ | … } は 2 引数を要求する)。_ に default を与えた { _ := d | … } は破棄ではなく「_ という名の optional slot」になる。
注 (コールバックへの要素適用): map / and_then / each / fold / filter 等の高階ライブラリメソッドがブロックへ「1 要素 (payload)」を渡すときは、その要素を単一値としてブロックのパラメーターに束縛する (R=1 は丸ごと、R≥2 は要素タプルを destructure)。表層の明示 kick f () (この表の最終行) と異なり、要素が unit () でも 1 個の引数として最初のパラメーターに束縛される (0 引数 kick に潰れない)。これにより Result(Unit) の payload を r.map { x | … } / r.and_then { x | … } で受け取れ、unit 要素の List も xs.map { x | … } で写せる。() が「明示 kick」になるのは表層の関数適用に限る — コールバックは常に「要素を 1 個渡す」意味論で動く。

3.6 呼び出しのセマンティクス

呼び出しはステートレスである。元の値は変更されない。

  1. 引数を §3.5 のルールでスロットに束縛 (フレッシュなフレーム)。束縛する値がスロットの型(注釈、無ければデフォルト値の型。§12.2)へ静的に代入できることを要求する
  2. 本体評価か部分適用かを判定する。判定軸は「全スロットの束縛」と「明示的 kick」の 2 つで、宣言形 (必須かデフォルトあり) には依存しない:
    • 値適用 (single value / タプル) ですべてのスロット (デフォルトの有無を問わず) が束縛されたなら → 本体評価 (3 へ)
    • 明示的 kick (() / !、引数 0 個) なら → デフォルトを持たない必須スロットが未束縛で残れば error、残らなければ本体評価 (3 へ)
    • それ以外 (値適用したが未束縛のスロットが残る) なら → 部分適用 (4 へ)
  3. 本体評価: 未束縛のままデフォルトを持つスロットに default 値を入れ (補完が起こるのは明示的 kick の経路のみ — 値適用で本体評価に至る時点では全スロットが束縛済み)、本体を評価して結果を返す。派生ごとのデフォルト値 (§4.2.2) を持つスロットに入れるのは、この派生について評価した値である
  4. 部分適用: 新しいオブジェクトを返す。元の関数への参照と「束縛済みスロット名→値」のマップを保持する。未束縛のまま残る派生ごとのデフォルト値は、この部分適用値について評価する

分岐はこの 2 つだけである。 body を省略したリテラルにも別経路は無い — 省略した body は「その literal の inner_bound を返す本体」なので (§2.2)、ステップ 3 がそのまま束縛を写した値を返す。引数で残りのスロットを束縛したなら完成した data object が、束縛が増えない呼び出し (! / ()、R = 0) なら自身と等しい値が返る。引数の検証 (ステップ 1 = §3.5 の引数数チェック) はどちらでも同じで、引数の形が不正なら通常のエラーになる。

ユーザー定義タグ原型にも別経路は無い。 タグ原型は本体を省略した通常のリテラルであり、
未束縛の全スロットに宣言順で値を渡す。デフォルト値付きの関数スロットも入力に数える。
入力が残れば部分適用、すべて束縛するか、必須入力を満たして kick したとき完成したタグ値になる。
公開操作だけを処理系が自動束縛する規則はない。

組込の Some / Ok / Err / Normal / Broke / Returned も通常の適用規則を使う。
組込の payload 入力にはデフォルト値がなく、入力を残した Tag() / Tag! は必須スロット不足になる。
None / Less / Equal / Greater / Continued は完成値なので適用できない。
ユーザー定義タグも入力がなく、型引数が確定していれば原型自身が完成値である。
超過引数と単一スロットへのタプル束縛は §3.5 に従う。

v := { x := 0, y := 0 | x + y }
v.x       #> 0      (デフォルトを読む)
v!        #> 0      (明示的 kick → 全デフォルト補完して本体評価)
v(3, 2)   #> 5      (全スロット束縛 → 本体評価)
v.x       #> 0      (変わらない、ステートレス)
v(7, 1)   #> 8      (何回でも)
v 3       #> 部分適用 (x=3、y 未束縛。デフォルトは kick まで補完されない)
(v 3)!    #> 3      (明示的 kick → y にデフォルト 0 を補完して本体評価)
(v 3) 4   #> 7      (残り 1 スロットを値適用 → 全束縛 → 本体評価)

obj := { name := "john" |}
obj!      #> obj と等しい値 (body 省略なので inner_bound が返る)
obj()     #> 同上

{}!       #> {} と等しい値
{|}!    #> 同上 (`{}` と等価)

# デフォルト値スロットも未束縛スロットとして数える (body の有無に依らない)。
all_defaults := { x := 0, y := 0 |}
all_defaults.x    #> 0            (デフォルト値は読める)
all_defaults 3    #> 部分適用 (x = 3、y は未束縛のままデフォルト値 0 を持つ)
all_defaults!     #> 全デフォルトを補完した、自身と等しい値

# 必須スロットだけの body 省略オブジェクトは R ≥ 1 を持つ。
pair := { x: Int, y: Int |}
p1 := pair 3      #> x := 3 を bind した部分適用オブジェクト
p1.x              #> 3
pair(3, 5).x      #> 3 (x, y 両方 bind した完成 data object)

# 必須スロット + 末尾の定数 tag は「コンストラクター」になる。
# 完全適用すると束縛を写した完成値が返り、部分適用は curry になる。
n_bin := { op: String, l: Int, r: Int, t := "binop" |}
n_bin("+", 1, 2).op   #> "+"      (op, l, r を束縛した完成 data object)
n_bin("+", 1, 2).t    #> "binop"  (未束縛のままデフォルト値を読む)
n_bin "+"             #> 部分適用 (op := "+"、l, r, t 未束縛)

束縛先の無い適用は静的エラーである(static-analysis.md §2.8)。

{} 5      # 静的エラー (R = 0 に単一値)
{} (1, 2) # 静的エラー (R = 0 に 2-tuple)
[] "x"    # 静的エラー (R = 0 に単一値)

3.7 部分適用の値表現

部分適用は新しいオブジェクトとして表現される:

  • 元関数への参照を保持
  • 束縛済みスロットの「名前 → 内容」マップを保持する。値スロットの内容は値、型スロットの内容は type T が渡した内部の型表現である。型表現は呼び出しと照合にだけ使い、Hikari の値として取り出せない

部分適用に対するスロットアクセス:

  • 束縛済みスロットは読める: add5 := add 5; add5.x #> 5
  • 未束縛スロットを読むとエラー (Error)
  • 呼び出しで埋めた型スロット (type a) は束縛済みでも値としては読めない (静的エラー。§17.4.1「型スロットは値として取り出せない」)
add := { x: Int, y: Int | x + y }
add5 := add 5    # 部分適用、x = 5、y は未束縛
add5.x           #> 5
add5.y           #> error (未束縛スロット)
add5(10)         #> 15
add5 10          #> 15

3.8 多値返却

, で区切られた値のリスト (シーケンスの最終位置) はタプルとして返る。「多値返却」は単に , でタプルを作って返している実態である。

多値返却は return(a, b) でよい(タプル 1 個の適用 = R=1 の return へ丸ごと束縛。return((a, b)) も同義)。

v := { x: Int, y: Int | x + y, x - y }
r := v(5, 3)
r  #> (8, 2)        タプル値
r.0  #> 8
a, b := v(5, 3)  # 分解代入
a  #> 8
b  #> 2

3.9 制御構造への波及 — if と when

if は 必須3 スロットとして定義される (組み込み):

if := { cond, then, else | ... }    # 全スロット必須、デフォルトなし

これにより if x {y} {z} の段階 curry が自然に成立する:

  1. if x → cond=x、then と else が未束縛 → 部分適用
  2. (if x) {y} → then={y}、else 未束縛 → 部分適用
  3. (if x {y}) {z} → else={z}、必須全て埋まる → 本体評価

タプル形 if(x, {y}, {z}) も同じ意味。

else を持たない 2-arg ヘルパーとして when を別途定義する (prelude):

when := conduit { cond: Bool, then: {| a } |
  if cond then {
    ()
  }
}

when c.not! {print "foo"} のように、else を省略したい用途で使う。成立時は then の値を、非成立時は () を返す。conduit (§18.3) なので、then の中の return / break / continue は when を貫いて外側へ届く (prelude.md §8.2)。

3.10 動的な要素アクセス

recv.[expr] は expr を評価した Int をキーとして、List・String・Bytes・range およびタプルの要素を動的に引く。前の 4 つは Sequence (§17.5) を実装する。タプルは位置アクセスを持つが、Sequence 全体は実装しない。recv.0 (§3.2) の添字部分を「リテラル整数」から「式の評価結果」に拡張したものである。

要素の並び専用である。 オブジェクトのスロットを実行時のキーで引く手段は言語に無い。キーで引く辞書が要る場合は標準ライブラリの std:map を使う (§7.5)。

評価規則:

  1. recv を評価する
  2. expr を評価して値 k を得る
  3. k が Int でなければ実行時エラー
  4. recv の要素を k で引く (recv.<k> と同じ)
  5. recv が上に挙げた要素アクセスを持たない、またはキーに対応する要素が無ければ実行時エラー

範囲外の添字は実行時エラーである。 静的検査が報告するのは、範囲外が実行前に確定する形だけである — 受け手がリストリテラルを束ねた不変な名前で、添字が整数の定数(xs.[5]・位置アクセス xs.5。§3.2)のとき、その値が 0 未満か長さ以上なら静的エラーになる (static-analysis.md §2.11「確定した範囲外」)。添字が変数の形は、受け手が何であっても実行時に確かめる。Any の受け手へのアクセスは静的エラーである。

等価性:

xs := [10, 20, 30]
xs.[0]  #> 10    (≡ xs.0)
xs.[1 + 1]  #> 30    (キー部分は任意の式)

型による制約:

xs.["x"]  #> error (key must be Int, got STRING)
xs.[true]  #> error (key must be Int, got BOOLEAN)
xs.[(1, 2)]  #> error (key must be Int, got TUPLE)

なぜ要素の並びだけなのか: スロットの動的キーは、どのスロットへ触るかが静的に決まらない。record は幅構造型なので、静的型が知らないスロット(別の視点が具体型で宣言しているスロット)へ書かれる可能性が残り、値のレイアウトを固定オフセットの構造体へ低レベル化する前提が壊れる。要素の並びにはこの危険が無い — List(T) は要素型が均質なので、添字が実行時に決まっても要素の型は変わらない。したがって、添字が実行時に決まることを理由に型を不明にする必要は無い。

結合性・優先順位: . と同レベル (§8.3 表の項 11)。左結合: a.[k1].[k2] は (a.[k1]).[k2]。f x.[k] は f (x.[k]) (.[] は並置より強い)。

空白の扱い: recv.[k] / recv .[k] / recv. [k] / recv . [ k ] はすべて等価 (§8.3.1)。

代入: 要素への代入 recv.[expr] = v / recv.N = v は静的に拒否する。
添字が Int 以外と分かる場合は添字の型エラー、それ以外は immutable-slot-assign になる。
List・String・Bytes・range とタプルはいずれも不変で、要素を差し替える経路を持たない(§7.4)。
任意添字への O(1) 散在書き込みが要る場合は std:array(同節)を使う。

xs := [10, 20, 30]
xs.[0] = 99  # 静的エラー: immutable-slot-assign (リストは不変)

ユーザー定義によるオーバーロードは持たない。recv.[k] の意味論は、上に挙げた組込型の要素の動的検索に固定。

存在確認との対: recv.[i] は位置不在のとき実行時エラーになる。引く前に確かめたい場合は recv.has_position(i) を使う (prelude.md §6)。位置の全列挙は recv.positions!。オブジェクトのスロットの列挙・存在確認は recv.names! / recv.has_name(k) で行えるが (§2.5)、名前で引く手段は無い (recv.<リテラル識別子> だけ)。組込型メソッド・演算子は列挙・存在確認の対象外なので、名前で解決できる全てを列挙する手段は言語に無い。

4. スロットと自己参照

4.1 スロットの可変性

スロットには mutable と immutable の 2 種類があり、どちらで宣言したかは slot-list の形で決まる (§2.1):

  • name (bare 必須) / name := default → immutable
  • mutable name := default → mutable

immutable slot を = で書き換えるとランタイムエラー。mutable slot は = で更新できる。値は参照共有のセマンティクスを持ち、mutable slot 経由の更新は共有先からも見える。

可変性は束縛済みスロットの属性である。 未束縛スロット (§3.5) には現在値が無いので、mutable と宣言してあっても書き込めない — { mutable count := 0 |} そのもの (コンストラクター) や、その部分適用への c.count = 5 はエラーである。書き込む先を持つのは呼び出しが束縛を写した完成値だけである (§2.2)。受け手がコンストラクターだと綴りで分かる位置 (リテラルそのものとその immutable 束縛) では、実行前の静的検査が unbound-slot-assign として報告する (static-analysis.md §2.10)。

obj := { name := "john", mutable score := 100 |}!  # 完成値 ([§2.2](#22-body-を省略したオブジェクト))。name は immutable、score は mutable
obj.score = 200
obj.score  #> 200

foo := obj
foo.score = 999
obj.score  #> 999     # 参照共有 (mutable slot)

! を落とした綴り ({ … |} そのもの) はコンストラクターであり、そのスロットは未束縛なので obj.score = 200 は上記のとおりエラー (unbound-slot-assign) である。完成値に対しても、immutable slot への代入 (obj.name = "bob") はエラー (immutable-slot-assign) で、この受け手は綴りで分かるので実行前の静的検査が報告する。

可変性は shallow — immutable slot が指す先が mutable な List / Object であれば、その中身は依然変更できる (slot 自体の再代入だけが禁じられる)。スロットを実行時に追加することはできない (§2.4) — キーで引く辞書が要る場合は std:map を使う (§7.5)。

4.2 自己参照 (inner-name)

slot-list に inner name を書くと内部名を宣言でき、本体内でその名前を通じて値自身に到達できる。
inner は予約語である (§1.4)。
name には予約語以外の識別子を選べる。self/this/me も使える。

宣言形のため代入演算子を持たず、inner-name は常に immutable である。
self = ... のような内部名そのものへの代入はできない。自身を別の値に差し替える意味は持たせない。

inner name はデータスロットではない。obj.name では引けず、等価・shape に影響しない。
slot-list 領域限定の特別形 (§1.5) で、1 リテラルに高々 1 つ宣言できる。

obj := { inner self, value := 100 |
  self.value + 1  # 自身のスロットを self 経由で参照
}

内部名は再帰関数の自己参照にも使う:

fact := { inner self: { Int | Int }, n: Int |
  if(n <= 1, {
    1
  }, {
    n * self (n - 1)
  })
}
fact 5  #> 120

:= の右辺を評価している最中は、左辺名 (この例では fact) はまだ束縛されていない。右辺そのものの式 (x := x + 1 の右辺の x) が読むのは外側の x である。関数の本体は呼ばれたときに走るので、ファイルと body の宣言では、本体から左辺名を裸で指して再帰できる (§5)。データのリテラルと関数リテラルのスロットのデフォルト値の中では、自分の名前は外側を指す (同)。裸の名前が指すのはその束縛で、後で差し替えれば差し替えた先を呼ぶ。inner-name はリテラル自身を指すので、束縛を持たない関数 (実引数に直接書いた関数リテラル) の再帰は inner-name でしか書けない。

go := { n: Int |
  if (n <= 0) {
    0
  } {
    1 + go (n - 1)
  }
}
go 3  #> 3

内部名が指すのは リテラルが生んだ値そのもの である。部分適用 (§3.5・§3.7) で派生した値の本体を評価するときも同じで、内部名には派生元が入る (束縛済みスロットを持つ派生値ではない)。したがって f(1)(2) と f(1, 2) は本体から見える自己参照も一致し、{ inner rec, a, b | … (rec(a - 1))(b + 1) … } のように curry 形で自己呼び出しを書いても、実引数は毎回すべてのスロットへ先頭から束縛される。

束縛を写した自分に届きたい場合は inner_bound を使う (§4.2.1)。

4.2.1 束縛を写した自分 (inner_bound)

slot-list に inner_bound name を書くと、束縛を写した自分に届く名前を宣言できる。inner と対になるが、指す先が違う。

宣言 指すもの 派生時
inner name リテラルが生んだ値そのもの (派生元) 派生元を指したまま
inner_bound name 束縛を写した自分 その派生値を指す (§4.2.2)
node := { inner_bound b, op: String, l: Int, r: Int | validate b }
node("+", 1, 2)  # op, l, r を束縛した値を validate に通してから返す

body を省略したリテラルが返すのはこの値である (§2.2)。{ x, y |} は { inner_bound b, x, y | b } と同じ値を生む。

規則は inner (§4.2) と揃える。

  • slot-list 領域限定の特別形 (§1.5) で、1 リテラルに高々 1 つ。名前は書き手が選ぶ識別子
  • 宣言形のため代入演算子を持たず、常に immutable
  • データスロットではない — obj.name では引けず、等価・shape に影響しない (§9.1 の等価は自己参照名の綴りを正規化して比べる)
  • 型注釈を持たない。束縛後の型はスロット宣言から導出できるため、注釈は言い直しにしかならない。inner_bound b: T は構文エラー (§1.4)
  • inner と併用でき、同じ識別子を両方に宣言するのは構文エラー。指す先は名前ごとに決まる — 派生のたびに派生値を指すのは inner_bound だけで、inner は派生元を指したままになる
  • 指すのは値そのもので、複製ではない。可変スロットへの書き込みは同じ値に効き、reference_equals (§9.1) も真になる。copy したときは §9.5 の自己参照名の再束縛と同じ規律で複製先へ束縛し直す
  • デフォルト値を評価している最中は読めない (§12)。派生値がまだ組み上がっておらず、そこから読める値を言語は定めない。静的エラーである (static-analysis.md §2.7)
  • デフォルト値が作る関数リテラルの中からは捕獲できる。デフォルト値の評価中に裸で読むこと (上記) とは別で、捕獲した名前が読まれるのはその関数が呼ばれたときなので、そのときには束縛が済んでいる。inner_bound 名を含むデフォルト値は、リテラル評価時ではなく派生のたびに評価する (§4.2.2)
{ inner_bound b, x: Int, get := {| b } | x }
  • inner_bound が指すのは、その値を作った派生である。 派生とは実引数を束縛して新しい値を作ることで、リテラル評価 (派生元を作る側) は派生ではない。部分適用も派生である — 未束縛スロットが残る呼び出しで得た値でも、デフォルト値が捕獲する inner_bound はその派生値を指す
c := { inner_bound b, x: Int, y: Int, get := {| b } |}
(c 1).get!  #> { x := 1, y, get := {| ... } |}
  • 包んでも指す先は変わらない。 クロージャをスロットの値として直接置いても、呼び出しの実引数として作ってラッパーに入れても、そのクロージャが指すのは同じ派生である。同じ派生元から何度派生させても、先に作った値のクロージャは後の派生に影響されない
wrap := { run: {| Int } | { run := run |} }
c := { inner_bound me, x := 0, direct := {| me.x }, nested := wrap {| me.x } |}
a := c(1)!
b := c(2)!
a.direct!, a.nested.run!  #> (1, 1)
b.direct!, b.nested.run!  #> (2, 2)

4.2.2 派生ごとのデフォルト値

デフォルト値の式のどこかに自リテラルの inner_bound 名が現れるとき、そのデフォルト値を派生ごとのデフォルト値と呼ぶ。上の get・direct・nested のデフォルト値はいずれも派生ごとのデフォルト値である。派生ごとのデフォルト値は、そのスロットを未束縛のまま残して派生するたびに評価し、その派生値を inner_bound として束縛する。それ以外のデフォルト値はリテラル評価時に 1 度だけ評価して派生をまたいで共有する (§12・§12.1)。

判定は同じリテラルの綴りだけで決まる。 出現の深さは問わない — 関数リテラルの本体の中の出現も数える。内側のリテラルが同じ名前をスロット・inner-name・inner_bound のどれかで宣言して隠した出現は、別のものを指すので数えない。兄弟の名前や外側の関数を経て自分へ届くかは追わない (その経路は下の「デフォルト値の式から、派生ごとのデフォルト値を持つスロットを裸の兄弟名で読めない」が塞ぐ)。

評価の時点と環境

  • 派生のたびに評価する。 実引数を束縛した後、実引数で埋まらなかったスロットの派生ごとのデフォルト値を宣言順に評価してから値を組む。実引数で埋めたスロットの派生ごとのデフォルト値は評価しない。部分適用の段でも評価するので、部分適用で得た値では、派生ごとのデフォルト値を持つスロットも読める。段を重ねれば段ごとに評価し、前の段の結果は使わない。未束縛スロットを持たない値への ! は束縛が増えないので評価しない
  • 環境は普通のデフォルト値と同じである。 派生ごとのデフォルト値はデフォルト値の式と同じ環境で評価し、inner_bound だけをその派生値へ束縛する。裸の兄弟名と inner は派生元を指す (§5)。外側の束縛は評価する時点の値を読む
c := { inner_bound me, x := 1, get := {| x, me.x } |}
a := c(10)!
a.get!  #> (1, 10)
  • 派生ごとに新しい値を作る。 派生ごとのデフォルト値が確保した可変な値は、その派生だけのものである。同じ派生元から派生させた 2 つの値は、派生ごとのデフォルト値を持つスロットの中身を共有しない
c := { inner_bound me, x := 0, view := { mutable hits := 0, run := {| me.x } |}! |}
a := c!
b := c!
a.view.hits = 5
b.view.hits  #> 0
  • 初期化の途中は完成していない。 派生ごとのデフォルト値が作ったクロージャを初期化の最中に呼んで inner_bound を読むと、後ろで宣言する兄弟を先に読んだときと同じく実行時エラー (undefined: name) になる (§5)。そのクロージャを初期化の最中に copy したときの扱いは §9.5 が定める

派生元では値を持たない

派生元では、派生ごとのデフォルト値を持つスロットは値を持たない。 派生元には指すべき派生が無いので、派生ごとのデフォルト値を評価しない。デフォルト値の無い未束縛スロットと同じく、読むこと・+ の被演算子にすること・スロット分解の右辺にすることは静的エラーで (unbound-slot-read)、そのスロットに値を要求する record 型の位置へ渡すことは型の不一致である (static-analysis.md §2.7)。! か実引数の束縛で派生してから読む。

c := { inner_bound b, count := 0, get: {| Int } := {| b.count } |}
c.get!  # 静的エラー: 派生元の get は値を持たない
c!.get!  # 派生してから読む

派生ごとのデフォルト値に課す制約

次の 3 つは静的エラーである (static-analysis.md §2.7)。

  • デフォルト値の式から、派生ごとのデフォルト値を持つスロットを裸の兄弟名で読めない。 裸の兄弟名は派生元を指し、派生元ではそのスロットは値を持たないからである。inner_bound 名を介して書く (per-derivation-default-sibling-read)
wrap := { run: {| Int } | { run := run |} }
c := { inner_bound me, x := 0, get := {| me.x }, nested := wrap get |}  # 静的エラー
d := { inner_bound me, x := 0, get := {| me.x }, nested := wrap {| me.get! } |}  # 通る
  • 派生ごとのデフォルト値は効果を持たない。 評価の回数と時点が派生の書き方で決まるので、効果を許すとその回数と順序が観測できてしまう。関数リテラルの本体は派生ごとのデフォルト値の評価では走らないので数えないが、そのスロットのデフォルト値は評価するので数える。可変な値の確保は効果ではないので、状態を持つ値やウィジェットは派生ごとのデフォルト値で組める。派生ごとのデフォルト値の中で確保した値と、初期化している派生値そのもの (inner_bound 名を通した書き込み) への書き込みも、この派生で新しく作る値への書き込みなので効果に数えない。1 度だけ走らせたい処理は、inner_bound を含まないデフォルト値か factory に置く (per-derivation-default-effect)
state := { mutable n := 0 |}!
next := {| state.n += 1; state.n }
c := { inner_bound me, x := 0, get := { n := next! | me.x + n } |}  # 静的エラー: n のデフォルト値が Mut を持つ
  • 派生ごとのデフォルト値は多重度型の値を名指せない。 何度評価されるか決まらないので、使用回数の限られた値 (§17.8) を消費も借用もできない (per-derivation-default-multiplicity)

4.3 レキシカルスコープによる外側参照

外側のオブジェクトリテラルが内部名を持っていれば、内側からその名前で外側に到達できる。これは特別な仕組みではなくレキシカルスコープそのものである。parent も super も予約語ではなく、外側リテラルがその名前を選んだだけ。

outer := { inner parent, value := 1 |
  child: { Int | Int } := { inner self, value := 100 |
    self.value + parent.value
  }
  child()  #> 101
}

5. 名前解決

本体内で裸の名前 x が参照されたとき、以下の順に探索する:

  1. 呼び出しフレームの束縛 (引数や本体内 := で導入されたローカル)
  2. 自身のスロット (ファイルレベルではトップレベル宣言が作る slot)
  3. 自身の内部名 (宣言されていれば)
  4. 外側リテラル群のスロット・内部名・本体ローカル (レキシカルチェーン)

§13.1 の評価モデルにより、ファイル全体は暗黙のオブジェクトリテラル { slot-list |} として扱われる。ファイルのトップレベル宣言は最外側リテラルのスロットなので、ステップ 2 (自身のスロット) と、内側のリテラルから見たときはステップ 4 (外側レキシカル) で解決される。

探索は宣言の前後を問わない。 ステップ 1 と 2 と 4 が探す束縛には、参照より後ろで宣言するものも入る。関数の本体は呼ばれたときに走るので、本体からは後ろで宣言する名前を裸で指せる — 後ろの兄弟スロット・後ろの本体ローカルと、それらを互いに呼び合う形 (相互再帰) である。どの領域 (ファイル・データのリテラルの slot-list・関数リテラルの slot-list・body) でも同じで、右辺が関数リテラルかどうかも問わない。

t := 100
r := { f := {| t + 1 }, t := 1 |}
r.f!  #> 2

f の本体の t は、外側の t ではなく兄弟のスロット t を指す — ステップ 4 は内側のリテラルから外へ向かって探すので、r のリテラルのスロットが先に見つかる。

スロットのデフォルト値の中の自分自身の名前は外側を指す。 データのリテラルと関数リテラルの slot-list では、スロットのデフォルト値の中に書いたそのスロット自身の名前は、自分ではなく外側の束縛を指す。同じ名前の外側の関数を包み直すスロットがこの形で書ける。前の兄弟の関数から同じ名前を指せば、それは後ろの兄弟であるこのスロットを指す。このスロットの自己再帰は inner-name で書く (§4.2)。ファイルと body の宣言はこの例外の外にあり、自分自身を裸の名前で指して再帰できる。

shout := { s: String | s + "!" }
r := { shout := { s: String | shout ("[" + s + "]") } |}
r.shout "x"  #> "[x]!"

スロットのデフォルト値からは、同じリテラルの body のローカルは見えない。 デフォルト値はリテラルの評価時に外側のフレームで 1 度だけ評価される (§12) ので、そこで作った関数の本体が後で走っても、呼び出しフレームの束縛 (ステップ 1) はその関数の外側に無い。デフォルト値の中の関数が裸の名前で指せるのは、兄弟のスロットと、リテラルの外側の束縛である。

x := 1
g := { a := {| x } |
  x := 2
  a()
}
g()  #> 1

読めるのは束縛が済んでからである。 本体が走った時点で指す名前がまだ束縛されていなければ、実行時エラー (undefined: name) になる。後ろで宣言する名前を指す関数を、その宣言より前で呼んだ形がこれにあたる。

即時に評価する位置はこの規則の外である。 デフォルト値の式そのもの・:= の右辺・body の式だけの文は、その位置で評価されるので、後ろで宣言する名前はまだ束縛されていない。そこで裸の名前が指すのは、前で宣言した兄弟か外側の束縛である ({ t := Some(t) |} の右辺の t は外側の t)。外側にも無ければ静的エラーである (static-analysis.md §2.13)。

制御構造 if / when / while に渡すブロックも関数リテラルなので、その本体からは同じ文列の後ろの宣言が見える — ユーザー定義の制御構造に渡すブロックと同じ答えである。prelude の制御構造は渡されたブロックをその場で走らせるので、そこから同じ文列の後ろの宣言を読むのは必ず束縛より前であり、外側に同じ綴りの束縛があっても静的エラーになる (static-analysis.md §2.13)。

t := 100
g := {|
  f := {|
    if true {
      t + 1
    } {
      0
    }
  }
  t := 1
  f()
}
g()  #> 2

f の本体の中のブロックが指す t は後ろの t := 1 である。f を介さずに g の本体で a := if true { t + 1 } { 0 } と書くと、同じ t をその宣言より前に読むので静的エラーになる。

派生しても、デフォルト値が作る関数が指すのは派生元のスロットである。 デフォルト値はリテラル評価時に 1 度だけ評価され (§12)、その関数も派生をまたいで共有される (§12.1)。前の兄弟を指すときも後ろの兄弟を指すときも同じである。派生のたびに評価する派生ごとのデフォルト値 (§4.2.2) の中でも、裸の兄弟名は派生元のスロットを指す。派生した値のスロットを読みたいなら inner_bound を使う (§4.2.1)。

裸の value と self.value が同じ値を指すのは、リテラルが生んだ値そのものの本体を評価しているときである。部分適用や実引数で派生した値の本体では、裸の value は束縛された値を、self.value は派生元のスロットを読む — 内部名は派生元を指すためである (§4.2)。束縛後の自分に名前で届きたいときは inner_bound を使う (§4.2.1)。

obj := { inner self, value := 100 |
  [value, self.value]: List(Int)
}
obj 5  #> [5, 100]
obj()  #> [100, 100]

6. 代入演算子

6.1 ローカル束縛: := と =

宣言は :=・代入は = であり、可変かどうかは前置予約語 mutable (§1.4) が担う。この割り当ては領域で変わらない — slot-list 領域のスロット宣言 (§2) もスロットアクセス (§6.2) も同じ 2 本の規則で読める。

  • name := expr: immutable なローカル宣言を作る。同じ呼び出しフレーム / 同じリテラルのスロット宣言内に既に同名があれば静的エラー (シャドウ不可。static-analysis.md §2.10)。外側スコープ (別のオブジェクトリテラル) の同名を「結果として隠す」のは可 — 別スコープなので衝突ではない
  • mutable name := expr: mutable なローカル宣言を作る。重複・シャドウの規則は := と同じ (既存が immutable でも mutable でも、同一スコープの再宣言は重複宣言エラー)
  • name = expr: 代入。スコープチェーンを上に探索し:

= が名前を導入しないことは、打ち間違いの防波堤である。 lenght = 5 は「そんな名前は無い」と静的に報告される。可変な名前が生まれる位置は mutable の綴りがある所だけなので、読み手も書き手も宣言を探すのに名前の初出を追う必要が無い。

prelude の束縛は最外スコープの immutable 束縛である。 = の探索はこれを見つけるので、println = f や max = 0 は上の「既存 immutable」の枝に落ちて静的エラーになる (static-analysis.md §2.10)。prelude 名を特別扱いする規則ではなく、x := 1 の後の x = 2 と同じ 1 本の規則が当たるだけである。

prelude は利用者のトップレベルより外側のスコープなので、:= / mutable := による被覆 (if := 5。§1.2.2) は正当で、重複宣言にはならない。prelude が占める名前の可変ローカルが要るなら mutable max := 0 と宣言する — 宣言は被覆として通り、以後その名前はその宣言を指す。

  • _ := expr / _ = expr: 名前が _ (ワイルドカード) のときは 右辺を評価したうえで何も束縛しない。_ は環境に入らないため、同一スコープで何度でも書けて (:= のシャドウ不可の例外)、後で読むと未定義 (undefined: _) になる。「捨てた」ことが構文上保証される。_ = expr は上の「どこにも無ければ静的エラー」の例外である — _ は探索の対象ではなく捨て先なので、宣言の有無を問わない。破棄が効くのは bare な宣言順束縛の左辺のみ — _ に値を与えた slot ({ _ := d |} / { mutable _ := 1 |}) や obj._、スロット destructure { a, _ } では _ は通常の識別子のまま (§6.3 / §3.5)。

代入族の文の値は unit (): := / = による束縛・代入は、評価すると常に unit () を返す (§3.3) — 右辺の値ではない。束縛は「名前を導入する」操作であって値を生む式ではない、という立場を値でも表す。ワイルドカードへの束縛 _ := expr / _ = expr も同じく ()。したがって body 末尾が代入族の文のとき、body の値は () になる (§2.2)。この規則はスロット代入 (§6.2)・分解代入 (§6.3)・複合代入 (§6.4) にも一様に及ぶ。右辺の短絡・エラー伝播 (? や右辺自体のエラー) は束縛前に生じるためその制御値を伝播し、正常完了時のみ () を返す。なお代入族は文であり、body の要素の位置にのみ書ける — 部分式の位置 (引数・:= / = の右辺・(...) 内) に現れると構文エラー (§1.5)。

v := { x, y |
  sum := x + y  # immutable 宣言 (シャドウ不可: sum := を再度でエラー)
  x = 99  # 静的エラー: x は必須スロット (immutable)。immutable-assign
  sum
}

# 引数を回しながら使う: mutable local にコピーする
counter_step := { count |
  mutable n := count + 1  # 可変の宣言 (count は immutable のためコピー)
  n = n + 1  # 既存 mutable を更新
  n
}

6.2 スロットアクセス: = と :=

スロットアクセスの代入は、対象 slot の mutability だけで決まる。スロットの集合は open / closed によらず固定なので (§2.4)、代入で新しいスロットが生まれることは無い。 ローカル束縛 (§6.1) と同じく = は名前を導入せず、宣言はリテラルの slot-list だけが行う。

  • obj.slot = expr: 既存 mutable → 更新 / 既存 immutable → ランタイムエラー / 未定義 → ランタイムエラー
  • obj.slot := expr: 静的エラー (slot 追加不可・再宣言不可)

obj.slot := expr は構文として valid (パース可能) だが、受け手に依らず常にエラーである。スロット集合はリテラル宣言時に固定される (§2.4) ので、この綴りが成立する受け手は存在しない。したがって受け手の形も型も解かずに静的に報告する (static-analysis.md §2.10)。obj.slot = expr の側は違う — 既存 slot か否か・mutability は実行時の値の性質なので、静的に判る受け手だけを報告し、残りは評価時に振り分ける。

それでも := を構文エラーにはしない。 綴りの意味は明瞭 (「スロットを足したい」) なので、返すべき答えは「読めない」ではなく「その操作は無く、実行時にキーを増やしたいなら std:map である」(§7.5) だからである。構文エラーの位置にはこの案内を置けず、同じファイルの他の診断も出せなくなる。

obj := { mutable name := "john" |}!  # 完成値。name は mutable
obj.name = "bob"  # OK (既存 mutable スロットを更新)
obj.score = 30  # 静的エラー: 未定義スロット (no-such-member)
obj.score := 30  # 静的エラー: slot 追加不可 (closed-object-slot-add)

p := { id := 1 |}!  # id は immutable
p.id = 2  # 静的エラー: immutable slot への代入 (immutable-slot-assign)

cache := {}  # スロットを持たないオブジェクト
cache.user_42 = "alice"  # 静的エラー: slot は追加できない (no-such-member)

slot を = / := により後付け追加できないのは、タイポによる事故を防ぐためと、スロット集合を静的に固定してレイアウトを決められるようにするためである (§2.4)。キーで引く辞書が要る用途は std:map を使う (§7.5)。

スロット代入も文の値は unit () (§6.1)。代入対象が無い・immutable などのエラーは伝播し、成功時のみ () を返す。

6.3 分解代入

分解代入は 2 形 (位置 / 名前) あり、それぞれ宣言版 (:=。mutable 前置で可変) と代入版 (=。§6.1 の = 規則どおり既存の可変を更新し、無ければ静的エラー) を持つ。mutable は名前リスト全体に掛かり、一部だけを可変にする綴りは無い — 混ぜたいなら宣言を分けて書く。

形 意味
a, b := expr (タプル destructure) a, b を immutable で導入
mutable a, b := expr a, b を mutable で導入
a, b = expr 既存の可変な a, b を更新
{ name1, name2 } := value (スロット destructure) 各 name を immutable で導入
mutable { name1, name2 } := value 各 name を mutable で導入
{ name1, name2 } = value 既存の可変な各 name を更新

分解代入も文の値は unit () (§6.1) — 右辺のタプル/オブジェクトではない。

分解先の型注釈は、取り出す各値の型を静的に要求する。
a: Int, b := expr と { x: Int } := value では、各値が注釈の型へ代入できなければ静的エラーである。
mutable の宣言・代入版・slot-list 領域の名前分解にも同じ規則を適用し、実行時には照合しない。
下方変換が必要なら、分解する前の値に明示のアスクリプションを書く。

タプル destructure: a, b := v(...) で右辺の要素の並びから複数のローカルを順に一度に導入する。多値返却のタプルを受けるのが主用途だが、取り出す先はタプル専用ではない — タプルのほか、List・String・Bytes・range も分解できる。後の 4 つは Sequence (§17.5) を実装する。

右辺 例 結果
タプル (§7.3) a, b := (1, 2) a = 1, b = 2
リスト (§7.4) a, b := [1, 2] a = 1, b = 2
String の rune 列 (§7.2) a, b := "xy" a = "x", b = "y"
Bytes (§7.2.2) a, b := "ab".to_bytes! a = 97, b = 98
range (§7.6) a, b := range(0, 2) a = 0, b = 1

要素数は厳密に一致する (§3.5)。左辺の名前の個数と右辺の要素数が違えば実行時エラーになる。上の 5 種以外の値を右辺に置くのも実行時エラーで、オブジェクト (§2)・Int・Float・Bool・unit・variant (Option / Result / Ordering / Control とユーザー定義 enum のタグ値)・std: の不透明型 (§13.4)・Future (§10) がこれにあたる。どちらのエラーも右辺の型が静的に確定していれば hikari check が実行前に報告する (static-analysis.md §2.7)。

タプル destructure の左辺に _ を置くと、その位置の値を捨てる (束縛しない、§6.1)。a, _ := (1, 2) で第 2 要素を破棄でき、_ も 1 ポジションを占めるため要素数の厳密一致 (§3.5) は変わらない。_, _ := pair のように複数捨ててもよい。一方、スロット destructure { a, _ } := obj では _ はワイルドカードにならず、「slot 名 _ を抽出」する通常 lookup になる (名前で選ぶ側は要らない名前を列挙しなければ済むため、破棄概念が不要)。

スロット destructure: オブジェクトから複数 slot を同名のローカルに一括束縛する:

{ name1, name2, ... } := value

名前リスト (name-list)

{…} で囲んだ名前の列は、スロット destructure の左辺・import の対象・export の列挙
(§13.2) の 3 か所に現れる。これは独立した構文カテゴリであり、オブジェクトリテラル
(§2.1) でも slot-list (§1.3) でもない
。

  • import とスロット分解の中身は bare 識別子、または name: 型。export の領域別の項目は §13.2 と §17.4.2 に従う
  • 区切りは §1.3 と同じ (,・改行・;、連続・前後・末尾を無視)
  • bare 識別子は「束縛または公開する名前」を表す

match のレコードパターンと綴りが一致する。 名前リストは、match のアームに書く
レコードパターン { field… } (prelude.md §8.4) の束縛のみの部分集合である
— どちらも {…} の中に名前を並べ、対象のスロットを同名で束縛する。レコードパターンは
これに加えて値照合 name := v と型照合 name: T を書けるが、名前リストは束縛だけを行う。

{ a, b } := v                    # 文で束縛
match v { { a, b } => … }        # arm で束縛

紛れないのは末尾の代入演算子で決まるからである。 名前リストは宣言位置にしか現れないが、
その 3 か所のうち代入の左辺は式が来られる位置である ({ a, b } はタプル (a, b) を返す
ブロックとして読める。§2.1.1)。パーサーは { から識別子・型注釈・区切りだけを走査し、閉じ
括弧の次が := / = であるかを見て名前リストと判定する。識別子以外のトークンを見た瞬間に
打ち切る自己中断スキャンなので、通常のブロックリテラルは巻き込まれない。import /
export はキーワード直後で式が来られないため、この判別を要しない。slot-list 領域でも
エントリの形が閉じている (§2.1) ため、{ 始まりのエントリは名前リストしかありえない。

分解の綴りが、右辺のどの軸から取るかを示す。 裸のカンマ列はタプルや上に挙げた Sequence 実装の要素を
位置順に取り、{…} はオブジェクトのスロットから名前で取る。裸のカンマ列がタプルの括弧を
省いた形であることは適用 v(3, 5) (§3.5)・多値返却の末尾式 sum, diff (§11.2)・タプル
destructure a, b := t で一貫している。

  • 左辺は 0-pipe {} 形のみ。{ name1 | body } のような | 入り形は不可
  • 左辺の bare identifier は「抽出する slot 名 = 束縛するローカル名」として解釈
  • 右辺のオブジェクトに該当 slot が無ければ実行時エラー (§3.7 の未束縛 slot エラーと同種)
  • リネーム形 ({ x := value.foo, ... } 等) は不採用。リネームが必要なら x := value.foo を個別に書く
  • = 形は文の相だけに書ける。slot-list の相が宣言するのは immutable なスロットなので (下記「スロット/文の二相」)、slot-list 領域の {…} = expr は構文エラー
  • 左辺の {...} は要素を改行で区切ってもよい (カンマと改行のいずれも区切り。区切り規則は §1.3 と同じ)。名前が多いとき縦に並べられる:
{
  name1
  name2
  name3
} := value
import mod := "math.hika"
{ sqrt, log } := mod                  # mod.sqrt → sqrt, mod.log → log (immutable)
import { sqrt, log } := "math.hika"   # 中継無しに直接書ける (import 宣言形。§13.2)

スロット/文の二相: スロット destructure { a, b } := expr は name := value と同じ二相を持つ。
slot-list(ファイルトップレベルを含む)では、抽出した各名前を immutable なスロットとして宣言する。
右辺は宣言環境で一度だけ評価し、抽出した名前は後続の宣言・本体から参照できる。
通常のスロットと同じ公開規則が働く(§13.2)。
body ではローカルを導入する文になる。

import { Token } := "lexer.hika" はファイルトップレベル限定の宣言である(§13.2)。
導入した Token は後続スロットの型注釈や本体から参照できる。
type / enum の定義はファイルトップレベルと body に書けるが、明示した slot-list には書けない(§17.4)。

slot-list の相は := のみである。スロットの可変性は宣言形が決める(§4.1・§2.1)ので、スロット destructure が mutable なスロットを作る道は置かない — 可変スロットが要るなら mutable name := expr を個別に書く。

二相を持つのは スロット destructure({…} 形)のみ。タプル destructure a, b := expr は 文の位置でのみ使える — 内側リテラルの slot-list では a, b := expr が「必須スロット a + デフォルト付きスロット b := expr」という関数スロット構文(§2.1)と衝突するため、slot-list エントリにはならない({…} 形は { 始まりで曖昧が無い)。ファイルトップレベルは文の位置である — そこでは , がスロット区切りではなく多値構築を表すので(§1.3・§13.1)衝突が起きず、a, b := expr はタプル分解として読まれ、a と b はどちらもそのファイルのスロットになる。

リストの要素を括弧付きで分解する形 [a, b] := xs は持たない。 タプルや上に挙げた Sequence 実装からの分解は裸のカンマ列 a, b := xs が担っており(上記)、形を 2 つ持つ理由が無い。角括弧は List のリテラル(§7.4)なので、[a, b] := xs は List への代入として読まれ構文エラーになる — 要素が裸の識別子だけなら診断は a, b := ... を促す。match にも List パターンは無く(prelude.md §8.4)、「List は括弧付きの分解形を持たない」で言語全体が一貫している。

6.4 複合代入

lhs op= rhs は「読んで・演算して・書き戻す」(read-modify-write) の糖衣。対象演算子は算術 5 種 += -= *= /= %= のみ (論理 && / || の複合形は持たない)。

意味論 (place は 1 回だけ評価する):

  1. lhs の場所 (place) を 1 回評価する。obj.slot なら obj を、obj.[key] なら obj と key を左→右で 1 回ずつ評価する
  2. その場所から現在値 cur を読む
  3. rhs を評価する
  4. cur op rhs (= cur.op(rhs) のスロット呼び出し、§8.1) を計算する
  5. 結果を同じ場所へ = の規則 (§6.1 / §6.2) で書き戻す

ローカルでは i += n は i = i + n と完全に同一。op がスロット呼び出しに脱糖されるため、ユーザー定義型で + 等のスロットを実装していれば複合代入もそのまま効く。複合代入も他の代入族と同じく文の値は unit () (§6.1) — 書き戻した新値ではない (下の例のコメント → 5 等は変数 i の値であって文の値ではない)。

左辺は = と対称に、ローカル i / スロット obj.slot を取れる。= の意味論のみで、: を伴う宣言形 (:+= のような記法) は持たない。単一ターゲットのみで、分解形 (a, b += ...) は不可。

規則の帰結として現れる挙動:

  • 読みが先に起きるため、対象は既存で読める必要がある。未宣言ローカルへの i += 1 は undefined: i、未定義スロットへの複合代入はスロット無しエラーになる。名前を導入しない点は = と同じで (§6.1)、複合代入に宣言形 (mutable i += 1) は無い
  • 書き戻しは = の規則に従うため、immutable なローカル / スロットへの複合代入はエラー。スロット集合はリテラル宣言時に固定されるので (§2.4)、複合代入で新規スロットが生まれることは open / closed のどちらでも無い
  • 型エラー (例: true += 1) は内部の op 呼び出しからそのまま表出し、手書きの true + 1 と同一のエラーになる

複合代入演算子は字句上 1 トークンで、演算子記号と = は隣接必須 (i += n は可、i + = n は + と = に分かれて構文エラー)。これは || と | | の区別と同じ字句レベルの規則で、§8.3.1 の「空白は優先順位に影響しない」とは独立。

mutable i := 0
i += 5  # i = i + 5 → 5
i *= 3  # 15
i -= 1  # 14
i %= 4  # 2

obj := { mutable n := 10 |}!
obj.n += 5  # obj.n = obj.n + 5 → 15

cache := {}
cache.x += 2  # 静的エラー: slot は追加できない (no-such-member。§2.4 / §6.2)

mutable s := "a"
s += "b"  # "ab" (+ は String 連結)

7. 原始型と基本リテラル

すべての原始型はオブジェクトとして扱われる。内部表現は最適化のため特殊化されるが、ユーザーから見える意味論は統一されている。

型 リテラル例 備考
整数 0、42、-5、0xFF、0b1010、0o755、1_000 任意精度 (桁数上限なし。int64 に収まる値は内部で int64 表現に最適化)。型名は Int。基数 prefix (0x/0b/0o) と桁区切り _ は §7.1.1
浮動小数 3.14、0.5、1e10、1.5e-3 IEEE 754 倍精度 (float64)。型名は Float。リテラルは小数点の両側に数字を要求 (§7.1.1)。NaN / Inf は値として存在しうる (§7.1)
文字列 "hello"、"hi, ${name}"、"""...""" ダブルクォートのみ。要素単位は Unicode code point (rune)。エスケープ \n \t \r \\ \" \$ \u{…} のみ。補間 ${expr} あり。複数行は """..."""(§7.2)
Bytes (リテラル無し) 不変のバイト列。s.to_bytes! / std:fs の read_bytes(path) で得る。要素は Int 0〜255 (§7.2.2)
真偽値 true、false
unit () void を表す 0 要素タプル値 (§3.3)。print / each / else 無し when / 代入族の文 (§6.1) 等の戻り
リスト [1, 2, 3] 不変 (要素の差し替え l.0 = X 不可・長さも変わらない)。長さは生成時に決まる。組み立てには std:array を使う (§7.4)
タプル (1, 2, 3) 不変・固定長、多値返却の値。要素数 0 または 2 以上 (§3.3)
マップ — 言語の値ではない。キーで引く辞書は std:map を使う (§7.5)

7.1 数値の演算

二項算術 + - * / % ** と単項 - は 両オペランドの実行時型でディスパッチする。Int と Float は別の数値型であり、暗黙の型変換 (numeric coercion) は行わない。

  • Int op Int → Int (任意精度整数上で実行):
    • 除算 / はゼロ方向への切り捨て: 7 / 2 #> 3、-7 / 2 #> -3
    • 剰余 % は切り捨て除算の剰余であり a % b == a - (a / b) * b。符号は被除数に従う: -7 % 2 #> -1、7 % -2 #> 1
    • オーバーフローしない (任意精度。結果が int64 に収まらないときは内部表現が自動的に多倍長へ切り替わるが、値の意味論に表現の区別はない)
  • Float op Float → Float (float64 / IEEE 754 上で実行):
    • + - * / は実数演算。/ は実数除算 (7.0 / 2.0 #> 3.5)
    • 剰余 % は Int と同じく切り捨て除算の剰余で、符号は被除数に従う (5.5 % 2.0 #> 1.5、-5.5 % 2.0 #> -1.5)。被除数が Inf のときは NaN
    • オーバーフローは検知せず Inf になる (1e308 * 1e308 #> Inf)
  • 混合(Int op Float / Float op Int)は静的エラーである。
    暗黙変換は行わない。リテラルは 1.0 + 2.0、Int の値は n.to_float! + 2.0 のように明示する。
    Int.to_float は全域関数で Float を直接返す(下記「数値間の変換」)。
  • ゼロ除算 は Int / Float とも実行時エラー (Error、§16.2): a / 0、a % 0、x / 0.0、x % 0.0。-0.0 での除算も同じく実行時エラーである (§9.4 の全順序では -0.0 と 0.0 は別の値だが、除数としては両方が定義されない)
    • 除数は非ゼロと分かる式でなければならない。/ と % の除数は、非ゼロの定数(0 でない数値リテラル・その単項マイナス・それを束ねた不変な名前。算術は評価しない)か、静的型が NonZero(Int) / NonZero(Float) の式のどちらかでなければ静的エラーになる (static-analysis.md §2.11「除数の非ゼロ義務」)。条件で確かめた名前(if (d != 0) { a / d })はその枝で NonZero(Int) へ絞られる。それ以外の式は上流で宣言型を絞る (d: NonZero(Int) := …) か、式アスクリプションで実行時へ委ねる (a / ((n - 1): NonZero(Int)))。NonZero(T) は prelude が持つ (prelude.md)
    • ** の負指数は義務の対象ではない。同じ実行時エラーの族だが、被検査項が除数ではなく指数で、述語も v >= 0 と違う。まとめて閉じるかは別の判断に属する — 現状は実行時エラーのままである
  • 累乗 ** も両オペランドの実行時型でディスパッチする (右結合・優先順位は §8.3):
    • Int ** Int → Int は任意精度の整数べき (正確、オーバーフローなし): 2 ** 10 #> 1024、0 ** 0 #> 1。負指数 (2 ** -3) は結果が整数で表せず実行時エラー (Error、ゼロ除算と同格)
    • 結果の大きさには上限がある。 結果の絶対値のビット長が 3,321,928 (10 進でおよそ 100 万桁) を超えるときは、計算を終える前に実行時エラー (Error) になる。2 ** (2 ** 40) のように、指数が Int に収まっても結果は作れない大きさになるためで、上限が無いと確保で落ちるか止まらなくなる。底が 0・1・-1 のときは答えが指数に依らず小さいので、どんな指数でも答える (1 ** (2 ** 100) #> 1)
    • Float ** Float → Float は実数べき: 2.0 ** 0.5 #> 1.4142135623730951。負指数は分数を返す (2.0 ** -1.0 #> 0.5)。整数値の指数なら負の底も定義される ((-2.0) ** 3.0 #> -8.0) が、負の底に小数指数を与えると実数解がなく NaN を値として返す ((-2.0) ** 0.5 #> NaN、is_nan! で判定)。オーバーフローは Inf
    • 混合(Int ** Float / Float ** Int)は他の算術と同じく静的エラー

標準関数が受理する Float の値域は各関数の仕様が定める。乱数の区間は std/random.md §3 に従う。

数値間の変換 (to_float / to_int) — 変換が失敗しうるかは「変換先で値を表現できるか」で決まり、方向で非対称である:

  • Int → Float (Int.to_float) は全域関数 — Option を返さず Float を直接返す。任意精度 Int を float64 へ最近接丸めし、float64 の有限範囲 (約 1.8e308) を超える巨大 Int は Inf を返す (Float 算術のオーバーフローが Inf になるのと同じ扱い、上記)。失敗しないので unwrap 不要 (n.to_float! * pitch)。範囲超えを検出したいときは結果を is_finite! で判定する。
  • Float → Int (Float.to_int) は Option を返す — 有限値は 0 方向へ切り捨てて Some(Int) (Int は任意精度なのでオーバーフローしない)。NaN / Inf は None。Int で表現できない値の不在を表す (Bytes の to_string! が不正 UTF-8 で None になるのと同じ、§7.4)。
  • String → Int / String → Float は Option — 文字列解析であり ("42".to_int! #> Some(42)、非数値は None)、上の数値間変換とは別枠。

Float は NaN / Inf を値として持ちうる (オーバーフロー由来・Int.to_float の範囲超え・(-2.0) ** 0.5 など)。これらの等価・順序の扱いは §9.4、判定メソッド (is_nan! ほか) は prelude.md を参照。

7.1.1 数値リテラル

基数 prefix (整数のみ): 整数リテラルは 0x (16 進) / 0b (2 進) / 0o (8 進) の prefix を取れる。prefix は小文字のみ (16 進桁 A–F は大小両方)。prefix 無しは 10 進で、先頭 0 も 10 進 (0755 は 755)。基数 prefix は整数のみで Float には付かない。不正な桁 (0b2 等) や桁なし (0x) は構文/評価エラー。整数リテラルに桁数の上限はない (int64 に収まらない値も任意精度の Int になる)。

桁区切り _: 整数・Float とも桁区切り _ を数字の間に書ける。先頭・末尾・連続・記号隣接 (小数点) は不可。基数 prefix 直後の 0x_FF のみ例外的に許容。例: 1_000_000、0xdead_beef、1_000.5、2.5e1_00。位置違反 (1__0 / 1000_) はエラー。

位置アクセスとの区別: 基数 prefix・桁区切りは数値リテラルの内部にのみ現れる。メンバー/位置アクセスのドット直後 (obj.0) は常に 10 進整数で、prefix を適用しない。

Float リテラル: Hikari は . をスロットアクセス (§3.2) に多用するため、Float リテラルは 小数点の両側に数字を要求し、かつ ドット直後の数字は常に整数と読むことで曖昧性を断つ。

  • Float になる形: 3.14、0.5、1e10、2.0E8、1.5e-3 (digits.digits 形、または指数 e/E 付き)
  • 3. (末尾ドット) / .5 (先頭ドット) は Float にしない: 3. は 3 . (整数のメソッド/位置アクセス 3.foo の頭)、.5 は . 5 として字句解析される
  • メンバー/位置アクセスのドット . の直後に来る数字は常に整数 (位置アクセス) として読む。したがって連鎖位置アクセス obj.0.0 は「位置 0 の要素の位置 0」を意味し、Float リテラルはメンバーアクセスのドット直後には現れない。t.1・xs.0・m.0.1 は位置アクセスのまま壊れない
  • 表現不能な大きさのリテラル (1e400 など) は 構文エラー (パース時に検出)
  • 指数のみ (1e10) も Float。整数が欲しい場合は指数表記を使わない
3.14        # Float
0.5         # Float
1e10        # Float (指数のみ)
3.0 / 2.0   #> 1.5
[1.5, 2.5]  # Float のリスト
3.          # `3` `.` …  (Float ではない)
xs.0        # 位置アクセス (Float ではない)
xs.0.0      # 連鎖位置アクセス (Float ではない。ドット直後は整数)
0xFF        #> 255    (16進)
0b1010      #> 10     (2進)
0o755       #> 493    (8進)
1_000_000   #> 1000000 (桁区切り)
0755        #> 755    (先頭 0 も 10進)

7.2 文字列の演算

  • "hello" + "world" で連結。+ は String + String のみ。他型との + はエラー(整形は §7.2.1 の補間を使う)

メソッド (length / split / splitn / slice / contains / index_of / replace / trim / to_lower / to_upper / starts_with / ends_with / to_int / code / to_bytes / Sequence の method など) は prelude.md §4 に集約。

要素アクセス: String は Sequence (§17.5) を rune (Unicode code point) 1 個単位で実装する。s.0 / s.[i] は §7.4 / §3.10 の規則どおりに動き、長さ 1 の String を返す。範囲外は実行時エラー (List と同じ規則)。length は rune 数を返す。

immutability: String は immutable。s.0 = "x" / s.[i] = "x" は静的エラー immutable-slot-assign。新しい値が必要なら slice / 連結 / map で新規 String を組み立てる。

エスケープ: 文字列リテラル中で使えるエスケープは次のみ。\n(改行) \t(タブ) \r(復帰) \\(\) \"(") \$($, §7.2.1) と \u{HEX}(Unicode code point)。\u{HEX} の HEX は 1〜6 桁の16進で、0〜0x10FFFF のコードポイントを表す (\u{41} → "A"、\u{1f600} → 😀)。範囲外・サロゲート範囲 (0xD800〜0xDFFF)・空の \u{}・{} 欠落・不正な16進はコンパイルエラー。code / to_char の定義域と一致する (prelude.md §3・§4)。これ以外の \x 等の未知エスケープもエラー。単一行 "..." の中に生の改行が現れるとエラー(改行を含めたい場合は下記の複数行 """...""" を使う)。

inspect が返すデバッグ表現は、文字列をこのエスケープ規則で出力する — 非表示文字 (制御文字など) は \n \t \r や \u{…} で見えるように表記し、出力をそのまま Hikari ソースに貼り戻せる (往復可能)。

複数行文字列 """...""": 生の改行を含む文字列は """ で囲む。開き """ の直後には改行が必須で、閉じ """ は自分の行に単独で置く。閉じ """ の行頭にある空白 (インデント) を接頭辞とみなし、本文の各行から同じ空白を取り除く (dedent)。本文の各行は、空白のみの行を除き、その接頭辞と厳密に一致する空白で始まらなければならずエラーになる。開き直後の改行と閉じ直前の改行は値に含めない。本文中に単独の " や "" が現れても終端せず、そのままリテラルの文字として扱う (""" の並びだけが終端する)。エスケープ \n \t \r \\ \" \$ \u{…} と補間 ${expr} は単一行 "..." と同じ規則で使える (cooked)。

msg := """
    Hello, ${name}
    Line "quoted" ok
    """
# msg == "Hello, ${name の展開}\nLine \"quoted\" ok"

シングルクォート (U+0027) は未使用: この記号は文字列リテラルの区切りではなく、他のどの構文にも割り当てられていない完全に未使用の記号である。ソース中に現れると字句エラーになる。

7.2.1 文字列補間 ${...}

文字列リテラル中に ${expr} を書くと、expr を評価して文字列として埋め込む。

  • 例: "hello, ${name}"、"残高: ${n + 50}"、"sum: ${f(x, y)}"
  • 評価値の文字列化:
    • String: そのまま / Int: 10進文字列 / Float: 最短往復形 — 小数点も指数も含まない形になるときは .0 を補う (2.0 は "2.0")。指数形になる値はそのまま指数で書く (1e21 は "1e+21")。どちらも Int の 10 進表記とは読み違えない (§7.1.1 の指数付きは Float である)。NaN/Inf はそのまま — Inf は符号を付けて -Inf と書くが、NaN は符号を出さない (負の NaN も NaN である。順序では別の位置に並ぶ。§9.4) / Boolean: "true"/"false" / unit (): "()"
    • List / Object / Function 等のオブジェクト: Inspect() 相当 (人間可読のデバッグ表現)
  • 補間内に書ける式は { } ダブルクォート " を含まないもの に限定
    • OK: ${name}、${x + 1}、${f(x, y)}、${a.b.c}
    • NG: ${ { x | x+1 }(5) }、${ "inner" } (関数本体や文字列リテラルが必要なら事前に変数代入する)
  • リテラルの ${ を書くには \${ でエスケープ。単独の $ (後ろが { でない) はそのまま
    • "\${100}" #> "${100}"、"$50" #> "$50"

7.2.2 Bytes

Bytes は不変のバイト列。生成は s.to_bytes!、std:fs の read_bytes(path) (std/fs.md)、または Int の List からの構築関数 bytes(list) による。Bytes リテラル構文 (b"..." 等) は持たず、range と同じく構築関数で作る (bytes/Bytes は range/Range と対)。

  • 要素アクセス: b.0 / b.[i] は Int (0〜255) を返す (String と違って長さ 1 値ではない)
  • length: バイト数 (rune 数ではない)
  • Sequence (§17.5): each / map / filter / fold / first / last 等が見る各要素は Int (0〜255)
  • 変換: b.to_string! は UTF-8 デコードして Some(String)、不正 UTF-8 なら None (to_int! の失敗仕様と同じ — 不在は Option)
  • 構築: bytes(list) は Int の List を Bytes に詰め替え Option(Bytes) を返す。全要素が 0〜255 の Int なら Some(Bytes)、0〜255 外を含むと None、非 Int 要素・非 List 引数は静的エラー、空 List は Some(空 Bytes)。to_string! の逆方向
  • immutability: Bytes は immutable。b.0 = N / b.[i] = N は静的エラー immutable-slot-assign
  • 演算子: + 等は持たない (b1 + b2 は operator '+' not defined for Bytes and Bytes)。連結は List 側で行う — to_list で開いて伸ばし、bytes() で確定する

メソッド一覧は prelude.md §5 に集約。

7.3 タプル

不変・固定長。t.0、t.1 でアクセス。t.0 = X は静的エラー immutable-slot-assign。要素数 0 または 2 以上 (§3.3)。

タプルの用途: 多値運搬専用である。
v((3, 5)) はタプル 1 個を適用し、未束縛スロット総数が 2 個のときに分解して束縛する(§3.5)。
多値返却(末尾式 sum, diff / return(a, b)。§11.2)と分解代入(a, b := v(...))にも使う。

タプルとリストは内部表現が別 (タプルは固定長で immutable な値型として残す)。「データとして保持・引き回す」用途ではリスト (§7.4) を使う。

7.4 リスト

リストは [e1, e2, …] と書く組込型である。Int / String / Bytes / Tuple と同じレイヤーに属し、オブジェクト (§2) ではない — slot-list も body も持たず、スロットを宣言できない。

  • 要素は ,・改行のいずれかで区切る (§1.3 の (...) と同じ規則。; は区切りにならず、末尾 , は不可)
  • 要素アクセスは整数添字 xs.0 / xs.[i] で、頭から 0, 1, 2, … と番号付ける
  • 空リストは []。空オブジェクト {} とは別の値で、[] == {} は false である (§9.1)
  • 要素の型は均質である (静的型は List(T)、§17.2)。異種の並びが要るならタプル (§7.3) を使う

リストは不変である。 要素の差し替え (xs.0 = X / xs.[i] = X) は静的エラー immutable-slot-assign で、長さも生成後に変わらない。長さは静的に決まるとは限らない — src.map { … } の結果長は入力次第である。この点がタプル (§7.3) との差で、タプルは長さが静的に決まり要素型が異種でよい代わりに、map / filter / fold を持たない。

要素を変えた結果が欲しければ map で新しいリストを組み立てる。組み立てや任意添字への O(1) 散在書き込み (累積器・DP テーブル・グリッド更新・in-place sort 等) が要る場合は、可変 scratch ハンドルを frozen で List に確定する std:array (std/array.md) を使う。可変性はそのハンドルの内部に閉じ、外へ出るのは不変な List である — std:map の ScratchMap → frozen() → InsertionMap (§7.5) と同じ二段構えである。

import arr := "std:array"

xs := [1, 2, 3]
xs.0  #> 1
xs.length!  #> 3
doubled := xs.map { x | x * 2 }
doubled  #> [2, 4, 6]
out: List(Int) := arr.collect { a |  # 期待型で要素型を決める
  xs.each { x | a.push (x * 10) }
}
out  #> [10, 20, 30]
xs := [1, 2, 3]
xs.0 = 99  # 静的エラー: immutable-slot-assign (リストは不変)

リストは Sequence を実装する (§17.5)。length / is_empty / each / map / filter / fold / find / any / all / count / first / last / positions / has_position / to_list と整数添字 xs.N がこれにあたる。同じ interface を String (§7.2)・Bytes (§7.2.2)・range (§7.6) が実装しており、リストを舐める場所へそのまま差し込める。タプル (§7.3) は位置アクセスと length を持つが、Sequence 全体は実装しない。各 method の意味 — is_empty が length! == 0 と同値であることを含む — は prelude.md §6 を参照。

Sequence は全ての値に生えるわけではない。オブジェクトは整数添字の並びを持たないので (§2.1)、{ x := 1 |}.length! は解決できない。オブジェクトが持つ自己記述の method は names / values / has_name (§2.5) である。

7.4.1 オブジェクトとリストの + 演算

リスト同士の + は順序を保って連結する。 結果の要素型は、両辺の要素型の合流規則で決まる。

[1, 2] + [3, 4]  #> [1, 2, 3, 4]

オブジェクトの + は、受け手の静的型が宣言する演算子スロットへの適用である。
スロットのシグネチャに従って引数と結果を検査する。
データレコード・コンストラクター・関数のスロットや body を合成する組込演算は持たない。
受け手の静的型が + を宣言しない場合、値が型に現れない + スロットを持ちうることを根拠に受理しない。
中置・ドット形・複合代入は同じ演算の解決規則に従う(§8.1)。
結果のアスクリプションを付けても、成立を示せない演算の呼び出しは受理しない。

p := { + := { rhs: Int | rhs + 10 } |}
p + 2  #> 12
{ x := 1 |} + { y := 2 |}  # 静的エラー: 左辺の型は + を宣言しない
{ x: Int | x + 1 } + { y: Int | y * 2 }  # 静的エラー: 関数の組込合成はない

既存スロットの値を更新した複製は copy(overlay)(§9.5)で作る。
別のスロット集合を持つ値は、必要なフィールドを明示したレコードリテラルで構築する。
実行時のキーで値を増やす辞書は std:map(§7.5)で扱う。

user := { name := "Aki", age := 30 |}
updated := user.copy { age := 31 |}
identified := { id := 1, name := user.name, age := user.age |}
updated.age  #> 31
identified.id  #> 1

7.5 マップ

マップは言語の値ではなく標準ライブラリの型である。 キーで値を引く辞書が要る場合は std:map を使う (std/map.md)。

import m := "std:map"

h := m.insertion.of [("Content-Type", "application/json"), ("X-Trace", "42")]
h.get "Content-Type"  #> Some("application/json")
h.keys()  #> ["Content-Type", "X-Trace"]   (挿入順)

std:map は 3 つの型を提供する。SortedMap は Comparable (§9.4) をキーにとりキー昇順で反復する不変な値型、InsertionMap は任意の値をキーにとり (== で同一性判定・§9.1) 挿入順で反復する不変な値型、ScratchMap は InsertionMap と同じキー同一性を持つ可変な scratch ハンドルで frozen() で InsertionMap に確定する。破壊的更新が要る辞書は ScratchMap で組み立てて確定させる — std:array が List に対して立つのと同じ二段構えである (§7.4)。集合が要る場合は std:set の OrderedSet (std/set.md)。

オブジェクトのスロットはマップではない。 スロット集合はリテラル宣言時に固定され (§2.4)、実行時のキーで引く手段も無い (§3.10) — スロットは静的に決まった record のフィールドであり、辞書ではない。m.names() / m.values() (§2.5) は自身のスロットを列挙する自己記述の手段であって、キーで引く経路は与えない。

この分離が本質的なのは、境界の理由が「辞書であること」ではなく「幅構造型の record に静的型が知らないスロットが書かれうること」だからである (§17)。値の型が均質だと分かるマップとして型が付けば、その危険は無い。

7.5.1 record と map の使い分け

欲しいもの 使うもの
フィールド名が書いた時点で決まっている構造体 オブジェクトのスロット ({ x := 1, y := 2 |})
キーが実行時に決まる / 識別子として不正な文字を含む std:map の InsertionMap / SortedMap
上記で破壊的更新が要る std:map の ScratchMap
添字が実行時に決まる均質な列 List(T) (読みは xs.[i]、§3.10)
上記で任意添字への O(1) 書き込みが要る std:array の Array (§7.4)

7.6 range (遅延シーケンス)

range(start, end) は 半開区間 [start, end) の整数列を表す遅延シーケンス値を返す。range は prelude が束縛する大域名 (if / while と同格の組み込みオブジェクト) であり、専用リテラル構文 (.. 等) は持たない。

  • 引数: start / end とも Int 必須の 2 引数。非 Int はランタイムエラー。range(5) は 2 引数に満たないため部分適用 (§3.5) となり、シーケンスにはならない
  • 半開区間: range(0, 10) は 0,1,…,9 (end を含まない)。range(0, xs.length()) が全インデックスを舐め、positions / 0-base 添字と整合する
  • 空 range: start >= end のとき長さ 0 (エラーにしない)。range(5, 5) も range(10, 0) も length() == 0、each は一度も回らず、map は []
  • 遅延: 要素は要求時に算出され、巨大な範囲でもリストを実体化しない。実体が欲しいときは to_list

要素は実体化しない: range は要素を保持しないが、Sequence (§17.5) を実装する。論理添字 i の要素は start + i*step で、リストを舐める場所にそのまま差し込める。map / filter は List の同名メソッドと同じく List を eager に返す。

range method: length, first, last, each, map, filter, fold, positions, has_position, r.N 添字 (Sequence)。加えて range 固有に step, reverse, to_list (いずれも新しい range / List を返し合成可能)。各メソッドの形と意味は prelude.md §6.5 に表でまとめる。

step と reverse の直交: 向きは reverse、刻みの大きさは step(n) (n は正の Int、step(0) / 負数はエラー) が担う。降順 2 刻みは range(0, 10).step(2).reverse()。負の step は持たない (向きと大きさを 1 引数に混ぜないため)。

位置と値の区別: range(5, 10) の要素値は 5,6,7,8,9 である。
positions() は添字 [0,1,2,3,4] を返す。List と同じく位置と値は異なる。
first / last は要素の有無を Option で返す。

r := range(5, 10)
r.0  #> 5
r.length!  #> 5
r.first!  #> Some(5)
r.last!  #> Some(9)
r.positions!  #> [0, 1, 2, 3, 4]

型語彙としての Range: range 値の型は型語彙 Range。r.matches(type Range) で判定でき、x: Range と注釈にも書ける (§17.4)。step / reverse 派生も同じ Range。

8. 演算子と中置記法

8.1 中置になれる名前と、三つの等価な呼び出し記法

中置になれるのは演算子表 (§8.3) にある名前だけである。表にある名前は三つの記法で書けて、意味は同じ。

1 + 2                  # 中置
1.+ 2                  # ドット+スロット名、引数は並置
1.+(2)                 # ドット+括弧

"a" -> 1               # 中置 (ペア構成。§8.3・§2.5)
"a".-> 1               # ドット+スロット名、引数は並置
"a".->(1)              # ドット+括弧 — いずれも (a, 1) を返す

one := { value := 1, add := { other: Int | value + other } |}
one.add 2              # add は表に無いのでドット形のみ
one.add(2)

統一規則として:

  • receiver op arg は、op が演算子表にあるとき receiver.op(arg) の糖衣。
    op の解決は receiver.op と同一規則 — receiver のスロット、無ければ型メソッドレジストリ。
    外側スコープの同名関数は引かない (= recv.op がエラーなら recv op arg もエラー)
  • f x は関数適用 (並置)。常に適用であり、中置に読み替えられることはない
  • どちらであるかは構文解析の時点で決まる。受け手の値を見て解釈が変わることはない — one add 2・xs map f のように任意の識別子を中置に使う記法を持たないのはこのためで、並置と同形になると「適用か中置か」が受け手の値に依存し、構文解析だけでは決まらなくなる

受け手のスロットは値の種別より先である。 中置は receiver.op(arg) の糖衣なので、スロットの引き方はドット形と同じ — 受け手が本体を持つ形 ({ slot-list | body }) でも、宣言したスロットがあれば中置はそこへ届く。組込の判定 (数の算術・§7.4.1 のリストの +・§9.1 の既定の等価・§9.4 の順序) は、受け手がそのスロットを宣言していないときの受け皿である。スロットが未束縛のまま (コンストラクターの部分適用) なら値を持たないので、そのときも組込の判定へ落ちる。

8.2 ユーザー定義オペレーター

スロット名は記号 (+、==、< 等) も識別子 (add、map 等) も自由に使える。+ などのオペレーターをユーザー定義型に実装するには、その名前のスロットを定義するだけ:

type Vec := { x: Int, y: Int |}

vec := { inner_bound me,
  x: Int := 0
  y: Int := 0
  + := { other: Vec |
    { x := me.x + other.x, y := me.y + other.y |}: Vec
  }
|}

v1 := vec(1, 2)!
v2 := vec(3, 4)!
v1 + v2  # v1.+(v2) → { x := 4, y := 6 |}

自己参照名は inner_bound でなければならない (§4.2.1)。inner が指すのは派生元 — この例では x / y が未束縛のままの vec そのもの — なので、self.x は実引数ではなくデフォルト値 0 を読んでしまい、v1 + v2 が { x := 3, y := 4 |} になる。演算子スロットが読みたいのは束縛を写した自分の側であり、それに届く名前は inner_bound だけである。

vec(1, 2) は + スロットを未束縛のまま残す部分適用なので、完成値を得るには明示 kick (!) が要る (§3.6)。

演算子のスロットは効果を持たない。 演算子が呼ぶスロット — 算術の + - * / % **、ペア構成の ->、等価の ==、順序の compare、単項 - の導出元の negate(以下、演算子のスロット)— に置く関数は、効果を 1 つも持てない(§17.9。Mut と Susp を含む 8 ラベルのどれも)。効果を伴う演算が要るなら、演算子ではなく名前を付けたメソッドとして定義する。

  • なぜか: 演算子は式のどこにでも現れ、== と compare は入れ子の等価 (§9.1) や並べ替え・探索のように組込の内側からも呼ばれる。呼ぶ位置ごとに効果を追うと、組込が要素のスロットを呼ぶ位置まで効果を通す規則が要る。スロットを置く位置で効果を持たないことを求めれば、どこで呼んでも効果は増えない。
  • スロットへ入るどの値にも掛かる。 リテラルに書いたデフォルト値・構築で渡す実引数・可変スロットへの書き込み・copy の overlay のどれで置いた関数も、効果を持たない関数型として照合する。効果を持たないと示せない値(型変数の値・EffectConduit で受けたパラメーター)も置けない。スロットの型を書くときも、結果型に効果は書けず、EffectConduit にもできない。静的検査が報告する (static-analysis.md §2.9)。
  • どのリテラルのスロットにも掛かる。 ファイルのトップレベルもファイルオブジェクトのスロットであり (§13.1)、本体を持つ値でも中置は宣言したスロットへ届く (§8.1)。

8.3 演算子表 — 優先順位と結合性

この表が中置になれる名前の全てである。表は閉じており、書き手が項目を増やすことはできない。表に無い名前を中置位置に置くことはできず、並置はすべて関数適用として読む (§8.1)。

外側 (弱) から内側 (強) の順:

  1. 代入: =、:=、+= -= *= /= %=
  2. ペア: -> (2-tuple。a -> b ≡ (a, b)。左結合)
  3. 論理OR: ||
  4. 論理AND: &&
  5. 比較: ==、!=、<、<=、>、>=
  6. 加減: +、- (二項)
  7. 乗除: *、/、%
  8. 単項: - (受け手の negate スロットからの導出。§8.6。※論理否定 ! は廃止 — §8.5)
  9. 累乗: ** (右結合)
  10. 関数適用 (並置 f x。左結合)
  11. ドット (.、.[])、postfix call (!、())、postfix 失敗 bail (?、§16.5)

同一レベルは左結合。step!? は (step!)? (postfix の左結合)。-> も左結合: 1 -> 2 -> 3 は (1 -> 2) -> 3 ≡ ((1, 2), 3)。

-> と式アスクリプション : (§17.1) の関係: : は本表に含めていない (式アスクリプションとして §17 で別掲、二項演算子・関数適用より弱く非結合)。-> はその : より強く、|| より弱い (ASCRIBE < PAIR < OR)。

字句: -> は - と > が隣接した単一トークン (<=/>=/!= などと同じ扱い)。a - > b (間に空白) は -> トークンにならない。a->b ≡ a -> b、a - b (減算) とは曖昧性なく区別される (§1.2)。

** (累乗) はこの表で唯一の右結合二項演算子である。2 ** 3 ** 2 は 2 ** (3 ** 2)。単項 - より強く結合し -2 ** 2 は -(2 ** 2)、指数側 (右オペランド) は先頭の単項マイナスを取れる (2.0 ** -1.0 は 2.0 ** (-1.0))。

これにより:

f x + g y       ≡  (f x) + (g y)          # 関数適用 > 記号オペレーター
f x y           ≡  ((f x) y)              # 並置は左結合 (curry)
1 + 2 * 3       ≡  1 + (2 * 3)             # 標準的な算数優先順位
2 ** 3 ** 2     ≡  2 ** (3 ** 2)          # 累乗は右結合
-2 ** 2         ≡  -(2 ** 2)              # 累乗は単項マイナスより強い
2 * 3 ** 2      ≡  2 * (3 ** 2)           # 累乗は乗除より強い
"n" -> a + b    ≡  "n" -> (a + b)         # -> は || より弱く、値側に演算式を括弧なしで書ける
["a" -> 1, "b" -> 2] ≡ [("a", 1), ("b", 2)]  # , は区切りであり演算子ではない。常に -> より緩い
1 -> 2 -> 3     ≡  ((1, 2), 3)            # -> は左結合

8.3.1 空白と結合優先順位

トークン間の空白の有無は §8.3 の優先順位・結合性に影響しない。空白はトークンの区切りとしてのみ機能する。

f(x)     ≡  f (x)     ≡  f ( x )           # 呼び出し
a+b      ≡  a + b                          # 二項演算
f{ b }!    ≡  f { b }!                         # juxtaposition + postfix call
obj.m()  ≡  obj.m ()                       # メソッド呼び出し

これにより、フォーマッターや手作業の整形によって意味が変わることはない。

注: || (短絡 OR) と | | (パイプ 2 個) のように、字句解析でトークン分割自体が変わるケースは §2.1 の規則であり、本節とは独立。

8.4 短絡評価 (例外)

&& と || だけは言語組み込みの特例として短絡評価する。メソッド呼び出しに脱糖しない。

false && expensive()  # expensive() は呼ばれない
true || expensive()  # expensive() は呼ばれない

これは「すべてはオブジェクト呼び出し」原則からの意図的な逸脱である(もう 1 つは宣言順束縛の左辺のワイルドカード _、§6.3)。理由: 短絡を関数化するには右辺をブロックで包む必要があり、a.&&({b}) のような記述は実用上負担が大きいため。

&&/|| の被演算子は Bool 必須 (§9.3、非 Bool は静的エラー)。&& は左が false なら左を、true なら右を返す。|| は左が true なら左を、false なら右を返す (短絡評価)。いずれも結果は Bool。

8.5 論理否定 ! の扱い

! は postfix 呼び出し短縮 (§3.2) に使うため、prefix の論理否定としては廃止する。論理否定は .not() メソッドで表現:

cond.not()      # 否定
cond.not!       # postfix 短縮形 (同義)
!cond           # NG (構文エラー)
cond!           # 全く別: cond を引数なしで呼ぶ

!= (不等) は単一トークンとして字句解析されるため、! 単体との曖昧性はない。

8.6 メソッド糖衣でない記法の一覧

Hikari の中心思想は「演算子はスロット呼び出しの中置記法」だが、いくつかの記法はメソッド呼び出しに脱糖されない。それらは原則に対する例外ではなく、原則そのものを支える土台 (構文構造・スコープ・遅延評価) である。実装やレビュー時の判断基準として、本節で一覧化する。

記法 区分 役割 参照
&& 短絡論理演算 被演算子は Bool 必須。左が false なら左、true なら右を返す (右辺を遅延評価)。a.&&(b) には脱糖しない §8.4
|| 短絡論理演算 被演算子は Bool 必須。左が true なら左、false なら右を返す (右辺を遅延評価)。a.||(b) には脱糖しない §8.4
:= 宣言 ローカル宣言・スロット宣言。既定は immutable で、mutable 前置 (§1.4) なら mutable。シャドウ不可。スロットアクセスへの := は常に静的エラー (slot 追加不可) §6.1, §6.2
= 代入 既存の mutable な束縛・スロットの更新のみ。名前もスロットも導入しない §6.1, §6.2
op= 代入糖衣 複合代入 += -= *= /= %=。lhs op= rhs は place を 1 回評価して cur op rhs を書き戻す read-modify-write。op 部分は演算子スロット呼び出しに脱糖、代入部分は非糖衣 §6.4
, 構造 リスト的並列性 — タプル要素・スロット列・引数列・多値返却 §2.1, §3.3
; / 改行 構造 シーケンス (最後の値が返り値) §1.3, §11.1
| 構造 スロット宣言と本体の区切り ({ slot-list | body }) §2.1
キーワード 構文形 予約語=宣言・照合の構文形 (§1.4)。type / enum / match / import / export / loop / conduit / inner / inner_bound §1.4
f x (並置) 呼び出し 関数適用。中置糖衣 recv op arg の 脱糖の着地点でもある。並置そのものは常に適用で、中置に読み替えられることはない §3.1, §3.2
. アクセス スロットの取り出し (呼び出しではない) §3.2
.[] アクセス 動的な要素の取り出し (key 式の評価値 (Int) で List・String・Bytes・range・タプルを引く。スロットは引けない)。recv.[k] は呼び出しではない §3.10
() 呼び出し / 構造 タプル化、または引数なし呼び出し §3.3
! (postfix) 呼び出し () の短縮形 (v! ≡ v())。prefix の論理否定としては廃止 §3.2, §8.5
? (postfix) 失敗 bail Result / Option の失敗 variant で関数から脱出する return の構文糖。成功は中身に開く §16.5
!= 比較 字句的に単一トークン。意味は (a == b).not() と等価だが、! と = への分解ではなく != のまま扱う §9.1

算術 (+ - * / % **)、比較 (==)、ペア構成 -> は receiver.name(arg) への糖衣である。
ユーザー定義型の公開した同名スロットで挙動を差し替えられる (§8.1)。
-> は全値が baseline を持つ universal method でもある (§2.5)。
ここでの - は二項の減算であり、単項 - は negate から導く(下記)。

なぜこの分類が必要か:

  • 短絡 (&& / ||) は右辺の遅延評価が本質。関数化すると a.&&({b}) のようなブロック包みを毎回強いることになり、実用上の負担が大きいため特例とする (§8.4)。
  • 束縛・代入 (:= / =) はスコープを操作する構文要素であり、スロット呼び出しでは表現できない。
  • 構造区切り (, / ; / |) はパース時に構造を作るためのもので、値ではない。
  • 呼び出し / アクセス記法 (並置 / . / () / !) は、糖衣の着地点を提供する側であり、それ自体が糖衣ではない。
  • != は字句解析の都合 (! 単体との曖昧性回避) で単一トークン化されているが、意味的には == の派生である。

導出形を持つ演算子は差し替えられない。 順序演算子 < <= > >= は compare から (§9.4)、!= は == から (§9.1)、単項 - は negate から (下記) 導かれるので、受け手がその綴りのスロットを持っていても参照しない。差し替えたいときは導出元の compare / == / negate を定義する。導出形の綴りでスロットを宣言した形は静的検査が報告する (static-analysis.md §2.9) — 知らせずに無視すると書いた側がエラーに気づけないためである。ただし - は例外で報告しない — 二項の減算スロットとして正当な綴りなので、宣言だけを見て単項を差し替えるつもりだったかは判別できない。

単項 - の導出元は negate である。 -a は受け手の negate スロットを引き (引数なしで呼ぶ)、無ければ値の種別でディスパッチする (§7.1 の数値だけが応答し、それ以外は実行時エラー)。- スロットが差し替えるのは二項の減算 a - b だけで、単項はそこへ届かない — 二項のスロットは引数を 1 つ取るので、単項を 0 引数呼びとして同じスロットへ低レベル化すると arity が合わないためである。引くのは受け手が宣言したスロットだけで、ランタイム層が実装する組込メソッドは引かない — std:time の Duration.negate (std/time.md §1) は綴りが同じだが組込なので -dur は種別のディスパッチへ落ち、dur.negate! と書く。

単項だけが届かないのではなく、算術演算子そのものが不透明 std 型に載らない。 dur + dur も dur - dur も同じく実行時エラーで、加減算は add / sub メソッドで書く (std/time.md §1・std/decimal.md §1 がそれぞれ「+ / - 演算子はオーバーロードしない」と定める)。載るのは順序と等価だけで、そちらは compare から導く導出形なので不透明な std 型でも組込の比較で決まる (§9.4・§9.1)。符号反転を持つ std 型は Duration.negate と Decimal.neg の 2 つで綴りも揃っていないので、導出元 1 つでどちらも引く形にはならない。

type Vec := { x: Int, y: Int |}

vec := { inner_bound me,
  x: Int := 0
  y: Int := 0
  negate: {| Vec } := { { x := 0 - me.x, y := 0 - me.y |}: Vec }
|}

v := vec(1, 2)!
n := -v  # v.negate! と同じ
println n.x  #> -1

9. 等価性と真偽値

9.1 == のセマンティクス

== は値等価を原則とする。可変ハンドルと range 値には参照同一性を用い、それ以外は値の中身が等しいかで判定する。

可変ハンドル Array・ScratchMap は内容で比べず、参照同一性を返す。
同じハンドルの別名同士だけが等しく、同じ内容の別ハンドルは等しくない。
!= はその否定である。内容を比較するには frozen で不変な値へ確定する。

  • 原始型 (整数・浮動小数・文字列・真偽値・バイト列・unit) は構造等価: 値そのものが等しいかで判定
    • 1 == 1 #> true、"a" == "a" #> true、() == () #> true、3.14 == 3.14 #> true
    • 異型同士の比較は false: 1 == "1" #> false、0 == false #> false、1 == 1.0 #> false (Int と Float は別型 = 別の値。暗黙変換しない §7.1)
    • Float の構造等価は IEEE 非準拠: NaN == NaN #> true (同一ビット = 等値)。IEEE 流の「NaN は自身と不等」が要る場合は is_nan! を使う (prelude.md)
  • オブジェクト (リスト / タプル / マップ / データオブジェクト / 関数として使う値) と Variant (Option / Result / Ordering・enum) は再帰的構造等価: 次の条件がすべて一致すれば等しい (組込 Variant は Tag + payload を比べる)
    • 公開・非公開のすべての通常スロットが持つ値(関数スロットも含む。関数を呼び出して比べることはない) — 束縛済みならその値、無ければデフォルト値。List・タプルでは要素を順に比べる
    • body のトークン列 — 空白・改行・コメントは無視する。自己参照名 (inner / inner_bound) の綴りは正規化してから比べる。比較は字句に限る (§9.1.1)
    • body が捕獲した外側の値 — 再帰的に同じ規則で比べる
    • [1, 2, 3] == [1, 2, 3] #> true、(1, 2) == (1, 2) #> true、{ x := 1 |} == { x := 1 |} #> true (別インスタンスでも中身が同じなら true)
    • 自己参照名の綴りは等価に影響しない — { inner self, x := 1 | self.x } と { inner me, x := 1 | me.x } は等しい
    • ユーザー定義 enum は宣言の所属・タグ・実体化した型引数も比較する。異なる宣言の同名タグは不等である。型引数は正規化した型の同一性で比べ、透過的別名は同じ型として扱う。状態に現れない型引数も比較する。組込の Option / Result / Ordering / Control は各組込のタグと payload の規則に従う。
  • 異型 (リスト vs タプル等) は false。長さ・スロット集合が違えば false
  • 循環参照しても停止する (比較中のペアを等しいと仮定する bisimulation)
  • 中断を許さないシグネチャであることを示せない呼び出しは静的エラーである。
    実行時にも比較中の中断を検出するガードを持つ。これが発火した場合は、その地点で panic する。
    導出 == はこの停止を false にしない。

!= は == の否定として実装される (a != b ≡ (a == b).not())。

参照同一性 reference_equals: == (値等価) とは独立の軸として、同一インスタンスかを問う universal method reference_equals (§2.5) を持つ。a.reference_equals(b) は a と b が同じインスタンスを指すとき true、構造が同じでも別インスタンスなら false。可変オブジェクトの別名 (aliasing) 判定 — 「a を書き換えると b も変わるか」 — に使う。

  • xs := [1, 2]; ys := [1, 2]; zs := xs のとき xs == ys #> true・xs.reference_equals(ys) #> false・xs.reference_equals(zs) #> true
  • 原始型 (整数・文字列等) は不変で固有のインスタンスを持たないため reference_equals は意味を持たない (1.reference_equals(1) は実装上のボックス同一性に依存する)。値の一致を見たいときは == を使う
  • 受け手が reference_equals スロットを定義していればそれが優先される (他の universal method と同じ)

9.1.1 body の比較が字句である理由

body の一致はトークン列の一致で判定する。正規化するのは自己参照名の綴りだけで、それ以上は行わない。

  • 意味を見ない。同じ入力に同じ出力を返すか (外延一致) は停止性に帰着するので判定できない
  • 畳み込み・簡約を挟まない。正規化の強さが等価を左右すると、最適化器を触るたびに値の等価が変わる。字句に限れば、判定はパース時に確定し実行系の都合から独立する
  • 自己参照名だけ正規化する。inner-name はデータスロットではなく等価に影響しない (§4.2) と定めている以上、書き手が self と me のどちらを選んだかで等価が割れてはならない

省略形と、それを綴った形の一致は等価の仕事ではない。 body が自リテラルの inner_bound 名への裸の参照 1 つだけのとき、その綴りは値を組む前に body を省略した綴りへまとめられる (§2.2)。等価が突き合わせるときには既に同じものになっているので、「省略した body」という架空のトークン列を作って比べる必要はない。§2.2 の約束が等価の一致だけでなく検分表示にも及ぶのはこのためである。

代償として、外延的に同じでも綴りが違えば別の値になる。次はいずれも { x, y |} と等しくない:

{ inner_bound b, x, y | { b }! }                # ブロックに包んで起動している
{ inner_bound b, x, y | b: T }                  # アスクリプションが付いている
{ inner_bound b, x, y | (if c { b } { b })! }   # 同じ値を返すが綴りが違う

区切り記号だけの違いで区別を作らないこと。 冗長な括弧 ({ … | (b) }) と 1 引数呼び出しの括弧 ({ … | f(x) }) も綴りが違う以上は別の値だが、hikari format は抽象構文木から印字を組み直すため、構文木に残らないこれらの区切りを正準形へ寄せる (format.md)。整形を通したソースにこの区別は残らない。上の 3 つのように構文木に残る綴りで区別すること。

捕獲まで見るのは省けない。 同じ綴りの body でも捕獲が違えば別の値だからである:

mk := { n: Int | {| n } }
mk 1 == mk 2  #> false   (body の綴りは同一だが、捕獲した n が 1 と 2 で違う)

9.2 不在の判定 (Option)

不在は nil ではなく Option で表す。first / last / index_of / to_int / to_string などは値があれば Some(v)、無ければ None を返す。判定は match の値コンストラクターパターンか述語メソッドで行う:

  • match o { Some(x) => use(x), None => default }
  • o.is_some() / o.is_none()、o.or(default)、o.unwrap! (None なら panic)

Hikari は形式的なラッパー (Option) を持つ方針へ転換した。if などの void 戻りは unit () であり不在ではない (§9.3 は Bool 必須のため () を条件にはできない)。

9.3 真偽値文脈 (Bool 厳格)

if、when、while、&&、|| の条件は Bool 必須。非 Bool 値を条件に与えると静的エラーになる。truthy / falsy は持たない。

  • 整数の非ゼロ判定は n != 0、コレクションの非空判定は xs.length! > 0、Option の在判定は o.is_some() のように 明示的に Bool を作る。
  • if (xs) {…} のような暗黙の真偽判定は静的エラーになる。
if(true,  { "t" }, { "f" })    #> "t"
if(false, { "t" }, { "f" })    #> "f"
if(0,     { "t" }, { "f" })    # 静的エラー: Bool でない
if((),    { "t" }, { "f" })    # 静的エラー: Bool でない

9.4 順序比較 (compare と < <= > >=)

等価 == (§9.1) と独立した順序の軸。比較可能な値に全順序を与え、その正準を universal method compare (§2.5) が担う。

  • compare: a.compare(b) は Ordering (Less ∣ Equal ∣ Greater、prelude.md §13) を返す。Less=a が前、Greater=a が後、Equal=同順位。
  • compare スロットは効果を持たない (§9.1 の == と同じ規則)。順序演算子 < / <= / > / >= は compare から導かれるので (下記)、中断しうると比較を含む式すべてが中断点になる。
  • 原始型の全順序 (組込 compare):
型 順序
Int 数値順
Float 全順序 (NaN を含む)。下記参照
String 辞書順 (Unicode code point 単位)
Bool false < true
Unit 単一値。().compare(()) は常に Equal
  • < <= > >= は compare から導出: a < b ≡ a.compare(b) == Less、a > b ≡ == Greater、a <= b ≡ != Greater、a >= b ≡ != Less。Int は観測上 §7.1 の従来挙動と一致する。
  • Float の順序は全順序 (IEEE 非準拠): compare が必ず Less/Equal/Greater を返す invariant を保つため、NaN にも定位置を与える。順序はビット列を単調なキーへ写したもので、負の NaN < -Inf < … < -0.0 < 0.0 < … < Inf < 正の NaN となる (-0.0 と 0.0 も別の位置に並ぶ)。これにより sort・Comparable が NaN 混入時も破壊されない。IEEE 流の「NaN との比較は全て false」が要る場合は is_nan! で明示判定する。表示は NaN の符号を出さない (§7.2.1 の表示規則) ので、NaN を含む列を並べ替えると両端に同じ NaN の字面が現れる。どちらの側かは字面では分からず、x < 0.0 のように順序で問うと決まる (負の NaN は -Inf より小さいので真、正の NaN は偽)。
  • 乱数の逆区間の判定も Float の全順序を使う: std:random の float_range(lo, hi) が該当する。
  • 異型の順序比較は静的エラー。== は異型を false とするが(§9.1)、順序比較では比較できる型を静的に要求する。1.compare("a") / 1 < "a" は受理しない。Int と Float も別型であり、1 < 2.0 / 1.compare(2.0) は静的エラーになる。暗黙変換はせず(§7.1)、n.to_float! < 2.0 と明示変換する。
  • overload (ユーザー型の自然順): compare スロットを定義した object は順序を持つ。a.compare(b) はレシーバーの compare スロットへ dispatch され (§9.1 の == overload と同じ機構)、< <= > >= もそれ経由で効く。等価 == はこの compare から導出される (§9.1 整合規則): a == b ≡ a.compare(b) == Equal。compare と == スロットの同居は禁止され、両者の Equal 一致は構造的に保証される (型定義側に委ねず、ズレを作れない)。
3.compare 5  #> Less
"b".compare "a"  #> Greater
3 < 5  #> true
"ab" < "abc"  #> true   (辞書順)

# ユーザー型は compare 一個で順序一式が揃う (self は inner-name §4.2)
v := { inner self, x := 1, compare := { o: { x: Int |} | self.x.compare o.x } |}

Comparable: 順序を持つ値、すなわち 原始型 (Int/Float/String/Bool/Unit) または受け手の型の値 1 個を受けて Ordering を返す compare スロットを持つ object。Comparable は組込の特別な型ではなく、構造的 interface { compare |} として prelude が定義する型である (§17.5。compare のベースラインが原始型に効き、object は自前の callable compare で応答する)。ユーザーも type MyOrd := { compare |} で同値の型を定義できる。型 Comparable で v.matches(type Comparable) と判定できる (§17.4)。sort (prelude.md §6) は要素が Comparable であることを要求する。

9.5 複製 (copy / Copyable)

等価 (§9.1)・順序 (§9.4) と同じく全値に生える universal method copy (§2.5)。x.copy! は x と同じ現在状態を持つ独立したコピーを返す。「今あるものと同じ物をもう一つ」という複製であって、無からの構築とは別の操作 — 引数を取った初期化や副作用つき構築が要るときは factory (本体付き 0 引数ブロックで毎回 fresh を返すイディオム) を使い、copy はそれを置き換えない。

default 式を再評価しない: copy はスロットの現在値を引き継ぐのであって、リテラルの default 式 (§12) を評価し直さない。ゆえに default 式に埋めた副作用 (採番・時刻取得・リソース確保) は copy では走らない。これが「複製」と「構築」を分ける観測点でもある。

メソッドの自己参照名の再束縛: object を複製するとき、自身の inner_bound 名 (§4.2.1) を捕捉するクロージャは、新インスタンスへ束縛し直したクロージャとして作り直される。スロットの値そのものであるクロージャも、派生ごとのデフォルト値 (§4.2.2) が作ったラッパーの中のクロージャも同じである。これにより複製先のメソッドは複製先の状態を触る。捕獲されるのが inner_bound なのは、可変スロットへ書き込めるのが束縛を写した完成値だけだからである (§2.2 / §4.1) — 派生元を指す inner (§4.2) から可変スロットへ書くことはできない。

counter := { inner_bound b, mutable count := 0, inc := { b.count += 1; b.count } |}!
counter.inc!  #> 1
counter.inc!  #> 2
d := counter.copy!  # count=2 を引き継ぎ、inc 内の b は d を指す
d.inc!  #> 3
counter.count  #> 2   (状態は独立)

初期化の途中の複製は、束縛前の名前を共有する。 派生ごとのデフォルト値が作ったクロージャを初期化の最中に copy すると、そのクロージャが捕獲する inner_bound はまだ束縛されていない。後ろで宣言する兄弟を捕獲したクロージャを、デフォルト値の評価の最中に copy したときも同じである (§5)。このとき copy は束縛前の名前を複製せず、元のクロージャと共有する。初期化が済めば両方から束縛済みの値が見えるので、複製したクロージャも完成後に呼べば元のクロージャと同じ値を読む。

wrap_copy := { run: {| Int } | { run := run.copy! |} }
a := { inner_bound me, x := 1, nested := wrap_copy {| me.x } |}!
a.nested.run!  #> 1
b := { nested := wrap_copy {| later }, later := 2 |}!
b.nested.run!  #> 2

深さは可変性が決める: copy が新しく作り直すのは可変な構造だけで、透過的に不変な部分はそのまま共有する — 不変な値は変異によって別名 (aliasing) を観測できないため、共有しても安全である。

  • 可変な object = 可変 (=) スロットを 1 つ以上持つ。→ 作り直し、全スロット値を同じ規則で再帰的に copy する。
  • 透過的に不変 = 到達可能なグラフに可変 object を一切含まない (原始型、全スロットが := かつ closed で不変な referent しか持たない object、plain list など)。→ そのまま共有する。
  • List (§7.4) とタプル (§7.3) の各要素へも同じ規則で降りる。

したがって防御的コピー (可変状態の分離) が成立する一方、大きな不変データは複製されない。可変スロットに不変な referent が入っていれば共有され、:= スロットに可変な object が入っていればその referent は作り直される — 判定はスロット宣言の可変性(mutable の有無)ではなく referent 自身の可変性で決まる。

循環と内部エイリアスの保存: copy は同一性マップを用いたグラフコピーで、1 回の copy 内で同じ可変インスタンスに複数経路から到達してもコピーは 1 つに集約する。これにより循環構造も終端し、元にあった内部別名関係もコピー後に保存される。

reference_equals との関係 (§9.1): y := x.copy! のとき、x の可変部分と y の対応部分は reference_equals が false (独立)、共有された不変部分は true になりうる。counter.copy!.reference_equals(counter) は counter が可変 object なので false。

上書き: 受け手が copy スロットを定義していればそれが優先される (他の universal method と同じ §8.6)。深いコピーを強制したい型や不透明リソースを抱える型は自前の copy を定義する。overlay 形 (下記) をサポートしたい型は、override 側も overlay を受け取る 1 引数 (デフォルトは空 object) として定義する。overlay を宣言しない 0 引数 override に overlay を渡すとアリティエラーになる。override は overlay を高々 1 つ受け、受け手の型を返す関数でなければならない (§2.5)。

引数つき複製 (copy-and-update): copy は overlay を 1 つ受け取れる。x.copy! は overlay 無しの純粋複製、x.copy(overlay) は複製と同時に overlay のスロットの値だけを差し替えた複製を返す。overlay を省いた copy! は空 overlay と等価。新しい構文は導入せず、overlay は既存の object リテラルで渡す (空 overlay は {})。

p := { x := 1, mutable y := 2 |}
q := p.copy { y := 20 |}  # { x := 1, mutable y := 20 |} — y は可変のまま
p.copy!  # 純粋複製 (overlay 無し)
p.copy { z := 9 |}  # panic — z は p のスロットに無い

既定の非空 overlay は、直接の受け手または overlay が名目的な所属か非公開の通常スロットを持つとき禁止する。
公開スロットだけの差し替えも同じで、既知なら restricted-structural-operation、不明なら操作前に panic する。
空 overlay と通常の copy! は複製条件に従って使える。公開した独自の copy はその関数の契約に従う。

コピーは公開・非公開のすべての通常スロット、所属・タグ・具体化した型引数、定義元のアクセス情報を保持する。
コピー前に取り出した操作は元の値を参照し続け、コピー先の操作の inner_bound だけをコピー先へ再束縛する。
inner は派生元を指す。非公開の非 Copyable 資源も到達グラフの検査対象である。

透明な record の overlay の規則:

  • 差し替えるのはスロットの値のみ。overlay に受け手のスロットに無いキーがあれば panic (バグ層、§16.2)。
  • スロットの可変性は受け手側を保持する: 受け手の mutable x := 1 (可変) は overlay 後も可変、x := 1 (不変) は不変のまま。overlay リテラルの綴りは値の運搬にのみ使われ、スロット種別 (可変性・必須/デフォルトの別) を書き換えない。
  • 土台の複製規則 (可変部の作り直し・透過的に不変な部分の共有・メソッドの self 再束縛・default 式を再評価しない) は overlay の有無で変わらない。差し替えた値はそのまま複製に入る。
  • shape は変えない: overlay はスロットを増やさない。別のスロット集合を持つ値は、新しいレコードリテラルで構築する (§7.4.1)。

Copyable: 複製できる値を表す。v.matches(type Copyable) は、v が原始型・object・list・関数などの通常値なら true、意味ある複製を定義できない不透明な可変ホスト資源は false。copy の受け手が静的に非 Copyable 型なら静的エラーになる。複製の途中で到達する非 Copyable な実体は、複製操作の前提違反として実行時に止める。順序を持つ値が限られる Comparable と違い、Copyable は inspect と同様ほぼ全値を覆う。Copyable も組込の特別な型ではなく、構造的 interface { copy |} として prelude が定義する型である (§17.5。copy のベースラインが非 Copyable 以外の全値に効く)。

非 Copyable なのは不透明で「可変」なホスト資源だけである。 判定は「ホストの可変状態を持ち、作り直しても同じものにならないか」で決まる。不透明であることそのものは理由にならない — 不透明でも不変な値は複製に意味があり、Int を複製するのと変わらないためである。 ユーザーが宣言する不透明型 (§17.4.2) の値は enum の値であり、ホスト資源ではない。Copyable かどうかも copy の振る舞いも、enum の値と同じく中身に従う。

区分 prelude / std の型
非 Copyable Future (§10)・std:array の Array・std:map の ScratchMap・std:fs の File・std:net の Conn・std:db/sqlite の Db と Tx
Copyable 上記以外のすべて。std の不透明型では std:time の Instant / Date / Time / Duration・std:decimal の Decimal・std:map の InsertionMap / SortedMap・std:set の OrderedSet・std:test の Trial

この集合は 3 つの位置で同じでなければならない — v.matches(type Copyable) の照合・copy の静的検査と複製時の到達グラフの検査・spawn と std:parallel の捕獲検査 (到達グラフに非 Copyable があれば panic。prelude.md §9.9)。3 つが別々の集合を持つと、同じ値が「複製できないのに複製される」形が生まれる。実行系による違いも無い。

10. スケジューラー意味論

if / when / while / break / continue / return などの制御構造、および fork / sleep / now / wait_any などの並行性プリミティブは、予約語ではなく prelude が束縛した特殊オブジェクト である。「特殊」とは実装が組み込み (ホスト言語で書かれている) という意味のみで、評価規則は他の関数と同じ — 引数は呼び出し前に評価され、ブロックを渡せばその評価は遅延される。API の詳細は prelude.md §8 (制御構造) と §9 (非同期評価) を参照。値の等価・型・レコードの形で分岐する唯一のディスパッチ構造 match は前置の特殊オブジェクトでも method でもなく 予約語の専用構文で (§1.4。match subject { pattern => body }、API は prelude.md §8.4、型テスト matches §17.4 は別系統の universal method)、break / continue の意味論は §18.1、return (脱出) は §18.2 を参照。

本節では fork / sleep を介して非同期評価を行う際のスケジューラーの意味論を規定する。

10.1 フロー切り替え規則

  • Hikari プログラム実行中は単一の論理フローのみアクティブ
  • フロー切り替えは次の中断点でのみ起こりうる:
    • (a) 未完了 Future を ! で呼び出したとき
    • (b) 現フローを中断する組み込み関数を呼んだとき (現状は sleep と wait_any)
  • 上記以外のコードは絶対に他フローに割り込まれない (普通の関数呼び出しの ! や resolve 済み Future への !、now などは中断しない)。データ競合は構造上発生しない
  • 切り替え順序・公平性は実装定義
不変条件 (実装形態に依らず維持する): 可変状態を共有しうるフロー同士は同時に走らず、その間の切り替えは中断点に限る。ゆえにデータ競合は構造上表現できず、Hikari はロック・mutex・atomic をユーザー語彙に持たない。並列実行は、可変状態を共有しない隔離されたフローに限る。同期辺は Future の resolve→await のみであり、resolve 前の全書き込みは await 後の読み出しから見える (happens-before)。プリエンプティブな切り替え (中断点以外での割り込み) は導入しない。

隔離フローの並列実行: 上の不変条件は「可変状態を共有しうるフロー同士」を対象とする。可変状態を共有しない隔離フローは同時に走ってよい。隔離フローは spawn (prelude.md §9) で作る — spawn は捕獲した可変状態を複製 (§9.5 の copy) して呼び出し元から切り離し、子フローを専用のスケジューラー領域で並列に評価する。親子はどちらも自分の中断点規則 (本節) に従うが、可変状態を共有しないためデータ競合は生じない。親子間の唯一の同期辺は子の Future の resolve→await であり、resolve 前の子の全書き込みは await 後の親の読み出しから見える (happens-before)。子の結果値は resolve 時点で完了した子ヒープ内に閉じており、親へは参照のまま渡る (複製しない)。fork (§9.1) は隔離しない協調フローで、可変状態を共有し並列化しない。

束縛前の捕獲は拒む: spawn の呼び出し時点で、捕獲から到達する名前が束縛前と静的に分かる場合は静的エラーとする。静的に判定できない場合も、捕獲から到達する名前の箱がまだ束縛されていなければ、子フローと Future を作らず、その呼び出し地点で panic する。通常の copy が初期化の途中の箱を共有する規則 (§9.5) は、別フローへの捕獲には適用しない。静的に移譲と判定された捕獲も同じく拒む。

child := spawn { later }  # 捕獲時点では later が束縛前なので静的エラー
mutable later := 1

移譲した捕獲の隔離: 上の「複製して切り離す」は、静的に移譲と判定された捕獲でも変わらない (prelude.md §9.9)。変わるのは非 Copyable な実体に達したときの振る舞いだけで、複製が失敗する位置を移譲は共有して進む (§17.8「複製と別フローへの捕獲」)。親がその実体へ届かないことは消費追跡が保証するので、共有しても経路は増えない。それ以外の可変な構造は移譲でも作り直されるため、多重度型の可変な内部を指す別の束縛が親側に残っていても、子の書き込みは親から観測できない。

wait_any(futures) は sleep と同じ中断点であり (規則 b)、futures のいずれかが最初に解決するまで現フローを中断し、解決した入力 Future 自身を返す (外側の Future で包まず単層)。呼び出し時点で複数が既に解決済みなら中断せず入力 List の最小位置の Future を返す。負けた入力 Future は解決状態を変えず、root 完了時には §13.3 の未解決 Future として扱われる。

root リテラル本体の評価が完了した時点で未解決の Future が存在する場合の扱いは §13.3 を参照。

行き詰まり: 走れるフローが無く、時刻待ちもホストの I/O の待ちも無いのに root が完了していない (互いを待つフロー、自分の Future を待つフロー) とき、処理系は root が待っている ! の地点を位置として panic する。本文は deadlock: no runnable flow で、位置の後に待った側の呼び出しの経路が続く (§16.2)。

10.2 失敗の伝播

fork / spawn した別フローの「失敗」は §16 の三層モデルにそのまま乗る。専用の例外機構や Future 固有の失敗チャネルは持たず、失敗は次の 2 種に分かれて別々の層で扱う。

  • 回復可能エラー (§16.1): block が Err(e) を 返す 場合。これは Future が運ぶ通常の値であり、f! が Err(e) を返して呼び手が match する。組込の input / std:fs ほかブロッキング I/O はこの形で resolve 値を Result に揃える (prelude.md §9.4)。スケジューラーは関与しない。
  • panic (§16.1 のバグ層): block 評価中に panic した場合 (型不一致・ゼロ除算・Err への unwrap! 等)。panic は await の ! エッジに沿って、それを取り出した消費側フローへ伝播する。v := f! は block の結果を呼び手フローに引き込む点であり、引き込んだ結果が panic なら その ! の地点で呼び手フローが panic する — あたかも呼び手自身がその式を評価したかのように振る舞う。そこから先は §16.1 どおり呼び手フローの上位へ自動伝播し、トップレベルで停止する。

この規則から派生する振る舞い:

  • 複数回の !: 「同一 Future への複数回 ! は同じ値を返す」(prelude.md §9.1) を panic にも広げる。panic も値と同じく保持され、各 ! が同じ panic を決定的に再現する (block 本体評価は 1 回)。
  • sibling のキャンセル: 消費側フローが panic してトップレベルで停止すると、§13.3 により他の未解決 Future が一括キャンセルされる。fork 失敗時の sibling 停止に追加規則は要らない。
  • wait_any との関係: panic で解決した Future も「解決済み」として勝者になりうる。wait_any 自身は panic せず勝者を返し、panic は勝者を ! で取り出した時に上記規則で surface する。
  • 未 await の panic: root リテラル本体の評価が完了するまで、panic した Future を一度も ! しなかった場合、その panic は surface せず、プログラムは正常に終了しうる (await されて初めて消費側フローに伝播するため)。これは §13.3 の「未解決 Future は放棄」と整合する (panic で解決済みだが未消費の Future も、消費側が無い以上いずれのフローも停止させない)。バグの握り潰しを避けるため、処理系は root 終了時にこの未消費 panic を診断として stderr へ報告する (終了コードは変えない)。

バイトストリームへの全量書き込みでは、空のデータも書き込みの完了として扱う。
ハンドルの使用条件と結果の形は、各操作の契約に従う。

10.3 キャンセル

Future の .cancel! (prelude.md §9.8) と root 完了時の一括キャンセル (§13.3) は、いずれもフローへ「キャンセル」を要求する。協調スケジューラーでは走行中フローは中断点でしか制御を手放さないため、キャンセルは中断点で観測される (プリエンプティブではない)。

  • 未開始のフロー (token 未取得) は block を評価せずキャンセルされる。
  • 中断点 (§10.1 の (a) 未完了 Future への !、(b) sleep / wait_any) で待機中のフローは、その中断点でキャンセルを検知してフローを中断する。中断は §10.2 の panic と同じ unwind 経路で fork 境界まで戻り、その Future を panic (Error) で解決する。
  • 中断点を持たない CPU バウンドなフローはキャンセルを観測できず最後まで走る。
  • キャンセルで解決した Future は、意図的な停止であってバグではないため、§10.2 の「未 await の panic」診断の対象にしない。

標準ライブラリが返す Future は、操作ごとの契約に従ってキャンセルされる。
その Future を待つフローのキャンセルが操作にも及ぶかどうかは、各モジュールの仕様が定める。

10.4 取り出し ! と関数型

Future への ! (≡ ()) は、そのフローの結果を取り出す操作である。Future はスロットを持たない本体付きの値なので、取り出しは明示 kick (§3.6) と同じ綴りで書ける。通常の kick とは次の 3 点が違う。

  • 中断点になる。 未完了なら現フローを中断する (§10.1 の (a))。
  • 本体は 1 回しか評価しない。 何度 ! しても同じ値を返し、panic も同じ panic を再現する (§10.2)。
  • 引数を取らない。 f(x) は実行時エラーである。

Future(T) は関数型ではない。 実行時には ! で呼べるが、型の上では関数型 { T } の位置へ渡せない。渡せるとすると 2 つの約束が崩れる。

  • 効果: 関数型は結果型に書いた効果しか持たない (§17.9)。{ T } と宣言した位置へ中断しうる値が入り、Susp を書いていない関数が中断する。
  • 複製: 関数値は Copyable だが Future は Copyable でない (§9.5)。関数型として受けた値が複製できないことになる。

関数として渡したいときは { f! } とブロックで包む。包んだブロックは ! の Susp を本体に持つ関数値なので、Susp を許す関数型の位置へ渡せる。

run := { th: {| Effect(Int, Susp) } | th!: Effect(Int, Susp) }
f := fork { 1 }
run { f! }  #> 1
run { 2 }  #> 2

11. シーケンスと多値返却

11.1 本体内の式列

本体は式と文 (§1.5) の列であり、; または改行で区切る。改行がある場合 ; は省略可能。最後に評価された要素の値が返り値 (文なら unit ()。§6.1)。

v := { x: Int |
  a := x + 1
  b := x * 2
  a + b  # これが返り値
}

11.2 多値返却

失敗値のエラーモデル全体は §16 (Result) を参照。

最終位置の , 区切りは多値 = タプル化を意味する。

v := { x: Int, y: Int |
  sum := x + y
  diff := x - y
  sum, diff  # タプル (sum, diff) を返す
}

; (シーケンス) と , (多値) は明確に異なる:

  • ; / 改行: 順次評価、中間値は破棄、最後の値だけ返す
  • ,: タプル構築、すべての値を保持して返す

多値返却は値の運搬一般に使う (失敗運搬専用ではない)。失敗は Result で表す (§16)。不在は Option (§9.2)。

parse_amount := { s: String |
  match s.to_int! {
    Some(n) => Ok(n)
    None => Err({ kind := "invalid", message := "金額が不正です: ${s}" |})
  }
}

12. デフォルト値の評価

スロットのデフォルト値式はリテラル評価時にeagerに、宣言順 (上から下) に1 回だけ評価される。例外は inner_bound 名を含むデフォルト値 (派生ごとのデフォルト値) で、リテラル評価時には評価せず、派生のたびに評価する (§4.2.2)。

make := {
  { x := compute() |}
}
make()  # compute() 1 回走る
make()  # compute() もう1 回走る (新しいリテラル評価)

a := { x := compute() |}  # ここで compute() 走る
a.x  # 走らない (キャッシュ済み)
a.x  # 走らない

デフォルト値の式から兄弟を読むときは inner-name を使う (裸の名前でも前の兄弟は読める。後ろの兄弟については §5 の「即時に評価する位置」):

p := { inner self,
  x := 10
  y := 20
  sum: Int := self.x + self.y  # 宣言順なので x, y は初期化済み
|}
p.sum  #> 30

デフォルト値から inner-name で読めるのは、その位置より上で宣言したスロットだけである。self.x はその兄弟スロットの評価済みの値そのものに解決する。次の 4 つは静的エラーである (static-analysis.md §2.7)。

  • 前方参照 — まだ評価していない兄弟を読む形 ({ inner self, sum := self.y, y := 20 |})
  • スロット以外を引く形 — universal method (self.inspect!)・型メソッドなど、完成したオブジェクトでなければ答えられない読み
  • inner-name の裸の出現 — me := self のように半端なオブジェクトそのものを持ち出す形
  • inner_bound 名の出現 — 束縛を写した自分 (§4.2.1) をデフォルト値の式そのものから読む形。そのデフォルト値は派生ごとのデフォルト値になるが (§4.2.2)、評価している最中の派生値はまだ組み上がっていない。デフォルト値が作る関数リテラルの中の出現は読みではなく捕獲なので、この制限の外にある

いずれもデフォルト値を評価している最中のオブジェクトは半端で、そこから読める値を言語は定めないからである。読みたいものが上の兄弟なら inner-name を介さず bare な名前でも書ける (sum := x + y) — スロットリストの中では兄弟が名前で見えるため (§6.3) で、inner-name はこの 2 通りの綴りのうち明示的な方にあたる。

body 領域と、デフォルト値が作る関数リテラルの中では制限が無い。 どちらもデフォルト値の評価より後に走るので、inner-name は完成したオブジェクトを指す。

q := { inner self,
  x := 10
  get := {| self.x }  # 関数の本体。呼ぶのは構築の後なので self は完成している
|}
q.get!  #> 10

12.1 デフォルト値は派生をまたいで共有される

デフォルト値が確定するのはリテラル評価時に 1 度だけなので、同じコンストラクターから 2 回派生させると (§4.2.1 の語法で、派生とは実引数を束縛して新しい値を作ること)、デフォルト値が可変な値であれば両方が同じものを掴む。派生ごとのデフォルト値 (§4.2.2) は派生のたびに評価するので、この共有は起きない。

c := { mutable box := { mutable n := 0 |}! |}
a := c!
b := c!
a.box.n = 2
b.box.n  #> 2   — a と b は同じ object を掴む

これは可変スロット (mutable) に限らず、{ box := { mutable n := 0 |}! |} でも同じである。デフォルト値が指す先が可変であれば、スロット自体の可変性とは無関係に共有が観測できる (可変性は shallow。§4.1)。リストは不変なので (§7.4) この形にはならない — 共有が観測できるのは可変スロットを持つ object と std:map の可変ハンドルである。

派生ごとに新しい値が要るなら、デフォルト値ではなく実引数で渡すか、body 付きの factory ({ { mutable n := 0 |}! }) で毎回リテラルを評価する。hikari lint の shared-mutable-default がこの形を勧告する (lint.md)。

12.2 注釈の無いデフォルト値スロットの型

型注釈を書かないデフォルト値スロット name := d の型は、デフォルト値 d の静的型である。
実引数はその型へ静的に代入できなければならず、デフォルト値と実引数を実行時には照合しない
(static-analysis.md §2.4)。

o := { b := 10 |}
(o 20).b  #> 20
o "s"  # エラー: b の型は Int
f := { x := 1 | x + 1 }
f 2  #> 3
f 2.5  # エラー: x の型は Int

型を広く取りたいスロットには注釈を書く (b: Any := 10)。

enum のタグのデフォルト値は、その enum の型として扱う。c := Color.Red の位置には Color.Green も渡せる。

[] と None は、期待型が無ければそれぞれ List(Never) と Option(Never) になる。
再代入できるローカルとスロットの初期値に Never が残る場合は静的エラーである。
mutable acc: List(Int) := [] のように期待型を注釈する
(static-analysis.md §2.10)。
再代入しない xs := [] は List(Never) の値として正しい。

関数のパラメーターも本体を省略したオブジェクトのスロットも、デフォルト値の型に含まれる Never を保つ。
そのため xs := [] に非空の List を、m := None に Some を渡すことはできない。
要素を持つ値も受け取るには、スロットの注釈か関数型の期待型で要素型を与える。

command := { name: String, args: List(String) := [] | [name] + args }
command("pwd")!  #> ["pwd"]
command("git", ["status"])  #> ["git", "status"]

型不明のデフォルト値は受理しない。何でも受け取るスロットには Any を明示できるが、
その値への操作には型の判定が要る。

ファイルのトップレベルのスロットは呼び出しで上書きされないので (§13.1)、この規則が効く場面は無い。

13. トップレベルと評価モデル

13.1 ファイルは暗黙のオブジェクトリテラル

Hikari プログラムはファイル単位で書く。各ファイルは body を省略したオブジェクトリテラル { slot-list |} (§2.2) として扱われる。宣言を置く領域と文を置く領域の区別は無く、ファイル全体が 1 つの slot-list 領域である。

ファイルレベルの構造:

  • 暗黙の inner-name 無しの { slot-list |} リテラル。ファイルレベルでは inner 宣言を持たない (§4.2 の inner-name は内側リテラル専用)
  • 領域は 1 つである。 ファイルレベルに | は現れず、書くと構文エラーになる (§2.1)
  • トップレベルに直接並ぶ宣言がスロットになる。 name := expr は immutable スロットを、mutable name := expr は mutable スロットを宣言し (§6.1)、どちらもファイルオブジェクトの member になる (§13.2)。name = expr は既存の束縛への代入であって名前を導入しないので、member を増やさない。入れ子リテラルの中の宣言はそのフレームのローカルであってスロットにならない
  • ファイルレベルの slot-list には文を書ける。 副作用のための式と代入族の文 (§6) を宣言に混ぜてよく、評価は記述順・値は捨てる。これがファイルレベルにだけ在る規則であり、内側リテラルの slot-list では構文エラーである (§2.1)。下の区切りの違いはこの規則の帰結で、独立した規則ではない
  • デフォルト値を持たないスロット宣言 (name: Type だけの形) はファイルレベルでは静的エラーである。ファイルオブジェクトはロードで完成するため、未束縛スロットを埋める呼び出し側がいない (下記「ファイルはコンストラクターにならない」)
  • スロット集合は固定である (§2.4)。slot 生成はトップレベル宣言時のみ
  • 宣言と名前解決の規則は内側リテラルの slot-list と同一 (§2.1, §5, §6.1)。区切りだけは body 領域の規則に従う — 文を受ける領域なので , はスロット区切りではなく多値 (タプル) 構築を表し、スロットは改行 (または ;) で区切る (§1.3)。したがって裸のタプル分解 a, b := expr (§6.3) もトップレベルに書け、a と b はどちらもスロットになる
  • shebang #!... は 1 行目に置ける。行コメント・空行は何行あってもよい
  • ファイル先頭に mode を宣言する行は無い。 #{...} はどの位置でも通常の # 行コメントである (§1.1)。#{ hikari } / #{ hikari |} で始まる既存ファイルは、その 1 行がコメントとして読まれるだけで意味は変わらない (hikari lint が残存を勧告する。lint.md)

評価モデル:

ファイルのロードは暗黙リテラルの評価そのもの:

  1. トップレベルの要素を記述順に評価する。スロット宣言はデフォルト値を eager 評価して確定束縛し (§12)、文は評価して値を捨てる
  2. そのオブジェクトを返す (スロットは確定済み)

ファイルはコンストラクターにならない。 未束縛スロットを残したリテラルは呼び出しで残りを埋めるコンストラクターになるが (§2.2)、ファイルレベルのスロットはロードで確定束縛されるため、ファイルオブジェクトは常に完成値である。

実行は「この暗黙リテラルを 1 回ロード (= 評価) する」ことに等価である。最外側フレームは、その中で定義された関数がレキシカル環境として参照する間、生存し続ける。

ロードは完走するか、オブジェクトを生まずに終わるかのどちらかである。 トップレベルの return (§18.2) と、トップレベルへ達した ? の失敗 bail (§16.5) はロードを中断し、途中まで組んだオブジェクトを返さない。したがって「宣言されたが評価されていないスロット」が外から観測されることはなく、スロット集合の固定は保たれる。中断したファイルはキャッシュにも残らない (§13.4)。

静的検査 (static-analysis.md §2) は全実行系の既定であり、ファイル単位で有効・無効を切り替える手段は無い。ファイルが宣言できるのは中身だけで、処理系の振る舞いを変える属性は持たない。

# main.hika
greet := { name: String | "hello, ${name}" }
print (greet "world")
# run.hika (shebang)
#!/usr/bin/env hikari
print "hi"
# math.hika (宣言だけを並べたファイル。PI と area がこのファイルの member になる)
PI := 3.14
area := { r: Float | PI * r * r }
# logger.hika (宣言と初期化の副作用が混ざる。評価は記述順)
log := { msg: String | print msg }
log "logger initialized"
# checked.hika (すべてのファイルが評価前に静的型検査される)
add: { Int, Int | Int } := { x, y | x + y }
print add(1, 2)

13.2 ファイルと名前空間

ファイル間の参照は import 構文 (§1.4) で行う。import は type / enum と同型の宣言形 <キーワード> 対象 := "path" で、パス先のファイルを §13.1 の規則で評価し、その member を対象名へ束縛する。import-target が bare 名 (import m := "x") ならモジュール名前空間全体を、名前リスト (import { a, b } := "x"、§6.3) なら列挙した member を分解束縛する ({…} の有無で分岐)。path は := 右辺の 文字列リテラル 1 個のみ、キーワードと対象・:=・path の間の空白は任意。

import は ファイルトップレベルの宣言 としてのみ現れる。関数本体・入れ子リテラルの内部には書けない (文法エラー)。これによりモジュールの初期化を起動時・単一の import チェーン上に閉じ込める。式ではないため := の右辺や部分式には置けない。

呼び出し側は丸ごと束縛した名前を通常のオブジェクトとして slot アクセスする:

import math := "math.hika"
math.sqrt 16

名前リスト {…} と組み合わせて、必要 member だけローカルに引くこともできる。ファイルトップレベルは slot-list なので (§13.1)、引いた名前は後続スロットの宣言から参照でき、そのファイルの member にもなる:

import { sqrt, log } := "math.hika"
sqrt 16

import は同じ構文で 標準ライブラリモジュール も取得する。引数が std: プレフィックスを持つ文字列リテラル ("std:fs" 等) のとき、ファイルではなくホスト提供の標準ライブラリ名前空間を解決する:

import { read, write } := "std:fs"
content := read("foo.hika")!.unwrap!

標準ライブラリのモジュール一覧と各 slot は std/index.md で定義する。std: 解決の詳細 (拡張子・キャッシュ・静的検査) は §13.4 を参照。

import は同じ構文で third-party パッケージ も取得する。引数が pkg: プレフィックスを持つ文字列リテラル ("pkg:http" 等) のとき、pkg: に続く 別名 を、呼び出し元ファイルが属するパッケージの マニフェスト で解決し、相手パッケージの入口モジュールを返す:

import { get, post } := "pkg:http"
get "https://example.com"

別名 → 取得元の対応・マニフェスト・lockfile・キャッシュ・推移依存の意味論は別書 packages.md で定義する。pkg: 解決の言語側の詳細は §13.4 を参照。

ファイル import の パス解決・キャッシュ・循環検出・エラー伝搬の詳細は §13.4 を参照。

定義ファイルの識別は、import のキャッシュ、名目型の所属と非公開スロットへの内部アクセスの判定に使う。

export によるファイル外公開の限定

ファイルオブジェクトの exported member 集合 を次で定める:

  • export が無い → 全トップレベル member を公開(既定)。
  • export { n1, …, nk } がある → n1, …, nk のみ公開。
  • export {}(空の名前リスト)がある → 何も公開しない。

import は評価したオブジェクトの exported member だけを露出する。未列挙のトップレベル名はファイル内ではレキシカルに参照でき(私的ヘルパー・相互参照)、importer からは member として存在しない(丸ごと束縛越しの .slot・import { 名前 } := "…" の分解とも該当スロット無しとして扱う)。

ファイルと値リテラルの export { … } は bare 識別子または name: 型 を並べる。
演算子名は宣言可能な既存の記号(+ など)を裸で書く。文字列・式・改名は書けない。
各ファイル・各値の slot-list・各タグ定義領域に最大一つであり、通常の本体や部分式には置けない。
タグ定義領域の項目は §17.4.2 で定める。

空の名前リスト export {} は「何も公開しない」と名乗る形である。 ファイルは 1 領域なので(§13.1)トップレベルの束縛は必ず member になる。member にしない選択はこの 1 行でだけ書ける。要るのは単体で走らせるプログラム — 外へ出す名前が無く、しかも多重度型の値(§17.8)をトップレベルに束縛するファイルである。多重度型の値は export できない(static-analysis.md §2.14)ので、公開しないことを名乗らなければトップレベルで資源を開けない。

# main.hika — 何も公開しない。conn はこのファイルの中で開いて閉じる
export {}

conn := db.open("app.db")!
conn.close()!
# util.hika — render だけを公開する。escape はファイル内からしか見えない
export { render }

escape := { s: String | s }
render := { s: String | escape s }

型注釈付き export: 公開する型契約は §17.6 に従う。
注釈なしなら通常の推論型を公開する。

公開した契約に現れる名目型は利用側が名前で書けなければならない。
公開操作の入力・結果、公開原型の構築入力、位置分解で公開する欄、型引数を再帰的に検査する。
非公開の状態だけに現れる名目型には公開を要求しない。構造型の別名自体も公開は不要だが、含まれる名目型は対象である。
不足は公開側の unnameable-exported-type とし、export { X } を案内する。
型の名前を公開することと、タグの名前を公開することはそれぞれの定義領域で別に選べる。

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

可変 member は束縛そのものである

mutable name := expr で宣言したトップレベル member は、ファイルオブジェクトの mutable slot として公開される。そのスロットはファイル内の束縛そのものであって、ロードを終えた時点の写しではない。ファイル内の読み書きと、import した側の m.name の読み書きは同じ格納先を指す:

  • ファイル内の関数が書き換えた値は、import した側の m.name にそのまま見える。
  • import した側が m.name = v (複合代入 m.name += v を含む) で書いた値は、ファイル内の読み出しにそのまま見える。代入は mutable slot への代入 (§4.1) と同じ規則に従う。
  • ファイルオブジェクトはプロセスに 1 つなので (§13.4 のキャッシュ)、別々のファイルから import した側同士も同じ値を見る。
  • immutable な member (name := expr) は importer からも immutable slot であり、代入は §4.1 のとおりエラーになる。
# counter.hika
mutable count := 0
bump := {| count += 1 }
# main.hika
import c := "counter.hika"
c.bump()
c.bump()
println c.count  # 2
c.count = 10
c.bump()
println c.count  # 11

分解形は写しである。 import { count } := "counter.hika" は分解束縛 (§6.3) なので、import した時点の値を immutable な名前へ束縛する。以降のファイル内の変更は反映されない。変更を追いかけるなら丸ごと束縛して m.count で読む。

spawn のブロックがファイルオブジェクトを捕獲したときの扱いは、他の可変な値の捕獲と同じである。子フローは複製を持ち、子の書き込みは親から観測できない (§10.1)。

13.3 root 終了時の未解決 Future

root リテラルの本体評価が完了した時点で、fork で生成され未だ resolve していない Future が存在する場合、それらは放棄される。block の残りの評価は走らない (実装は当該フローを止める責任を持つ)。放棄は §10.3 のキャンセルであり、放棄した Future はキャンセルの panic で解決する — 後から ! すると、その ! の地点で panic する。

最後まで結果を必要とする Future は明示的に f! で待つ義務がユーザー側にある。

root は 1 つとは限らない。 プログラムのほかに、std:test の run が走らせる 1 件のテスト (std/test.md §2) がそれぞれ root であり、この節の規則はそれぞれが完了したときに当てはまる。hikari test はファイルのトップレベルを 1 つの root として走らせ終えてから、各テストを別の root として走らせる。

root の中では、その root の外で起こしたフローは進まない。 run が走らせる root は、呼び出した側のフローが止まっている間に走るからである。外で起こした未解決の Future を中で待つと (!・wait_any・timeout ほか合成オペレーターに渡す)、その地点で panic する (待っても解決しないので、行き詰まりにも時間切れにもしない)。外の Future そのものはキャンセルしない — 外の root が続きで待てば値を取り出せる。外で解決済みの Future は中でも取り出せる。

13.4 import の詳細仕様

import <対象> := "path.hika" (§13.2) の対象形・パス解決・キャッシュ・循環検出・エラー伝搬を定める。import は prelude 組込ではなく言語コアの宣言形 (§1.4) であり、評価時に 呼び出し元ファイル のパス情報を参照する点が通常の宣言と異なる。

対象とパス解決

  • 対象は bare 名 (丸ごと束縛) または名前リスト {…} (分解束縛。§6.3) のいずれか。path は := 右辺の 文字列リテラル 1 個のみ (import m := "math.hika")。変数・文字列補間 "${...}"・bare 識別子・任意式は 構文エラー (static-analysis.md §1)。リテラル限定によりモジュールグラフを実行前に確定する。
  • 引数のプレフィックスで解決系統が分岐する: std: → 標準ライブラリ解決、pkg: → third-party 解決 (いずれも下記)。プレフィックス無しは ファイルパス解決:
    • 拡張子 .hika は明示必須 (import m := "math.hika")。
    • パスは 呼び出し元ファイル基準の相対 として解決。./ ../ の有無を問わない ("math.hika" ≡ "./math.hika")。
    • 絶対パスは静的エラー (static-analysis.md §1)。/ で始まるパスは受け付けない — ソースが機械上の配置に依存すると、hikari build の embed も別環境での取得も成り立たないためである。位置に依らない参照が要るなら pkg: を使う。
    • 検索パスによる解決は未対応 (third-party は pkg: 経由)。

標準ライブラリ解決 (std: プレフィックス)

  • 引数が std: で始まるとき ("std:fs" 等)、std: に続く名前を ホスト提供の標準ライブラリモジュール として解決し、その名前空間オブジェクトを返す。一覧は std/index.md。
  • .hika 拡張子は 付けない ("std:fs"、"std:fs.hika" ではない)。ファイル相対パス解決・cwd・呼び出し元ファイル基準は 適用されない (ホストが提供するため位置に依らず常に同じオブジェクト)。
  • 循環検出・ファイル不在・読み込み失敗の対象外。host code は常に存在するため、これらのエラーは起こらない。未知の std: 名は実行前の静的検査で弾く (static-analysis.md §1)。
  • キャッシュは絶対パスではなく std: 名そのもの をキーとする (std:fs → 同一オブジェクト)。プロセス内 1 回だけ構築し以降は同じオブジェクトを返す。
  • embed バイナリ (hikari build) でも std: モジュールは常に解決可能 (ホストコードはバイナリに同梱される)。.hika ソースの embed FS とは独立。
  • std: モジュールは値メンバー (コンストラクター等) に加え、.hika の type/enum と同じく 型メンバー を export しうる。std:time の不透明型 Instant / Date / Time / Duration がこれにあたり、import t := "std:time" のもとで t.Instant と修飾参照するか import { Instant } := "std:time" で取り出して型注釈に書ける (§17.4 と対称、static-analysis.md §2)。不透明型は型名のみ公開され、内部表現は露出しない (パターン分解不可)。std の不透明型とユーザーが宣言する不透明型は、利用側から見て同じ性質を持つ (§17.4.2)。

third-party 解決 (pkg: プレフィックス)

  • 引数が pkg: で始まるとき ("pkg:http" 等)、pkg: に続く名前を 別名 (alias) とみなし、呼び出し元ファイルが属するパッケージの マニフェスト の deps で解決する。解決先パッケージの 入口モジュール (マニフェストの entry) を返す。
  • 別名は マニフェスト・ローカル — パッケージごとに独立した名前空間で、解決は常に「その .hika を含むパッケージのマニフェスト」基準。これにより推移依存同士で別名が衝突しない。マニフェストの探索・スキーマ・取得元記法・lockfile・キャッシュ・推移依存の意味論は packages.md。
  • pkg:<alias> は相手パッケージの 入口 1 点 に着地する。ファイル単位の pkg:<alias>/<path>.hika は持たない (相手パッケージ内部のファイル分割は、そのパッケージ自身の相対 import で閉じる)。
  • .hika 拡張子は 付けない。ファイル相対パス解決・cwd・呼び出し元基準は適用されない (別名は論理名で、実体の場所はマニフェスト/lock/キャッシュが決める)。
  • キャッシュは (取得元, バージョン, commit) をキーとし、同一の解決先は同じオブジェクトを返す。別バージョンの同一パッケージは別実体として共存する (バージョン解決器を持たない)。
  • マニフェストを持たないファイルからの pkg: import、deps に無い別名、未取得 (キャッシュ不在) は実行前の静的検査で弾く (static-analysis.md §1)。
  • embed バイナリ (hikari build) では依存ソースが embed FS の別名前空間に同梱され、pkg: は常に解決可能 (packages.md)。

型メンバーの export — ジェネリック宣言

  • 型パラメーターを持つ type / enum の宣言(type Box(a) := { value: a |})も 型メンバーとして export される。取り込んだ側は修飾形(import m := "box.hika" のもとで m.Box(Int))と分解形(import { Box } := "box.hika" のもとで Box(Int))のどちらでも型引数を当てられる。宣言したファイルの中で書いた Box(Int) と同じ型になる。
  • 公開されるのは型ではなく型コンストラクターである。 型引数を当てるまで型ではないので、型式の位置に引数無しで書いた m.Box はエラーであり type-arity-mismatch として報告する(List を型式の位置へ引数無しで書けないのと同じ理由。要素型が決まらない、§17.2)。引数の個数が宣言と食い違う形も同じ診断で、個数は宣言が持つ個数を述べる。この扱いは取り込み方で変わらない — 同じファイルで宣言した Box を裸で書いた形も、分解形で取り出した Box を裸で書いた形も、同じ診断で報告する。呼び出しの型引数も型式の位置である(§17.1)ので、v.matches(type Box) と v.matches(type m.Box) も同じ診断になる。
  • 分解形が束縛するのは型コンストラクターであって値ではない。 import { Box } := "box.hika" の後、Box は型式の位置でだけ引ける名前であり、Box(Int) と適用して型になる。値の位置に Box と書けないのは型の名前一般と同じである(§17.1「型式の位置」)。取り込み方に依らず、修飾形の m.Box も同じく型式の位置の名前である。
  • 非ジェネリックの type / enum は型そのものを公開する。 引数を持たないので適用の余地が無く、この節の区別は生じない。

キャッシュ

  • 同一の解決済み絶対パスは プロセス内 1 回だけ評価、以降は同じオブジェクトを返す。
  • キャッシュ登録は 評価完了時のみ。評価中エラーで中断したファイルはキャッシュに残らず、次の import でゼロから再評価される。

循環検出

  • 評価中のファイルパスをスタックに保持し、同一パスがスタックに既に含まれる import を 循環 import として Error で raise。
  • スコープは同一プロセス内、トップレベル import チェーンのみ。エラーメッセージに検出時の import チェーンを含める。チェーンは起点のファイルから並べ、循環が閉じるファイル (起点へ戻る import) までを a.hika -> b.hika -> a.hika の形で出す。
  • hikari <file> / hikari check / hikari build 実行・LSP では、実行前の静的検査 (static-analysis.md §1) が同じ循環を import-cycle として先に報告する。実行時の raise は動的到達のフォールバックで、読み込み失敗と同じ位置づけである(下記「エラーモデル」)。

エラーモデル

  • 読み込み失敗 (パス未解決 / 読み込み失敗): import 位置で Error を raise。なお hikari <file> / hikari build 実行・LSP では import 先不在・import 先の構文エラーは 実行前の静的検査 (static-analysis.md §1) で先に報告される。実行時の raise は動的到達のフォールバック。
  • 評価エラー (import 先の評価中の例外): import 先で発生した例外がそのまま呼び出し元へ伝搬。中断したファイルはキャッシュに残らない。

意図的に 入れない もの: bare 識別子 import、任意式 import、リネーム付きスロット destructure、部分循環 import、動的読み込み / 遅延読み込み / 明示再読み込み、ファイルレベル inner-name、ファイル単位のメタデータ宣言 (ファイルは中身だけを宣言し、処理系の振る舞いを変える属性は持たない。§13.1)。

import をファイルトップレベルの宣言に限定する (§13.2) のは、この遅延読み込み排除と整合する — 関数本体内 import は実質的な初回タッチ遅延読み込みになるため許さない。宣言形のため配置制限は文法で担保され、別途の placement 静的検査は要らない。

14. 標準ライブラリ

prelude (起動時に root フレームに束縛される) の定義は別書 prelude.md に分離した。import <対象> := "std:<name>" で取得する 標準ライブラリモジュール (std:fs 等、root には常在しない) は別書 std/index.md で定義する。

std:regex の16進エスケープ、反復数の字形、反復にならない波括弧の扱いは std/regex.md §3 が定める。たとえば a{01} は a{01} という文字列に一致し、a の反復とは解釈しない。

std:time の受理範囲は std/time.md §1、範囲超過の扱いは std/time.md §8 が定める。

15. 章をまたいで効く規則

本書の規則には、章をまたいで効くものがある — 並置=関数適用(§3.1)、
(...) は要素数で意味が変わる(§3.3)、; / 改行はシーケンス
(§11.1)、:= は宣言で = は代入(§6.1)、
予約語は固定された 12 語である(§1.2.2)などである。

それらをまとめた一覧はどこにも持たない。 同じ項目を 2 か所に持つと、
更新されない一覧が規則と食い違う。規則の正はそれを定める章にあり、本書の他の章も他の文書もその章を指す。

16. エラーモデル

Hikari のエラーは 値 であり、専用の例外機構や大域脱出を持たない。失敗の重さに応じて 3 つの層に分ける。同じ「大域脱出を持たない」方針を共有する制御構文(break / continue / return・ユーザー定義制御構造・末尾呼び出し)は、エラーとは別系統の制御値で実現され §18「制御フローと制御値」にまとめる。本章で扱う失敗 bail ?(§16.5)はその制御値を用いるが、エラー処理の一部としてここに置く。

16.1 三層モデル

層 時点 種別 表現 伝播
静的エラー 実行前 構文エラー等、実行を始める前に判明するもの (値にならない) 実行開始前に全体を検査して報告
回復可能エラー 実行時 ファイル不在など想定内の失敗 Result 値 Ok(v) / Err(e) (§17 型語彙)。e はエラー型 E の値 (既定は { kind, message |} の Error) 自動伝播しない。呼び手が match (値コンストラクターパターン) / unwrap! で分岐する
バグ 実行時 プログラムのバグを示す致命的失敗。これを起こすことを panic する という Error 評価のどの位置でも上位へ自動伝播し、トップレベルに達したところで停止する

時点と層は直交する。 回復可能エラーとバグはどちらも実行時に生じる — 分かれるのは生じた後の運び方 (値として呼び手へ返すか、自動で上へ伝播するか) であって、いつ分かるかではない。本書が「実行時エラー」と書くのは実行前に検出できるもの (static-analysis.md §2.11 の検査) との対比であって、層の名前ではない。

panic は必ずプログラムを落とすわけではない。 停止・非ゼロ終了はトップレベルまで達したときの結末で、手前に受け止める位置があればそこで止まる。現状 2 つある — std:test の run は Trial の境界で捕まえて FAIL に数え (std/test.md §2)、一度も ! しなかった Future の panic は surface しないまま診断だけが出る (§10.2。終了コードは変わらない)。

16.2 層の振り分け原則

ある失敗をどの層に置くかは 「プログラムのバグか、想定内の状況か」 で決める。

  • バグ(アスクリプションの型不一致・ゼロ除算・呼び出しの深さの上限超過など)→ バグ層(panic する)。未定義参照と arity 不一致は静的エラーであり、型の panic の地点は §17 の健全性保証に従う
  • 想定内の状況 (ファイル不在、権限不足など、起こりうるもの) → 回復可能エラー
  • 実行前に判明するもの (構文エラー等) → 静的エラー

これらの panic は型不一致や unwrap! のように 言語・組込が contract 違反として自動で起こすのが基本だが、ユーザーコードからも明示的に panic を起こせる。組込 panic(message) (prelude.md §1) は message (String) を持つバグ層エラーを発火する — 「到達しないはず」「未実装」「呼び出し前提の違反」のような バグを表明するための手段である。

  • panic は §16.1 のとおり評価のどの位置でも上位へ自動伝播し、トップで診断付き停止・非ゼロ終了する。診断は発生位置とメッセージに加え、そこへ至る関数呼び出しの経路 (各呼び出しの位置と、呼ばれた関数の名前。内側から外側の順) を含む。経路は診断表示のみに使われ、Hikari コードから観測する手段は無い。診断を出さず exit code だけを返す exit(code) (意図的終了、prelude.md §1) とは別系統である。
  • panic は 発散する (値を返さない) ため、型上の結果は Never (ボトム型、§17.2) で任意の位置に置ける (match { p => v, _ => panic("unreachable") } のような分岐の穴埋めに使える)。Never は全型の部分型なので発散アームは分岐合流で他方の具体型へ寄り、結果型を Any に倒さない (static-analysis.md §3)。message には String を静的に要求する。
  • 想定内の失敗 (回復可能エラー) には panic を使わない。失敗を値で運ぶ §16.3 の Result / Err(e) を使う。panic はあくまでバグ層への明示的な入口である。

16.3 回復可能エラーの形

回復可能エラーは kind (String) と message (String) の 2 スロットを持つ closed なデータオブジェクト (§2.4)。

  • kind: 機械可読な種別。分岐に使う。match err.kind { … } (prelude.md §8.4) でそのまま key にできる
  • message: 人間可読な説明。表示・ログ用。分岐に message の文字列マッチを使わない

型語彙 Error(= { kind: String, message: String |})でこの形を照合・注釈できる (e.matches(type Error) / x: Error、§17.4)。

Error は Result の 既定のエラー型である。Result(T) は Result(T, Error) の別記で、E を省略するとこの { kind, message |} 形を既定にする (§17.4)。別記であって E を未確定にする書き方ではない — Result(T) と書いた時点で E は Error に確定し、照合も Error として行う。エラーを型で区別したいとき (parse の Syntax / Overflow 等) は Result(T, E) でエラー型をパラメーター化し、E に構造化型 (enum 等、§17.4) を入れる。組込 (input / std:fs ほか) はすべて既定の Error を返す。

import { read } := "std:fs"
match read("config.hika")! {
  Ok(content) => use content
  Err(e) =>
    match e.kind {
      "not_found" => use_default!
      "permission_denied" => abort!
      _ => print e.message  # 未知 kind
    }
}

16.4 kind の集合 (閉/開のハイブリッド)

  • 組み込みが返す kind は正規一覧として文書化する (閉じている。prelude 各節が列挙)
  • ユーザー定義のエラーは任意の kind 文字列を使ってよい (開いている)。エラー値は { kind := "...", message := "..." |} のオブジェクトリテラルでも、prelude の error(kind, message) (prelude.md §12.3) でも組める。専用構文は要らない
  • 受け手は 未知 kind 用の default 分岐 を持つことを慣習とする (kind は開いた String なので網羅性は静的に保証されない。closed variant — Option / Result / enum — の match は静的型検査が網羅性を要求する。static-analysis.md §2.9)
実行開始前の一括構文検査 (構文エラー・動的 import 排除・import 解決層エラー) は static-analysis.md §1 を参照。

16.5 失敗 bail (?)

? は Result / Option の 失敗 variant に当たったら即座に関数から脱出 する postfix 演算子で、§18.2 の return の上の構文糖である (新しい脱出機構ではない)。逐次処理の「失敗なら即抜け、成功なら中身を取り出して次へ」を、match や when (…is_err!) {return …} のネストなしに平坦に書ける。

e? は対象 e を一度だけ評価し、その variant で分岐する:

対象 成功 → 式の値 失敗 → 脱出
Result Ok(v) → v Err(e) → return r (Result をそのまま返す)
Option Some(v) → v None → return None
  • postfix: ! (§3.1) と同じ後置で、対象が Option / Result 値であることを要求する。step!? は (step!)? と割れ、「! で resolve / kick した結果の Option / Result に ?」が一様に通る。手元の値には r?。Option / Result 以外への ? は静的エラー。
  • return の構文糖: r? ≡ match r { Ok(v) => v; Err(_) => return r; Some(v) => v; None => return None } (対象は一度だけ評価)。脱出は §18.2 の Return 制御値で実現し、字句スコープ・透過範囲・トップレベル終了は §18.2 と完全に同一。if / when / match / while / each のブロックは透過 (? の失敗が外側の関数から脱出)、自前の高階関数に渡したブロック内の ? はそのブロックから脱出、トップレベルの失敗はモジュール評価を終了する。
  • bail 値: Result は Result そのものを返す (Err(e) を再構築せず payload { kind, message |} を保全)、Option は None。
  • 戻り型の収束: ? の失敗 bail は関数の戻り型に「失敗 variant 型」を寄与する (§18.2 の return と同様、末尾値と合流する)。脱出する値は Err(e) / None であって成功 payload を持たないため、寄与するのは失敗 variant 型のみ — bail の成功 payload 型は関数の戻り成功型を制約しない。したがって Ok 型の異なる逐次 ? (上の例の read(path)!? は Result(String)、末尾 Ok(cfg) は Result(Cfg)) も末尾値と収束する (Err の E だけが戻り型へ流れる)。一方、1 つの関数で Option bail (return None) と Result bail (return Err(…)) を混ぜると variant の種別が割れる。静的検査はこれを確実に割れる合流として報告する (static-analysis.md §2 / §4)。「? を Result / Option を返さない関数で使う」ケース (末尾値と bail の種別が割れる) も同じ収束判定で拾う。
  • トップレベルに達した失敗の表面化: entry の最上位で ? が失敗 variant(Err(e) / None)により bail したとき、それは「未処理のまま最上位へ達した失敗」として評価エラー扱いになり、stderr に診断を出して非ゼロ終了する(exit code 1、hikari-command.md §5.4)。診断本文は Err(e) なら e の message(標準 Error の場合)、None なら bailed on None。? の下地である return に失敗 variant を直接渡した場合も同様に表面化する。ファイルには本節「戻り型の収束」が及ばない — ファイルは body を持たず、ロードが返すのはファイルオブジェクト自身である(§13.1)。トップレベルの bail は値を生まずロードを中断するので Never に型付き、Never は合流の恒等元なので(static-analysis.md §3.3)締めの値を要求しない。unwrap!(失敗=バグの表明 → panic)との違いは、こちらが「想定内の失敗が未処理で最上位に達した」通常のエラー経路である点で、診断は Trace を持たない単一行になる。
  • 表面化は bail の浮上元に依らない: 上の表面化は、entry のトップレベル(§13.1)へ達したすべての bail に同じに起きる。スロット宣言のデフォルト値から浮上しても、トップレベルの文から浮上しても違いは無い。
process := { path |
  content := read(path)!?  # Err なら read の Result をそのまま return、Ok なら content
  cfg := parse(content)?  # Err なら parse の Result をそのまま return、Ok なら cfg
  Ok(cfg)
}

Option / Result の値・メソッド (unwrap! / or / map ほか) は prelude.md §12。

16.6 呼び出しの深さの上限

呼び出されてまだ戻っていない関数の数を呼び出しの深さという。深さには上限があり、既定は 100000(10 万段)である。上限を超える呼び出しはバグ層の panic になる(§16.2)。資源を使い尽くしてプロセスごと落ちる前に、どこで何が深くなったかを診断として出すためである。

countdown := { n: Int |
  if (n == 0) {
    0
  } {
    1 + countdown (n - 1)
  }
}
countdown 1000  #> 1000

上の countdown は 1 段ごとに戻り先を残すので、countdown 200000 は上限を超えて panic する。

  • 診断: 本文は stack overflow: call depth exceeded N(N は実効の上限)。位置は上限を超えた呼び出しを書いた位置で、そこへ至る呼び出しの経路が続く(§16.2)。経路の中で同じ位置から同じ関数を呼んだ行が続く部分は (repeated K times) の 1 行にまとまるので、深い再帰でも診断は数行に収まる。
  • ほかの panic と同じに扱う: 受け止める位置(std:test の run・一度も ! しなかった Future、§16.1)があればそこで止まり、無ければトップレベルで exit code 1 で終わる。
  • 末尾呼び出しは数えない: 自己末尾再帰(§18.5)は現在の呼び出しを置き換えて進むので深さが増えず、何段回しても上限に当たらない。相互再帰と別関数への末尾呼び出しは 1 段ずつ数える。
  • 組込を経た呼び出しも数える: 組込の関数・メソッドの呼び出し、組込が呼び返すブロック(map に渡したブロック・演算子スロットの本体)もそれぞれ 1 段である。したがって深さは、利用者が書いた再帰の段数より数段多くなりうる。
  • フローごとに数える: fork / spawn(§10)で起こしたフローは深さ 0 から数え始め、起こした側の深さを引き継がない。std:test の run が走らせる各テストも同じである。

上限を変える

上限は環境変数 HIKARI_MAX_CALL_DEPTH で変えられる(hikari-command.md §13)。正の 10 進整数ならそれが上限になり、未設定・空・0・それ以外の綴りは既定の 100000 になる。値は実行するときの環境から読むので、hikari build の生成物も走らせるときに設定する。

上限を上げると深い再帰が通るようになる代わりに、落ちるまでに使う資源が増える。1 段が保持するのは戻り先と局所の値なので、使う量は段数に比例する。

デフォルト値の根拠

既定の 100000 は次の 2 つの間に置いた。

  • 正当な深い再帰を落とさない: 要素数に比例する深さの再帰(数万要素のリストを非末尾の再帰で畳む・深い入れ子の木を再帰下降する)が上限の内側に収まる。
  • 資源を使い尽くすより十分手前で止まる: 1 段が保持する量は、局所の値が少ない関数で数百バイト、局所の値が多い関数でも数 KB である。100000 段でも数十 MB から数百 MB に収まり、普通の計算機のメモリーを使い尽くすことはない。上限が無ければ、止まらない非末尾の再帰はメモリーを使い尽くすまで伸び続け、診断を出さずに異常終了する。

17. 型注釈 (type annotations)

変数・パラメーター・スロット・分解束縛・inner-name・関数の結果型・任意の式に 型注釈 名前: 型(式に対しては 式: 型)を付けられる。型は値ではない — 型の名前は prelude と type / enum の宣言がスコープに載せるが、束縛・引数・返り値・等価の対象にはならず、型を書ける位置(§17.1「型式の位置」)でだけ引ける。型を受け取る関数は呼び出しで埋める型スロット type a で書く(§17.4.1)。

注釈とアスクリプション

束縛・パラメーター・スロット・分解束縛・inner-name・関数の結果型の注釈には、
値をその型へ静的に代入できることを要求する。型検査の受理を証明とみなし、
これらの注釈では実行時に照合しない。注釈からの暗黙の下方変換は認めない。

式アスクリプション 値: T が唯一の明示の下方変換である。
Any から T、OneOf から選択肢、基底型から NonZero(T) へ絞り込むときに使う。
静的に証明できなければ、その式の評価地点で §17.4 の規則で照合し、
不一致なら型不一致として panic する(§16.2)。
括弧は不要で、n: Int := a: Int と f(a: Int) と書ける。
panic しない絞り込みには match と if (v.matches(type T)) を使う。

a: Any := 3
n: Int := a: Int
n + 1  #> 4

アスクリプションの照合を消せるかの判定: 値が対象型を満たすことを静的に証明できた
アスクリプションでは照合を行わない。NonZero(T) では基底型の一致に加え、値が非ゼロの定数か静的型が NonZero(T) であることが要る。
証明できない位置には照合が残る。判定は過小近似であり、消える照合は必ず成功するので、
照合の省略は観測できる意味論を変えない。値の定義に固定した公開範囲と名目型の識別情報は維持する。

照合の省略は検証モードで確かめられる。
環境変数 HIKARI_VERIFY_ERASURE(hikari-command.md §13)を設定すると、
消去したアスクリプションの照合と、注釈(束縛・パラメーター・結果ほか)の照合も実行する。
受理したプログラムでここが失敗したら、それはプログラムの誤りではなく処理系の欠陥である。
そのため型不一致の panic とは区別し、panic を受け止める位置(§16.1)でも捕まえない。
専用の診断を出して終了コード 71 で停止する(hikari-command.md §5.4)。
照合が判定できない場合も同じ扱いである。通常の実行では何も変わらない。

完全静的な型付けと健全性

Hikari の型検査は評価前に必ず行い、型が付くと示せないプログラムを受理しない。
注釈は推論できる位置で省略できる。使われる値の位置で型不明に倒れた場合は静的エラーになり、
期待型か注釈を要求する(static-analysis.md §2.2)。

Any は操作できない top 型である。すべての型 T について T <: Any であり、
どの値も Any の位置へ入れられる。Any の値へのメンバー参照・演算子・呼び出しは静的エラーである。
アスクリプションか panic しない絞り込みで、必要な型を確かめてから操作する。

健全性保証: 静的検査を診断ゼロで通ったプログラムについて、次の 2 つを約束する。

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

系: アスクリプションを書かないプログラムは型の panic を起こさない。
添字の範囲外や明示の panic など、型以外のバグ層の失敗を禁止する約束ではない。

可変な位置へ代入する値は、その位置の型を静的に満たさなければならない。
record のフィールドと可変なコンテナーの型引数は不変に扱う
(§17.2「変性」)。
Any からは書き込めず、再代入によって値の型が変わる経路も受理しない。

関数値の実行時の型

関数値は、検査器が決めたシグネチャを実行時の型として持つ。
シグネチャの構造は関数リテラルごとに決まり、宣言した型と推論した型を区別しない。
束縛名・record のスロット・コンテナー・Any を経て渡しても、そのシグネチャを保つ。
別の型への注釈やアスクリプションは、元の関数値のシグネチャを書き換えない。
関数リテラルへ直接書いたアスクリプションも、注釈型の結果に書いた NonZero(T) をそのリテラルの結果型にしない。
本体の結果が 0 でないことを示すには、本体の値へアスクリプションを書く({| 1: NonZero(Int) })。

関数型の照合は引数数・型スロットの位置・各引数型・結果型を不変に突き合わせる。
効果集合は §17.9 の包含規則で照合する。
Any は関数型の成分でも top 型であり、具体型に一致する wildcard ではない。
結果型が Unit の関数型への照合でも、異なる結果型を一致とはしない。
Unit を期待するリテラルの結果破棄は、下記の期待型による検査で決める。

型変数を持つ関数は、シグネチャ全体を同時に実体化して対象の関数型に一致するかを判定する。
同じ型変数のすべての出現には同じ型を当て、境界の要求も満たさなければならない。
引数ごと・結果ごとに独立した wildcard としては扱わない。
実体化してよいのは、その関数自身が量化する型変数だけである。
外側の関数の型変数を捕獲する関数値は、作られた呼び出しの型の対応を保持する。
捕獲した型変数を、新たな多相な型変数として実体化し直さない。

inc := { x: Int | x + 1 }
f: Any := inc
f.matches type { Int | Int }  #> true
f.matches type { Int | String }  #> false

id := { x: a | x }
id.matches type { Int | Int }  #> true
id.matches type { Int | String }  #> false

部分適用は、§3.5 の対応で埋まったパラメーターを除き、
残るパラメーターと結果型に、渡した実引数で決まった型変数の対応を反映する。
型引数を渡した位置も同じである。未束縛のデフォルト値スロットは引数数に含める。
呼び出し先やデフォルト値を実行して型を調べることはしない。

first := { x: a, y: a | x }
p := first 1
p.matches type { Int | Int }  #> true
p.matches type { String | Int }  #> false

prelude と標準ライブラリの組込関数・組込メソッドも、静的検査が使うシグネチャで照合する。
メソッドを受け手に束縛した値では、受け手のパラメーターを除き、その型引数の対応を反映する。
シグネチャの成分が無いことを理由に一致とはしない。
照合のために関数本体・デフォルト値・受け手のメソッドを実行することはない。

関数型の注釈やアスクリプションは値を包み直さず、元のシグネチャで一致を判定する。
関数型の注釈を持つ名前・スロット・メンバーを呼ぶ位置でも、実引数と結果は実行時に照合しない。

型式の () は Unit と同じ型を表す。
注釈・matches・関数型の引数と結果・型引数のいずれでも同じ意味である。

Unit の結果位置は値を捨てる文脈である。
期待結果型が Unit の関数リテラルでは、計算した結果を捨てて () を返す。
本体の末尾と、そのリテラル自身から脱出する return の値を評価して捨てる。副作用は保つ。
制御透過のブロックを貫いて外側の関数へ届く return や、ループへ届く break の値は捨てない。
これは期待型を使って本体を検査する規則であり、異なる結果型を持つ関数値を同じ型とする規則ではない。
結果を捨てるコールバックの結果型は Unit にする。

Future(T) の照合は待ち合わせを起こさない。
値が Future であることに加え、Future の結果の型が T を満たすことを判定する。
結果の型は、Future を作った組込(fork・spawn・map・and_then・all・std の入出力ほか)の結果型を、その呼び出しの型で確定したものである。
値を待たずに型で比べるので、結果の位置は共変に読む — 結果の型が T の部分型なら一致する。
panic で終わるブロックの結果の型 Never は、どの T も満たす。

f: Any := fork {| 1 }
f.matches type Future(Int)  #> true
f.matches type Future(OneOf(Int, String))  #> true
f.matches type Future(String)  #> false

T が NonZero(U) なら、結果の型が NonZero(U) であるときに限って T を満たす。
値が 0 かを見るには値が要り、値を読むには待ち合わせが要るからである。

17.1 記号と位置

: は型注釈専用の記号。:=(束縛)とは字句上区別される(x: Int は x : Int の 3 トークン、x := 0 は := の 1 トークン)。

  • パラメーター / スロット: { x: Int, y: Int | x + y }
  • デフォルト付き(immutable / mutable): { x: Int := 0 | ... } / { mutable count: Int := 0 | ... }。注釈を書かない { x := 0 | ... } はデフォルト値の型 (Int) を要求し、実引数を静的に検査する(§12.2)
  • 変数束縛: total: Int := 0 / mutable total: Int := 0(型注釈付き束縛は値を伴う。name: T 単体の宣言は持たない)
  • inner-name: { inner self: T, slot-list | body }(自身の値の型。§4.2)
  • 分解束縛(位置 / 名前): a: Int, b: String := f() / { x: Int, y: Int } := v(ワイルドカード _ に型は付けない)
  • 式アスクリプション: 式: 型(任意の式に後置し「この式は当該型に評価される」と表明。(self.x - other.x): Int / f(x): String。関数の結果型は body 末尾式へのアスクリプションで書ける。§17.3)

: の結合強度: 式アスクリプションの : は最低優先(二項演算子・関数適用より弱く、非結合)。f x: Int ≡ (f x): Int、a - b: Int ≡ (a - b): Int と読む。括弧は任意(hikari format は曖昧になりやすい二項式アスクリプションに括弧を補う)。: と := は字句区別されるため foo := bar: Baz は foo := (bar: Baz)(束縛の右辺へのアスクリプション)であり、束縛注釈 foo: Baz := bar とは別位置の表現。アスクリプション右辺の型は型コンテキストで評価される(§17.2)ため、タプル型は x: (Int, String) と単一括弧でよい。

型テストは v.matches(type T) または v.matches type T と書く。
タプル型や構造型も直接書ける(v.matches(type (Int, String))・v.matches(type { x: Int |}))。

matches の型引数に裸で書ける小文字名は、実行時に確定している型変数に限る。
無境界の型変数は実行時に消去されるので、照合の材料を持たない。
使えるのは呼び出しで埋める型スロットの型変数と、境界付き型変数である。
{ v: Any, type a | v.matches(type a) } と { v: a: Comparable, w: Any | w.matches(type a) } が該当する。
それ以外の小文字名は undefined: <名前> として報告する。
大文字始まりの未定義名も同じ扱いである(v.matches(type Nosuch))。
型コンストラクターの内側も、照合に必要な型変数が確定していなければ静的エラーにする。
v.matches(type List(a)) で a の判定を省略して一致とすることはできない。

型式の位置

型を書ける位置 — 型式の位置 — は次で尽きる。

  • 注釈(パラメーター・スロット・変数束縛・分解束縛・inner-name・式アスクリプション)
  • type の右辺と enum 原型のスロット注釈・領域本体のタグ集合(§17.4)
  • match のアームに置いた型(prelude.md §8.4)
  • 呼び出しで type T と明示した実引数(呼び出しの型引数。§17.4.1)
  • 型コンストラクターの引数・タプル型の要素・structural 型のエントリ

型式の文法はどの位置でも同じで、書いた地点で静的に解ける。 名前として読めるのは裸の識別子(Int・List(Int)・Pair(a, b))と、受け手が裸の名前のメンバー(m.T・m.Seq(Int))までで、その受け手は import したモジュール(型メンバーを持つ。§13.2)である。呼び出しの結果(mk()(Int))・入れ子のメンバー(ns.sub.T)・関数やタグへの適用(f(Int)・Some(Int))は型式ではなく、どの位置に書いても静的検査が報告する(static-analysis.md §2.4)。

型の名前を値の位置に置く形は静的エラーである。 型は値ではないので、x := Int・f(List)・println Int・[Int, String] は書けない(static-analysis.md §2.4)。例外は enum のタグを引く 2 つの形 — 修飾したタグ Name.Tag と、名前リストによるタグの取り出し { A, B } := Name — である(§17.4「enum の名前はタグを引く受け手になる」)。

17.2 型の正体(値が一形なら型も一形)

値が { slot-list | body } の一形なら、型も同じ一形で表す。function と record は同じ {} 型フォームで、結果型(body)の有無だけが違う(値の「body 有無=関数かデータか」と対称):

  • 原始型: Int / Float / String / Bool / Unit / Bytes / Any / Never
  • 特殊型: Any(任意の値に一致する、操作できない top 型)/ Never(値を持たないボトム型。全型の部分型。panic/exit のような発散位置の結果型で、どの値にも一致しない=v.matches(type Never) は常に false。§16.2)
  • record / object 型(body なし): { x: Int, y: Int |}
  • function 型(body 位置に結果型): { Int, Int | Int }(位置の型+結果)/ { x: Int, y: Int | Int }(名前付き+結果)。引数名は表示専用で、照合は引数数・引数型・結果型だけを見る(§17.4 の照合表)。書いた綴りは型の表示(診断メッセージ・hover)にそのまま出る
  • tuple 型: (Int, String)((T) の 1 要素はグルーピングであり tuple にならない、§3.3)
  • 型コンストラクター(固定形に書けない可変長 / union / 不透明 payload): List(T) / OneOf(A, B) / Option(T)(= Some(T) ∣ None)/ Result(T, E)(= Ok(T) ∣ Err(E)、E 既定は { kind, message |} の Error。Result(T) ≡ Result(T, Error))/ Future(T)。ユーザー定義のタグ付きデータ(enum、§17.4)の型も OneOf(...) 相当でここに属する — 各タグは型 Name の下に置かれ、Name.Tag で参照する(フラット束縛はしない)
  • 呼び出しで埋める型スロット: 関数型のエントリ type a — その引数が値ではなく型を受け取り、受け取った型を型変数 a と呼ぶことを表す({ String, type a | Result(a) })。値の側の slot-list にも同じ type a と書く(§17.4.1)
  • 順序型: Ordering(= Less ∣ Equal ∣ Greater、順序比較の結果。§9.4)
  • 構造的 interface(capability 型): メソッド契約を表す構造型。Comparable(= { compare |}、§9.4)/ Copyable(= { copy |}、§9.5)は組込特別型ではなく prelude 定義の構造型であり、専用の型 kind を持たない。ユーザーも同じ構文で定義できる(§17.5)
  • 非ゼロ数値型: NonZero(Int) / NonZero(Float) — 0 でない数値。prelude 定義の型コンストラクターで、基底型の部分型になる。除数として使える(§17.7)
  • 多重度型: AtMostOnce(T) / ExactlyOnce(T) — 値を何回使えるかを制約する型。付随する語彙として Borrowed(T)(借りた値)と Consuming(F)(受け手を消費するメソッド)を持つ。いずれも prelude 定義の型コンストラクターで、値ではなく使用を制約するため実行時に照合するのは基底型(T / F)だけである(§17.8)
  • 効果型: Effect(T, …) — 結果型 T と、その計算が起こす効果ラベル(Io / Fs / Net / Proc / Time / Rand / Mut / Susp)の集合。付随する語彙として EffectConduit(F)(その引数の効果が呼び出し元へ透過する)を持つ。prelude 定義の型コンストラクターで、書けるのは関数型の結果型位置だけである。実行した計算の効果は実行時照合の対象にしない(§17.9)

構造型と名目型: 型は、何で同じ型と決まるかで 2 つに分かれる。

  • 構造型は形で決まる。形が同じなら同じ型である。record・function・tuple の型、List(T) ほかの組込の型コンストラクター、構造的 interface がこれにあたる。type で付けた別名も、基底型と同じ型である(§17.4)。
  • 名目型は宣言で決まる。形が同じでも、別々に宣言したものは別の型である。enum で宣言した型(§17.4「enum は宣言した位置で識別する」)と、std の不透明型(std:time の Instant ほか。§17.4.2)がこれにあたる。
  • 名目型の照合(matches・型注釈)も宣言で判定する。名目型の内部表現と同じ形の値を作っても、その名目型には一致しない。

型コンテナーの役割は一つに固定する: {...} = object/record/function、(A, B) = tuple、List(T) = list。型位置に [...] は現れない(下記)— list は List(T)、固定位置は tuple (...) に書く。

型位置の {} の解釈(値位置と異なる):

  • | 結果型 あり = function 型(結果型を持つ)。パラメーターのエントリに加えて、呼び出しで埋める型スロット type a を置ける(§17.4.1)。
  • | 結果型 なし = structural 型(object/record/interface)。末尾 | は必須(0-pipe は下記の function 型)。エントリは:
    • name: 型 = 型付きフィールド(データ契約。スロットが 型 に一致)
    • bare 小文字 m = メソッドフィールド(m に応答する契約。§17.5 の構造的 interface)
    • bare 大文字 Name = 埋め込み(Name が指す structural 型の全エントリを取り込む。§17.5)

(従前ここには「bare 識別子=位置型フィールド」の記載があったが、positional shape 型は実装を持たず dormant だったため、bare エントリは上記のメソッドフィールド/埋め込みに割り当てる。§17.5。)

この 3 つで尽きる。 値位置の slot-list が持つ他の綴り —— デフォルト値つきスロット(name := 型 / 可変スロット mutable name := 型)・名前でない位置エントリ({ 1 |})・呼び出しで埋める型スロット(type a)—— は structural 型のエントリではなく、構文エラーにする。型位置の [...](brackets are not a type)と同じ、書いた綴りだけで決まる判定である。

可変性は型の綴りに載らない。 mutable を型位置に書けないのはこのためで、record 型が深さについて部分型を持たない根拠(下記「変性」)は値の可変スロットにあり、型の側がスロットごとの可変性を述べるわけではない。可変スロットを持つ値は name: 型 の位置へそのまま渡せる(幅・深さの規則は値の可変性を見ない)。

pipe なしの {T}(0-pipe)は body 形であり、値位置の {body} と同じ規則に従う。型位置では body が結果型になるため {T} ≡ {| T } =「引数なしで T を返す関数型」となる(structural 型にしたい場合は末尾 | が必須で { … |} と書く)。ただし body が空の {} は例外で、結果型が無いため関数型にならず、空の structural 型 {|} として読む — 型位置では {} ≡ {|} がどちらも「フィールドを問わない空の structural 型」であり、要求が無いので全値に一致する(Any 相当。§17.5)。値位置で {} ≡ {|} が 1 つの空オブジェクトになる(§2.1.1)のと揃う。これは値 {5}(引数なしで 5 を返すブロック)の型が {Int} になる、という値↔型の対称の帰結である:

書き方 意味
{Int} 引数なし → Int を返す関数型(≡ {| Int })
{ x: Int |} フィールド x: Int を持つ record/structural 型
{ compare |} compare に応答する構造的 interface(§17.5。Comparable)
{ draw: {| Unit } |} draw が {| Unit }(引数なし→Unit)に応答する interface。メソッドシグネチャ契約(§17.5)
{ Int, Int | Int } (Int, Int) → Int の関数型

変性(variance): record 型は幅について部分型を持ち、深さについては持たない。宣言していないスロットを余分に持つ値は通る(幅。{ x: Int, y: Int |} の値は { x: Int |} の位置へ渡せる — スロットは実行時に減らせない)が、宣言したフィールドの型は厳密に一致していなければならない(深さ。{ x: Int |} の値は { x: Any |} の位置へ渡せない)。理由は可変性にある — 可変スロット(mutable)は中身を差し替えられるので、同じ値に広狭 2 つの静的な視点を同時に持たせると、狭い視点では違反である書き換えを広い視点から行えてしまう(可変なコンテナーを共変に扱ったときに生じる不健全性そのものである)。

このフィールド型の一致では NonZero(T) と T を区別する。たとえば mutable n: NonZero(Int) を持つ値を { n: Int |} として受けることはできない。広い型を通して 0 を書くと、元の型の保証を破るためである。

幅が開いているのは「渡せる値」であり、触れるメンバーは静的型で決まる。
受け手の静的型が record なら、注釈の有無によらずメンバー集合をその型に閉じる。
r := { x := 1 |} の r.y と、{ o: { x: Int |} | o.y } はどちらも no-such-member である
(static-analysis.md §2.7)。
余分な欄を読むには、その欄を含む型へのアスクリプションか matches による絞り込みが要る。

束縛・パラメーター・結果・export のいずれでも同じ規則を適用する。
型注釈は公開範囲を変更しない。非公開名へのアクセスは値の定義の規則に従う(§2.6)。

差し替える手段が無い位置は共変である。 Option / Result / Future の payload、tuple の要素、そして List(T) の要素型(List は不変で要素を差し替える経路を持たない。§7.4)がこれにあたり、狭い型の値を広い位置へ渡せる。一方 std:array の Array(e) は set / push で、std:map の ScratchMap(k, v) は set / update で要素を差し替えるため、その型引数は不変(invariant)である(std/array.md §3・std/map.md §3.1)。同じ std でも不変な値である SortedMap(k, v) / InsertionMap(k, v)(std/map.md)と OrderedSet(e)(std/set.md)は差し替える経路が無いので共変である。静的検査での扱いは static-analysis.md §2.10「可変コンテナー位置の不変性」。

可変コンテナーの実行時の型照合でも、構築時に確定した型引数の一致を要求する。コンテナーが空でも型引数は失われず、Array(Int) は Array(String) や Array(Any) に一致しない。ScratchMap(k, v) のキー型と値型にも同じ規則を適用する。

可変な位置で確定した型引数 Never も不変である。既存の Array(Never) を
Array(String) の別名として受けることはできない。式自体の型が Never である発散計算と異なり、
空の可変コンテナーは値として存在し、別名からの書き込みを受けうる。
新しく構築する値は期待型から型引数を決められ、不変な List(Never) は List(String) へ共変に扱える。

ユーザーが宣言した enum の型引数は不変である。 enum Box(a) := { MkBox := { value: a |} | MkBox } の Box(Int) の値は Box(Any) の位置へ渡せない — 中身に差し替える経路があるかどうか、不透明かどうか(§17.4.2)に依らない。変性を中身の形から導くと、中身の形を変えただけで型の変性が変わり、タグを伏せて公開した型では利用側から見えない中身が利用側の書ける形を決めてしまうためである。組込の Option / Result / Future と、上に挙げた std の不変なコンテナーは、仕様が中身と変性を定めているので共変のままである。型引数を共変と宣言する手段は無い。

型位置に […] は現れない

値位置の […] は List のリテラル (§7.4) だが、型位置に […] は無い。List 型は型コンストラクター List(T) で書く。

書き方 意味
List(Int) Int のリスト
[Int] 構文エラー。診断は List(Int) を促す
[x: Int, y: Int] 構文エラー。record 型は { x: Int, y: Int |}
[Int, Int | Int] 構文エラー。関数型は { Int, Int | Int }

[T] を List(T) の糖衣として置かないのは 3 つの理由による。

  1. List は型の名前として引ける必要がある。 書き手は List を自分の定義で覆うことができ(下記「型語彙もシャドウできる」)、import したモジュールの型コンストラクターも m.Seq(Int) と名前で引く。型コンストラクターが名前であることは、この覆い・修飾と同じ規則に載る。[T] は構文であって名前ではないので、どちらにも載らない
  2. 型コンストラクターの形が揃う。 Option(T) / Result(T, E) / Future(T) / OneOf(A, B) と書き手のジェネリック宣言はすべて Name(args) 形である。List だけ括弧記法を持てば例外が 1 つ増える
  3. 同じ型に綴りが 2 つある状態を作らない。 型の正準表示 (診断メッセージ・hover) も List(T) の一形である

固定長で異種の並びは tuple (Int, String) に書く (§7.3)。

関数型の位置エントリはパラメーター型である。 { Int, Int | Int } の Int, Int は「スロットの型を宣言順に並べたもの」であって、値位置の要素の並びとは別物である — §17.4 の照合表のとおり、引数名は表示専用で照合は引数数・引数型・結果型だけを見る。値位置の {…} が名前でスロットを宣言するのに対し、型位置では名前を省いて型だけを並べられる、という関係である。

型語彙もシャドウできる: 型の名前は値と同じレキシカルスコープに載るので、書き手が同名を宣言すればそちらが勝つ。type Error := { code: Int |} と書いたファイルでは、以後の e: Error はその書き手の定義を指し、prelude の Error は隠れる(外側スコープの同名を隠すのは §6.1 のとおり衝突ではない)。型語彙は予約語ではない以上、Int / Range / Error のような名前を自分の型に使うことを言語は妨げない。スコープは 1 つなので、同じスコープで同名の型と値を宣言する形は二重の宣言(already-declared)であり、内側の宣言は種別を問わず外側の同名を隠す。型式の位置で引いた名前が値であれば型式にならず、値の位置で引いた名前が型であれば値にならない(§17.1「型式の位置」)。静的検査の解決順は static-analysis.md §2.4「型名の解決順」に従う。

型位置の bare 識別子には規則が 2 つあり、位置で決まる。

  • 型式の位置(注釈 x: T・type の右辺・型コンストラクターの引数・タプル型の要素): 大文字始まりは型参照、小文字始まりは型変数(下記)
  • 構造型の slot-list に置く bare エントリ: 大文字始まりは埋め込み、小文字始まりはメソッドフィールド(§17.5)。ここでは小文字は型変数にならない — { a |} は「a に応答する値」であって「任意の型」ではない

値位置との対応はメソッドフィールドまでである。 {} の値位置では bare 識別子は casing に依らず必須スロットなので、型位置の小文字(「その名前に応答すること」を要求する)とは対応する。大文字の埋め込みだけが対応先を持たない — 別の構造型のエントリを取り込む操作は型の側にしか無く、値の側に相当するものが無いためである。

型変数(type variable): 型コンテキストの bare 小文字識別子は型変数を表す(大文字は具体型参照)。関数型 { … | … } に現れる型変数はその関数型単位で全称量化され(最外周量化)、同一シグネチャ内の同名は同一の型変数を指す。呼び出し側が各呼び出しごとに具体型へ確定する。

値スロットと、その入力型に現れる自由な型変数には別の名前を使う。
{ a: a | a }・{ a: List(a) | a } のように値名が型変数を覆う宣言は not-a-type になる。
宣言順を変えても同じ規則に従う。型を受け取る type a は値スロットではなく、この制約の対象外である。

id := { x: a | x }                              # 型 { a | a }
map: { List(a), { a | b } | List(b) } := { … }  # a, b を量化

境界付き型変数(type set 境界 / interface 境界): 型変数には、確定できる型を制限する境界を付けられる。境界は型変数の初出にアスクリプションで後置する — named 位置は x: a: Number(パラメーター x の型は型変数 a、a の境界は Number)、位置形式はグルーピング括弧で (a: Number)(§3.3 の 1 要素括弧)。境界の後置は一段のみ(a: Number: T は構文エラー)。文の束縛注釈(v: 型 := …)の型位置はアスクリプション非結合(§17.1)のため連鎖形を書けない — グルーピング括弧 v: (a: Number) := … で書く(slot-list 内の named 位置は連鎖形 x: a: Number を書ける)。束縛注釈の境界付き型変数は束縛の値の型に確定する — v: (a: Number) := 3 の v は Int で、値が境界に収まらなければ型エラーである。同一シグネチャ内の同名型変数は同一なので境界は初出の 1 箇所に書く(複数箇所に書く場合は同じ境界でなければ型エラー)。

境界に置けるのは閉じた union(OneOf(...)・そのエイリアス・原始型単体)または構造的 interface(Comparable・Copyable・ユーザー定義 type interface・合成・埋め込み・データ契約を含む TypeRecord、§17.5)——前者は「確定型がメンバーか」、後者は「確定型が interface を満たすか」で閉じる。interface 境界 a: I は「I を満たす単一の型で、同一シグネチャ内の全 a はその同じ型を共有する」ことを表す(union を境界とする type set 境界の同型リンクを interface へ一般化したもの)。境界付き型変数は量化の単位である関数型の中でのみ意味を持つ。

sum := { x: a: Number, y: a | (x + y): a }  # 型 { (a: Number), a | a }
sum(3, 7)  #> 10       (a = Int に確定)
sum(1.5, 0.5)  #> 2.0      (a = Float に確定)
sum(1, 2.0)  # 静的エラー(a が Int と Float に割れる — 混在は不可)
sum("a", "b")  # 静的エラー(String は Number のメンバーでない)

境界は「型の集合」への制約であって値の型ではない。union を直接注釈した x: Number, y: Number は「各引数が Int または Float」を独立に言うだけで混在を許すのに対し、x: a: Number, y: a は「両引数が同じ数値型で、結果もその型」まで表明する(数値多相の正書法。prelude.md §3・std/math.md §1)。interface 境界も同様の対比を持つ — x: Comparable, y: Comparable は「各引数が独立に Comparable」を言うだけで混在を許すが、x: a: Comparable, y: a は「両引数が同じ型で、ともに Comparable」まで表明する:

max := { x: a: Comparable, y: a | if(x < y, { y }, { x }): a }
max(3, 7)  #> 7      (a = Int)
max("a", "b")  #> "b"    (a = String)
max(1, 2.0)  # 型不一致(a が Int と Float に割れる)

型変数の確定と注釈の代入可能性は静的に検査する。
同じ型変数が 1 つの呼び出しで別々の型に確定する形は静的エラーである
(static-analysis.md §3.1)。
無境界の型変数へ Any が流れた場合は Any に束縛する。
境界付きの型変数へ Any を直接渡す形は静的エラーであり、必要な型へのアスクリプションを要求する。

本体の中の型変数は剛である。 シグネチャ(パラメーターの注釈・束縛注釈・内部名注釈)に書いた型変数 a は、その関数の本体の中では何にも当てはまらず、a 自身とだけ等しい型である。a は呼び出しごとに別の型へ確定するので、本体は確定先を 1 つも仮定できない。したがって次の形を静的検査が報告する(static-analysis.md §3.1「剛な型変数」)。

  • a の値を具体型を要求する位置へ置く形 — 注釈位置・具体型のパラメーター・宣言結果型・演算子の被演算子・メンバー参照の受け手・適用の呼び先・可変な位置への書き込み
  • a の値を別の型変数 b の位置へ置く形と、具体型の値を a の位置へ置く形

a の値を置いてよいのは、Any の位置・同じ a の位置、型変数を取る多相な関数・メソッド・値コンストラクターの引数(Some(v)・[v]・xs.contains(v))、全値に定義される操作(== / !=・universal method〔§2.5〕・表示と補間)である。v.matches(type T) で絞り込んだ枝の中では v を T として使える。境界付き型変数(上記)は、境界が数え上げるメソッド・演算子を使える。

id := { x: a | x }
wrap := { x: a | Some(x) }
same := { x: a, y: a | x == y }
peek := { x: a |
  if (x.matches type Int) {
    x + 1
  } {
    0
  }
}
total := { x: a: Number, y: a | x + y }
bad := { x: a | x + 1 }  # 型エラー(a は + を持たない)
cast := { x: a | n: Int := x; n }  # 型エラー(a は Int とは限らない)
five := { x: a | 5: a }  # 型エラー(Int は a とは限らない)

境界付き型変数も呼び出しごとに静的に確定する。
確定型は境界を満たし、同じシグネチャ内の各出現が同じ型を指さなければならない。
確定は型式の中にも及ぶ。record のフィールドや List の要素型を含めて単一化する。
呼び出しを終えても決まらない型変数が値の位置に残る場合は、期待型か注釈を要求して静的エラーにする。
ネストした関数型をまたぐ多相(higher-rank)と無注釈関数の自動多相化は持たない。

17.3 評価前と評価後

名前: 型 は常に「名前が今持つ値(評価前)」を表す。関数を束縛した名前の型は関数型であって結果型ではない:

add: { Int, Int | Int } := { x, y | x + y }  # add は関数(評価前)
r: Int := add(1, 2)  # 呼び出し結果(評価後)を別途束縛

呼び出し g(a) は関数型の結果型を、await f! は Future の payload 型を結果として持つ。
slot の型と inner-name の型は同じ値への独立した表明であり、その整合を静的に検査する。

関数の結果型の宣言: 次の 3 形で結果型を表明できる。

add: { Int, Int | Int } := { x, y | x + y }  # 束縛注釈
add := { inner self: { Int, Int | Int }, x, y | x + y }  # 内部名注釈
add := { x, y | (x + y): Int }  # body 末尾アスクリプション

束縛注釈と内部名注釈は、関数のシグネチャを静的に要求する。
引数型と、末尾式・早期 return・? の失敗 bail が返す値の型をそのシグネチャに照らす。
内部名注釈は、束縛名を持たないメソッドや演算子スロットでも使える。

body 末尾アスクリプションは、返す式自身に対象型を後置する。
その式の評価地点でだけ、静的に証明できなければ実行時照合する。
早期 return や ? の bail も結果型へ静的に代入できなければならないが、
末尾式のアスクリプションによる照合は、末尾式に到達しない経路では行わない。
別の脱出経路で下方変換が必要なら、その値にも明示のアスクリプションを書く。

どの形でも、関数型の注釈を呼び出し時に強制するための包み直しは行わない。
関数値の照合は、検査器が決めたシグネチャを使う
(§17「関数値の実行時の型」)。

Ok(v) だけでは Result(a, b) のエラー型 b が決まらない
(prelude.md §12)。
結果型を宣言するか期待型を与え、値の位置に未確定の型変数を残さない。

17.4 型語彙・型定義・照合

型注釈で使う型の名前は prelude がスコープに載せる(値ではない。§17 冒頭)。型語彙・type 定義・照合の表現はここで確定する。

  • 原始: Int / Float / String / Bool / Unit / Bytes / Any / Never(Never はボトム型。下記照合表と §16.2)
  • 型コンストラクター: List(T) / OneOf(A, B, …) / Option(T)(= Some(T) ∣ None)/ Result(T, E)(E 既定は { kind, message |} の Error。Result(T) ≡ Result(T, Error))/ Future(T)
  • 順序: Ordering(= Less ∣ Equal ∣ Greater)
  • 数値グループ: Number(= OneOf(Int, Float) の透過的エイリアス。閉じた union。主用途は境界付き型変数の境界 a: Number(§17.2)で、単独の注釈 x: Number は「Int または Float」のみを表し引数間の同型は要求しない)
  • 構造的 interface: Comparable(= { compare |}、§9.4 / §17.5)/ Copyable(= { copy |}、§9.5 / §17.5)。prelude 定義の structural 型で、ユーザーも { メソッド名… |} で定義できる。単独の型述語(v.matches(type Comparable)・x: Comparable)としても、境界付き型変数の境界 a: Comparable(interface 境界。§17.2)としても使える
  • 多重度: AtMostOnce(T) / ExactlyOnce(T)(使用回数の制約)/ Borrowed(T)(借りた値)/ Consuming(F)(受け手を消費するメソッド)。prelude 定義の型コンストラクターで、照合は基底型(T / F)に落ちる(§17.8)
  • 効果: Effect(T, …)(結果型と効果ラベルの集合)/ EffectConduit(F)(引数の効果が透過する)と、効果ラベル Io / Fs / Net / Proc / Time / Rand / Mut / Susp。prelude 定義の型コンストラクターとラベルで、関数値のシグネチャに効果の情報を載せる(§17.9)
  • shape: record { x: Int |} / function { Int, Int | Int }(body=結果型)/ tuple (Int, String)
  • 組込値型: Range(§7.6 の遅延シーケンス値の型)/ Error(= { kind: String, message: String |} の shape エイリアス。Result の既定エラー型で Result(T) ≡ Result(T, Error) の Err(Error) が指す)

型の実行時照合

matches・match の型パターン・静的に証明できないアスクリプションでは、次の規則を使う。
束縛・パラメーター・結果などの注釈では、この表による実行時照合は行わない。

型 一致の条件
Any すべての値に一致する
Never どの値にも一致しない
原始型 値がその種類である
List(T) List であり、すべての要素が T に一致する
タプル (T…) 要素数が等しく、各要素が対応する型に一致する
OneOf(T…) いずれかの選択肢に一致する
Option(T) / Result(T, E) タグが対応し、payload がその型に一致する
record / interface §17.5 の各メンバーの規則を満たす。mutable で宣言したスロットは値ではなく宣言型で照合する
関数型 検査器が決めたシグネチャが対象の関数型に一致する
ユーザー定義 enum 完成値であり、所属・タグ・実体化した型引数が一致し、その型引数を当てた全通常スロットの宣言契約を満たす
std の不透明型 値がその名目型に属する。型引数があれば、その一致も要求する
Future(T) Future であり、結果の型が T を満たす。照合で待ち合わせはしない
NonZero(T) 基底型に一致し、値が 0 でない(Float は 0.0 と -0.0 を除く)
多重度型 値の種類は基底型で判定する。使用の規律は静的に検査する

型の別名は展開した型と同じ規則で照合する。
関数型の一致は §17「関数値の実行時の型」に従う。
std の不透明型の値について型引数まで確かめる照合は、健全性の保証を満たす形で実装する。
可変ハンドル Array(T)・ScratchMap(K, V) は、構築時に確定した型引数をハンドルへ保存する。
照合では保存した型引数の一致を要求し、空かどうかや現在の要素から型引数を決め直さない。
別名での参照や同じハンドルを返す更新でも、確定した型引数を保つ。
型引数は不変なので、Array(Int) は Array(Any) にも一致しない。

OneOf の正規化: Never はどの値にも一致しないボトム型(§16.2)であり、union の恒等元である。OneOf(...) は選択肢から Never を除去した形に正規化する — 残り 1 本ならその型そのもの(OneOf(A) ≡ A と同じ退化)、0 本なら Never。したがって OneOf(Int, Never) は Int と同一の型であり、表示も照合も Int として振る舞う。分岐合流が Never を恒等元として扱う(発散アームは合流結果を変えない。static-analysis.md §3.3)のと対称の規則である。

型定義は type で書く:

type Span := { text: String |}  # record 型
type Add := { Int, Int | Int }  # function 型
type Pair := (Int, String)  # tuple 型
type Nums := List(Int)  # 型コンストラクターの適用

type Name := <型式> は右辺の型式(§17.1「型式の位置」)に名前 Name を付ける(:= のみ・immutable)。型コンテキストでは {...}=shape 型(§17.2)、(A, B)=tuple 型、bare 識別子=型参照(§17.2)。角括弧は型位置に現れない(§17.2)。Name は型式の位置で型として引ける(pos: Name)。型名は大文字始まりの慣用(予約語ではない)。

型宣言の右辺も、ほかの型式の位置と同じく宣言した地点で静的に解く(実行時には何も残さない。§17.1「型式の位置」)。並置は段階的な適用なので、type Pos := Int where { n | n > 0 } は (Int where)({ n | n > 0 }) — 呼び出しの結果への適用 — と読まれ、型式にならない。値の不変条件は型式では書かず、検査つきの構築関数で守る(§17.7「他の不変条件の書き方」)。

型に名前を付けるのは type だけである。 x := Int のように値の束縛で型に名前を付ける道は無い(型の名前を値の位置に置く形は静的エラー。§17.1「型式の位置」)。type の名前は差し替えられないので、同じ名前がある時点と別の時点で違う型を指すことは無い。

type Name := <型式> で名付けた型は、照合・等価では基底(展開)型と完全に同一だが、Name を経由して参照された型の表示(エディター支援の hover・型診断メッセージ)では展開形ではなく別名 Name を保つ。注釈なしのリテラルから推論された構造型には別名は付かない(基底型をそのまま表示する)。

出現位置: type Name := <型式> を書けるのはファイルトップレベルと本体の文(文/ブロック body)だけである。ファイルトップレベルでは Name はモジュールの型メンバーになり、他の Name := … と同様に export される(値を持たない・immutable。§13.2)。本体の文では Name をその本体のスコープに載せる。明示したオブジェクトリテラルの slot-list には書けず、構文エラーである — リテラルの slot-list に書ける型のエントリは呼び出しで埋める型スロット type a だけである(§2.2「型スロットを持つリテラル」・§17.4.1)。ファイルも暗黙のオブジェクトリテラルだが(§13.1)、型の置き場所はモジュールなのでここだけ区別する。宣言であって式ではないため、部分式の位置(引数・:= / = の右辺・(...) 内)に現れると構文エラー(§1.5。enum も同じ)。import と違い入れ子リテラルの body には書ける。文として評価されたときの値は unit ()(§1.5。body 末尾に置いても body の値は () — 定義した型は型式の位置で Name と書いて引く)。

ジェネリック型定義: type Name(a, b) := <型式> / enum Name(a) := <タグ定義領域> は LHS の頭部で型パラメーター(小文字型変数)を束縛し、RHS でそれを参照する。

type Pair(a, b) := (a, b)
enum Box(a) := { MkBox := { value: a |} | MkBox }
enum Either(a, b) := {
  export { Lft(value), Rgt(value) },
  Lft := { value: a |},
  Rgt := { value: b |}
| OneOf(Lft, Rgt) }

適用 Pair(Int, String) は (Int, String) に展開する。arity 不一致は型エラーである。
type は透過的で、基底型と構造的に同一である。表示には別名を保つ。
再帰する別名も同じで、別々に宣言した同じ形の別名は同じ型である — type L(a) := { v: a, next: Option(L(a)) |} と同じ形に宣言した M(a) について、L(Int) と M(Int) は代入でも実行時の照合でも区別しない。
展開で型引数が育つ再帰 (type T(a) := { v: a, next: Option(T(List(a))) |}) も宣言できる。
再帰定義と適用する型引数を保持し、値の成分へ降りるときに必要な部分を展開する。
有限の値が深いことを理由に照合を打ち切ることはない。空のコンテナーは未訪問の要素型を照合しない。
OneOf の候補を調べることは、値の成分へ降りることとは区別する。
有限回の型引数の置換で一致する候補に到達するなら、候補の入れ子が増えても照合は成功する。

type F(a) := List(F(List(a)))
empty: Any := [[[[[[[[[[]]]]]]]]]]
wrong: Any := [[[[[[[[[1]]]]]]]]]
empty.matches type F(Int)  #> true
wrong.matches type F(Int)  #> false

ただし型同士の比較は展開が尽きないので、別の別名とは構造で比べず、同じ別名の適用同士が型引数で一致するときだけ同じ型とする。
enum の型パラメーターは状態と公開操作で共有し、未確定なら期待型または注釈を要求する。
宣言・構築・実行時の詳細は §17.4.2 に従う。

enum の名前はタグを引く受け手になる。 enum Shape := { Circle := { radius: Float |}, Empty := {} | OneOf(Circle, Empty) } のタグは型 Shape の下に置かれ、次の 2 つの形で引く。どちらも型を値として扱うのではなく、型の下のタグの名前を引く形であり、書いた地点で静的に解ける。

  • 修飾したタグ Shape.Circle / Shape.Empty(import したモジュール越しの m.Shape.Circle も同じ)
  • 名前リストによる取り出し { Circle, Empty } := Shape(§6.3)。右辺は型式として読める enum の名前である(Shape・m.Shape)

Shape を値の位置に置く他の形(s := Shape・f(Shape))は、型の名前一般と同じく静的エラーである(§17.1「型式の位置」)。

enum は宣言した位置で識別する。 2 つの enum が同じ型であるのは、同じ宣言を指すときだけである。名前が同じでも宣言が違えば別の型で、そのタグの値も別の所属を持つ(§9.1)。

  • トップレベルの宣言は、宣言したモジュールと名前で識別する。モジュールは、std なら std: の名前、パッケージの中のファイルならパッケージ(取得元・版)とパッケージの中のパス、それ以外のファイルなら解決した後のパスで識別する(§13.4 の import のキャッシュと同じ基準)。同じパッケージの別の版の宣言は別の型である。
  • 本体の文の中の宣言は、囲むスコープの位置まで含めて識別する。評価のたびに新しい型ができることはない。外側の同名を隠した宣言(上記「出現位置」)は、外側とは別の型である。
  • import・type の別名・再公開は同一性を変えない。
  • 表示は名前だけを書く。診断に別々の同名の型が並ぶときの書き方は static-analysis.md「診断に載せる型の綴り」が定める。

名前付きと位置は混ぜられない

function 型の slot-list は、すべて位置({ Int, String | Int })かすべて名前付き
({ x: Int, s: String | Int })のどちらかである。
混ぜた綴り({ x: Int, String | Int })は
静的検査が報告する(static-analysis.md §2.4)。

位置形が基本である。 関数の値 { params | body } の各 param を型で置き換えたものが関数型なので、
型の側に名前は要らない。高階の型(map: { List(a), { a | b } | List(b) } の内側 { a | b })には
そもそも与えるべき名前が無い。名前付きの綴りが書けるのは値と型で {…} の文法を共有しているためで、
関数型のパラメーター名は照合に参加しない — { x: Int | Int }・{ y: Int | Int }・{ Int | Int } は
同じ関数に一致する(§17.4 の照合は arity と型だけを見る)。名前は読み手への注記である。

混在を禁じるのは、混ぜると書いた順が保てないためである。位置エントリとスロットは別の列に載るので、
混在した綴りは位置エントリを先に並べた形になり、{ x: Int, String | Int } は「第 1 引数が String」の
関数型になってしまう。名前が照合に参加しない以上、混在を許して並び順の規則を読者に負わせるより、
書けなくする方が安い。混ぜない綴りは書いた順のままである。

呼び出しで埋める型スロット type a はこの規則の外にある — 位置形・名前付き形のどちらの関数型にも置け、書いた順に引数を受ける(§17.4.1)。

17.4.1 呼び出しで埋める型スロット type a

型は値ではない(§17 冒頭)が、実行時に型を要する関数はある — 文字列を指定した型の値へ読む json.decode(text, type Config) がそれである。こうした関数は、slot-list に呼び出しで埋める型スロット type a を持つ。

decode := { text: String, type a | … }  # a は呼び出しで埋める型スロット
decode: { String, type a | Result(a) }  # 同じ関数の型
cfg := decode(text, type Config)  # 結果型は Result(Config) に確定する

値のスロット x と並ぶ、型のための必須スロットである。 値のスロット x が呼び出しで値を受け取るのと同じく、type a は呼び出しで型を受け取る。値のスロットの x := 1 にあたる「型のデフォルト値」は無い — リテラルの slot-list に type A := Int は書けない(§17.4「出現位置」)ので、slot-list の type はいつも呼び出しで埋める型スロットである。

  • スロット名がそのまま型変数の名前になる。 呼び出しごとに違う型が入るので型変数であり、名前は小文字で書く(型式の位置の小文字は型変数。§17.2)。大文字で始まる名前(:= を持たない type A)は構文エラーである — 型式の位置の大文字の名前は型の参照であり、型変数にならない。
  • 関数型の側も同じ綴りで書く。 値の slot-list から名前を落とすと関数型になる(§17.4「名前付きと位置は混ぜられない」)が、型スロットの名前は型変数そのものなので落とすものが無く、type a のまま残る。type a のエントリは位置形・名前付き形のどちらの関数型にも置ける({ String, type a | Result(a) }・{ text: String, type a | Result(a) })。
  • 型スロット宣言の type a を書けるのは、リテラルの slot-list と関数型のエントリだけである。 文としての type a(:= を持たない型宣言)と、structural 型のエントリ({ type a |})は構文エラーである。ファイルトップレベルも slot-list だが、ファイルはロードで完成するので呼び出しで埋めるスロットを持てない(§13.1。デフォルト値を持たない値のスロットと同じく静的エラー)。呼び出し実引数の type T は型スロット宣言ではなく、下記の型引数である。
  • 境界は持たない。 type a に Comparable のような境界を付ける綴りは無い。

呼び出し

呼び出しの実引数に type T と書くと、T を型式として読む(§17.1「型式の位置」)。これも型引数と呼ぶ(型コンストラクターへ当てる List(Int) の Int と同じく、型そのものを渡す引数である)。実引数が型引数かどうかは呼び先の静的型ではなく、type の有無だけで決まる。括弧呼び出しと並置呼び出しのどちらにも書ける。

decode(text, type List(Point))  # 型コンストラクターの適用も書ける
decode text type List(Point)  # 並置でも同じ
  • 呼び出しで埋める型スロットは未束縛のスロットとして arity に数える(§3.5 の R)。部分適用もそのまま働く(decode(text) は型引数を待つ関数)。
  • 型引数の位置に裸で書いた小文字名は、実行時に確定している型変数(呼び出しで埋める型スロットの型変数・境界付き型変数)でなければ undefined: <名前> として報告する。§17.1 の型式の規則に従う。
  • 1 つの type は 1 個の型引数を表す。型引数を含む複数の実引数を、型スロット 1 つへ暗黙にまとめることはない(§3.5)。
  • 型引数と値引数は書いた順に未束縛スロットへ対応する。type を付けた引数だけを後方の型スロットへ振り分けない。既知の値スロットへ型引数を渡す形は静的エラー、既知の型スロットへ値を渡す形も静的エラーである(static-analysis.md §2.4)。
  • 呼び先には静的な型が必要であり、型スロットの位置も静的に検査する。Any を関数として直接呼ぶことはできない。型引数は、静的に受理した型スロットへ実行時にも渡る。
  • 型変数の確定は他の型変数と同じく呼び出し単位である(§17.2)。型引数が a を確定させるので、a を結果型に書けば渡した型が結果型へ運ばれる。

type T を書けるのは呼び出しの直接の実引数だけである。型引数全体を一般の括弧式にした (type T)、値の束縛 x := type T、リスト要素 [type T] は構文エラーになる。型式自身を括ることはできるので、f(type (A, B)) の (A, B) はタプル型 1 個である。

並置の type が取るのは型式の 1 項だけである。 1 項とは、裸の名前(Int)・メンバー(m.T)・括弧の適用(List(Int)・m.Seq(Int))・括弧で括った型((A, B))・structural 型({ x: Int |})のどれか 1 つで、その後ろの並置は外側の適用へ戻る。並置は型式を作らない(§17.4)ので、k type Int x は k (type Int) x — Int を型引数、x を値引数とする 2 段の適用 — であり、Int x を型式として読むことはない。

本体の中の a

本体では a を型式の位置でだけ使える — v.matches(type a)・注釈 x: a・別の型スロットへの型引数(json.decode(s, type a))。a は型であって値ではないので、値の位置に置く形(t := a・println a)は静的エラーである。

import json := "std:json"
all_match := { vs: List(Any), type a | vs.all { v | v.matches type a } }
my_decode := { s: String, type a | json.decode(s, type a) }  # 結果型 Result(a) が保たれる

a は実行時にも確定している。 無境界の型変数が実行時に消去される(§17.2)のとは違い、呼び出しで埋める型スロットには呼び出しが型引数を渡すので、本体の v.matches(type a) と式アスクリプション v: a の実行時照合では受け取った型を使う。束縛注釈 x: a の代入可能性は静的に検査する。静的には a は他の型変数と同じく剛である(§17.2「本体の中の型変数は剛である」)。v.matches(type a) で絞り込んだ枝の中では v を a として使える。

型スロットは値として取り出せない

関数の引数とオブジェクトのスロットは同じものなので、呼び出しで埋めた型スロットは値の中に残る — 部分適用の値(§3.7)・body を省略したリテラルが返す完成値(§2.2)・inner_bound の指す値(§4.2.1)がそれである。オブジェクトは型を持てるが、型を値として取り出す道は無い。

k := { type a, x: Any | x.matches type a }
p := k type Int  # a に Int を埋めた部分適用
p.a  # 静的エラー(type-in-value-position)
{ a } := p  # 静的エラー(同上)
  • 値の位置で読めない(上の例)。モジュールの型メンバーを値の位置で読む形(m.T)と同じ扱いである。
  • 型式の位置でも読めない。 モジュールの型メンバーは宣言で中身が決まるので x: m.T と書ける(§17.1「型式の位置」)が、呼び出しで埋めた型スロットの中身は呼び出しごとに違い、書いた地点で静的に解けない。x: p.a は型式ではない。
  • 等価には数える。 2 つの値の型スロットは、埋まった型の同一性で比べる(§9.1)。k(type Int) == k(type String) は false である。
  • 表示には出ない。 表示(println / inspect)は型スロットを載せない。

17.4.2 タグ原型と公開範囲

ユーザー定義 enum は、タグ原型を同じ領域に定義し、その領域の本体でタグ集合を指定する。
タグ原型は本体を省略した不変な値リテラルであり、状態と普通の関数スロットを持てる。

enum Box(a) := {
  export { Mk(value), Empty },
  Mk := {
    export { read },
    value: a,
    inner_bound self,
    read: {| a } := {| self.value }
  |},
  Empty := {}
| OneOf(Mk, Empty) }

b := Box.Mk(3)!
b.read!  #> 3

read は Mk だけが持つ操作なので、Box(Int) と注釈した値からは引けない — 全タグが公開する操作だけを Box(Int) の値で使える (下記「enum と特定タグの型・操作」)。

タグ定義領域

  • 領域の slot-list は export とタグ原型の直接の定義だけを持つ。補助関数・定数は外に置く。
  • 各原型はその場に書いた不変な、本体を省略したリテラルだけである。変数・関数結果・別の原型の流用は認めない。
  • 原型直下に呼び出しで埋める type a は置けない。enum 頭部の型パラメーターを使う。
    操作の関数リテラル内に独立した type b を置くことはでき、普通の型引数と部分適用で扱う。
  • 領域本体は、自領域のタグ名一つ、または自領域のタグを列挙した非空の OneOf(Tag, …) だけである。
    全原型を丁度一度列挙し、他領域のタグ・式・重複・未列挙の原型は認めない。
  • 原型に明示した本体、直下の型スロット、流用などは invalid-enum-definition になる。
    enum E := Tag(T) や enum E := OneOf(Tag(T), Empty) は文法にない。

タグ名の公開と位置分解

タグ定義領域の export は最大一つで、省略は全タグ名の公開、export {} はタグ名を公開しない。
タグ名の公開は原型のスロット名の公開と独立している。
裸の項目 Tag はタグ名だけを公開し、Tag(slot, …) は位置分解列も宣言する。
export を省略しても位置分解列を生成しない。

分解列は、その原型に直接宣言した通常の値スロットの、宣言順を保つ非空の部分列である。
関数スロットも列に含められる。非公開スロットを列に含めても、そのスロットの名前は公開されない。
逆順・重複・未定義名・型スロット・inner 名は invalid-public-decomposition になる。
空の Tag()、タグ項目と分解項目の型注釈、改名・ワイルドカード・式は構文エラーである。

enum Pair := {
  export { Mk(left, right) },
  Mk := { export {}, left: Int, right: Int |}
| Mk }
p := Pair.Mk(1, 2)
match p { Pair.Mk(x, y) => x + y }  # 3: 名前を公開せずに位置分解できる
p.left  # 別ファイルからは private-member-access
# export { Mk(right, left) } は invalid-public-decomposition
# export { Mk() } は構文エラー

構築・部分適用・完成状態

タグ原型の適用は通常のスロット宣言順を使う。公開・非公開と位置分解列は構築の入力を変えない。
上の Box.Mk は value と read の二つの未束縛入力を持ち、Box.Mk(3) は部分適用である。
Box.Mk(3)! は read のデフォルト値を補完して完成する。第二入力に関数を明示してもよい。
必須入力を残した kick は必須スロット不足になる。許す入力を限定したい場合は通常の構築関数を公開する。
本体を実行して返った任意の値に、処理系がタグを付けることはない。
所属とタグは通常のスロットではなく、別名・適用・部分適用・コピー・コンテナー・Any を経ても保持する。

型引数の確定と保存

enum 頭部の型パラメーターは状態、操作の入力・結果、再帰参照で共有する。
型引数は不変であり、実引数と構築結果の期待型から確定する。
確定した部分適用の型引数を後続の適用で推論し直すことはない。
状態に現れない型引数と空タグの型引数も完成値に保存する。
ジェネリック関数内で作った値でも、呼び出しで確定した型引数を保存する。
状態を持つタグでも、型引数の保存によって共有する不変なデフォルト値を変更しない。
List・Option・record などに包んだ値の照合でも、内側の完成値が保存した型引数を比べる。
共有するデフォルト値中の、可変状態や自己参照を含まない包みでも、呼び出しごとの型引数は他の呼び出しへ影響しない。
未確定のまま値を置くと unresolved-type-argument になり、暗黙の Any・Never・union で補完しない。
同じ型パラメーターへ異なる型を渡すには OneOf(Int, String) などの期待型を明示する。

enum MyOption(a) := {
  export { Some(value), None },
  Some := { value: a |},
  None := {}
| OneOf(Some, None) }
x: MyOption(Int) := MyOption.None
# MyOption.None を期待型なく値へ置くと unresolved-type-argument

enum Duo(a) := { Mk := { left: a, right: a |} | Mk }
d: Duo(OneOf(Int, String)) := Duo.Mk(1, "a")
# Duo.Mk(1, "a") を期待型なく構築すると型不一致
type IntOption := MyOption(Int)
n: MyOption(Int) := IntOption.None
n.matches(type IntOption.None)  # true: 型引数を固定したタグ述語
n.matches(type MyOption.None)  # true: 型引数を問わない完成タグの述語
s: MyOption(String) := MyOption.None
n == s  # false: スロットがなくても型引数を比較する

取り出した操作の型も enum の確定した型引数を保持し、新しい独立した型変数として量化しない。
再帰ジェネリック型と自身の enum を返す操作も宣言できる。
推論が循環する位置には通常の型注釈を要求し、型グラフは有限の共有と循環として扱う。

enum と特定タグの型・操作

型位置の E.Tag は完成したその所属・タグの値を表す。
ジェネリック型の裸の Box.Mk は型引数を問わないタグ述語であり、Box(Any) を意味しない。
type IntBox := Box(Int) を経た IntBox.Mk は、値位置では Int を固定した原型、
型述語・パターンでは Int を固定したタグである。
型位置の Box.Mk(Int) と Box(Int).Mk は認めない。
未完成の原型と部分適用値は完成した enum の型とタグ述語に一致しない。

名目型の照合は公開・非公開に関係なく、所属・タグ・保存した型引数と全スロットの契約を検査する。
状態に現れない型引数も照合するので、空タグでも Box(Int) と Box(String) は区別できる。
同じ形の record に型注釈を付けても enum の所属を獲得しない。

enum 全体の操作は、非公開タグも含む全タグが名前で公開し、同じ完全な関数契約を持つものだけを静的に使える。
候補を絞り込んだ型でも、その全候補で同じ規則を使う。異なる契約の暗黙の overload や union は作らない。
実行時の構造照合は実際のタグ値の公開スロットで判定するので、そのタグだけが持つ操作にも一致しうる。

パターンと網羅性

  • 裸の E.Tag は完成値の所属・タグだけを判定し、欄を取り出さない。
  • E.Tag(pat, …) は宣言した公開位置分解列だけを使い、その列と同じ要素数を要求する。
    定義元のファイル内でも同じ列を使う。裸の公開項目または export 省略のタグは位置分解できない。
  • E.Tag { slots } は所属・タグの判定と、そのタグ値に対する通常の名前付きレコードパターンを組み合わせる。
    非公開名は外部から読めず、定義元で内部表現が特定できる場合は読める。
  • Some({ slots }) は位置分解した一つの値へレコードパターンを適用する。
    Some { slots } はタグ値自身のスロットを照合する。
  • ユーザー定義タグ値はタグを伴わない位置分解・タプルパターン・.0・.[0] で通常スロットを読めない。
    v.Tag も通常のメンバー参照であり、内部表現を取り出す特別な意味を持たない。

非公開タグ原型の別名を値として公開すれば、その値の通常の適用で構築できる。
その別名はタグの型述語・パターンを書く権限を与えない。
大文字の構築関数と enum を返す関数もタグとして照合できない。
タグの名前は定義元か、タグ名を公開した型を参照できる位置で使う。
再公開は定義した公開メンバー集合をそのまま渡し、新しいタグ権限を与えない。

網羅性は非公開タグも含む実際の候補集合を検査する。
外部から名前を使えない未被覆タグがあれば catch-all を要求し、non-exhaustive-match に非公開名を列挙しない。
絞り込み済みの候補にないタグは要求しない。
ガードと一部の値だけを覆う副パターンは、そのタグ全体の被覆にならない。
型引数を固定した別名のタグパターンも、その実体化だけを覆う。

不透明型と観測

型名を公開し、タグ定義領域でタグ名を公開しない enum はユーザー定義の不透明型になる。
利用側は型注釈・型引数・matches と、値が公開した通常の関数スロットで扱う。
std の不透明型はホストが値を持ち、そのモジュールの名目型として識別する。
std の公開操作を取り出した関数も、受け手を束縛した入力・結果・型引数・効果・多重度・制御透過の契約を保持する。
取り出しによって受け手入力を追加せず、部分適用・コンテナー・捕獲を経てもその契約を保持する。
閉じた資源の操作は資源の規則に従って失敗する。

既定の表示と明示した既定の inspect は非公開状態とタグも表示するが、関数スロットを呼び出さない。
公開した独自の inspect は明示呼び出しでだけ使い、print・補間の自動表示は既定表現を使う。
公開範囲は秘密保持の保証ではない。既定の等価と複製は全通常スロットと所属・タグ・具体化した型引数を扱う。
ユーザー定義 enum の JSON 変換は対応外である。json.decode は Error、json.stringify は Err(unsupported) を返す。
std:json の Value は専用の JSON 値として対応する(std/json.md)。

17.5 構造的 interface(メソッド契約)

構造照合は、record・関数値・ユーザー定義 enum の公開メンバー集合だけを使う。
定義元で内部アクセスできることも、非公開スロットを interface の要求へ数える根拠にならない。
デフォルト値から推論したパラメーター型の実行時照合でも、要求する record の欄は公開分だけを使う。
本体で非公開名にアクセスできることは、静的検査が別に証明する。
std のホスト操作はその公開した契約で照合する。

structural 型 { … |} は、データ契約(x: 型)とメソッド契約(bare 名)を 1 つの型で表す。メソッド中心のものを interface と呼ぶ。Comparable・Copyable はこの仕組みの上に prelude 定義された型であり、組込の特別な型ではない(§9.4 / §9.5 / prelude.md §13・§15)。ユーザーも同じ構文で定義できる。

エントリ(§17.2 の型位置 { … |}):

  • メソッドフィールド m(bare 小文字): 「値が m に応答する」ことを要求する(callable であればよい)。シグネチャまで契約するなら m: { In | Out }(型付きフィールドの型に関数型を置く形)。§17.4 の関数型の照合で、検査器が決めたシグネチャの引数数・引数型・結果型を確かめる。bare m は応答のみ、m: 関数型 はシグネチャまで。
  • 型付きフィールド x: 型(named): 現行 record shape と同じデータ契約(余分な slot 可・幅構造型)。型 が関数型なら上記のメソッドシグネチャ契約になる(メソッドフィールドの上位互換で、構文は非破壊)。
  • 埋め込み Name(bare 大文字): Name が指す structural 型の全エントリを取り込む。構築時に展開する。structural 型でない値の埋め込みは型エラー。
type Comparable := { compare |}  # compare に応答する値
type Copyable := { copy |}
type Drawable := { draw, area |}  # 複数メソッド
type CompCopy := { compare, copy |}  # 合成
type Point := { Comparable, x: Int, y: Int |}  # 埋め込み+型付きフィールド

応答の定義とベースライン: universal method(§2.5)は、値が自前スロットを持たなくても組込ディスパッチで応答する(=ベースライン)。ベースラインの範囲:

method ベースラインで応答する値
compare 原始型 Int/Float/String/Bool/Unit(§9.4)
copy Copyable な値(Future / 非 Copyable な opaque 以外。§9.5)
apply_when / inspect / matches / reference_equals / -> 全値

ベースラインを持つ名前と、メソッドフィールドに書ける名前は一致しない。 メソッドフィールドは bare 小文字の識別子だけなので(§17.2)、記号綴りの -> を要求する interface({ -> |})は書けず構文エラーになる。-> のベースラインは §2.5 の universal method としての解決 — v.->(x) の名前解決と、スロットを持たない受け手での中置 — にだけ現れる。

ユーザー定義メソッド(draw 等)は、callable な自前スロットで応答する。std の不透明型はメソッド表のメソッドでも応答する。

照合規則(v.matches(type { … |}) / アスクリプション / match の型パターン)。
静的検査と実行時照合は同じ規則を使う。各エントリについて次を確かめる。

  • メソッドフィールド m: v に効くベースラインがあれば一致する。
    無ければ、callable な自前スロット m、または std の不透明型のメソッド表の m があれば一致する。
  • 型付きフィールド x: 型: 自前スロットの値の型が、要求する型に一致することを確かめる。
    mutable で宣言したスロットは値ではなく宣言型で照合し、宣言型が要求する型と同じ型であるときに限って一致する。
    値は別の名前から書き換えられるが宣言型は変わらないので、今の値で一致させると、絞り込んだ視点が正当な書き込みの後に偽になるからである。
    型を書かずに宣言したスロットは、デフォルト値から推論した型を宣言型とする。
    ただし、リテラルを期待型のある位置へ直接置いたときは、期待型のそのフィールドの型が宣言型になる — その位置ではリテラルの欄をフィールドの型で検査し、以後その値をフィールドの型で書き換えられるからである。
    record と関数値のどちらのスロットでも同じである。
    std の不透明型は、メソッド表にあるそのメソッドのシグネチャまで照合する。
    ベースラインは型付きフィールドを満たさない。名前が universal method でも(count: Int・compare: { Int | Ordering })、
    ベースラインで応答する組込のメソッドは自前スロットではないので、[1, 2].matches(type { count: Int |}) は偽である。
  • 埋め込み: 展開後のエントリ列に同じ規則を適用する。

関数型の照合は不変であり、検査器が決めたシグネチャを見る
(§17「関数値の実行時の型」)。
結果型を宣言しない関数も、推論した結果型で照合する。

type Adder := { add: { Int | Int } |}
{ add := { x: Int | x } |}.matches type Adder  #> true
{ add := { x: String | x } |}.matches type Adder  #> false
{ add := { x: Int | "s" } |}.matches type Adder  # 結果型 String なので一致しない

mutable でないスロットは値で照合する。

o := { mutable v: OneOf(Int, String) := 1 |}!
o.matches type { v: Int |}  #> false
o.matches type { v: OneOf(Int, String) |}  #> true
{ mutable v := 1 |}!.matches type { v: Int |}  #> true
{ v: OneOf(Int, String) := 1 |}!.matches type { v: Int |}  #> true

メソッドシグネチャ契約 m: { In | Out } は型付きフィールドである。
メソッド名だけの m と異なり、引数数・各引数型・結果型まで一致しなければならない。
std の不透明型を共通の操作で受ける場合は、この interface を使う。

{ compare |} は Comparable、{ copy |} は Copyable と同値である。
自前の compare スロットで Comparable を満たすには、そのスロットが
受け手の型の値 1 個を受けて Ordering を返す関数でなければならず、静的検査がこれを要求する。
sort・max・< ほか Comparable を求める位置は、受け手と同じ型の値を渡して結果を順序として使うからである。
要求の無い空 interface {|} は全値に一致する top 型である。
Any の値からメソッドを参照するには、必要な interface に絞り込む。

Sequence — 要素の並びを持つ契約

Sequence は整数添字で引ける要素の並びを持つことを表す prelude 定義の interface である。 Comparable / Copyable と同じ仕組みの上に立ち、組込の特別な型ではない。

実装するのは List (§7.4)・String (§7.2)・Bytes (§7.2.2)・range (§7.6) の 4 つで、オブジェクトは実装しない — オブジェクトが持つのは名前で引くスロットだけだからである (§2.1)。

method 意味
length / is_empty 要素数。is_empty は length! == 0 と定義される (独立した測度ではない)
recv.N / recv.[i] 添字で引く (§3.2 / §3.10)。範囲外は実行時エラー
positions / has_position 添字の列挙と存在確認
first / last 先頭・末尾の要素
each / map / filter / fold 走査。map / filter は List を返す
find / any / all / count 述語による検索・判定・計数
to_list List への実体化

各 method の形と戻り値は prelude.md §6 に集約する。

タプルは一部だけを持つ — 位置アクセス (t.N / t.[i]) と length のみで、is_empty は持たない (唯一の空値が () であり判定に意味が無いため。prelude.md §7)。したがってタプルは { length |} には一致するが Sequence の全体には一致しない。

(1, 2).matches type Sequence  #> false
(1, 2).matches type { length |}  #> true
a, b := (1, 2)
a + b  #> 3

要素はいずれも不変である。 recv.N = v / recv.[i] = v は静的に拒否する。
診断の規則は §3.10 に従う。
任意添字への O(1) 散在書き込みが要る場合は std:array(std/array.md)を使う。

要素の位置分解は Sequence の照合とは別である。 タプル destructure a, b := v は、タプルまたは上の 4 つの組込型の要素を取り出す (§6.3)。タプルは Sequence に一致しなくても分解できる。これら以外の値は位置分解できない。

17.6 公開する型契約

export { name: T } は、公開する値が T へ静的に代入できることを要求し、利用側の静的型を T にする。
ファイルでも値リテラルでも、普通の型注釈と同じ検査である。
型注釈は実際の公開メンバー集合を固定する定義とは独立し、値の identity・所属・スロットを変更しない。

静的型 T にない名前は直接参照できないが、実際の公開メンバー集合がより広ければ、
その公開型への matches やアスクリプションで絞り込める。
非公開スロットを要求する構造型には、定義元のファイル内でも一致しない。
注釈・再公開・関数結果・コンテナーの境界で、入れ子の値の公開メンバー集合を変更しない。
内部状態の宣言と使用は通常の名前解決・型・可変性の規則で検査する。

構造的 interface は型述語にも型変数の境界にも使える。
境界 a: I は「I を満たす単一の型を、同一シグネチャ内の全 a が共有する」と表明する。
型述語・アスクリプション・境界とも公開メンバー集合の同じ照合規則を使う。

17.7 非ゼロ数値型 NonZero(T)

NonZero(T) は 0 でない数値を表す型である。T は Int か Float に限る。prelude がスコープに載せる型コンストラクターで(prelude.md §3.3)、除数として使える値(§7.1)を型として書き下すためにある。

d: NonZero(Int) := 3
x: NonZero(Float) := 2.5
17 / d  #> 5
1.0 / x  #> 0.4

型引数が Int / Float 以外の形(NonZero(String))と、型引数の個数が 1 でない形は、型を解く地点で静的エラーになる(static-analysis.md §2.4「NonZero の型引数」)。

非ゼロ数値型の照合

NonZero(Int) は 0 でない Int に一致する。NonZero(Float) は 0.0 と -0.0 のどちらでもない Float に一致する — NaN と ±Inf は 0 でないので一致する。-0.0 も除くのは、-0.0 での除算も実行時エラーであり、0.0 と -0.0 が全順序では別の値だからである(§9.4)。

5.matches type NonZero(Int)  #> true
0.matches type NonZero(Int)  #> false
(-0.0).matches type NonZero(Float)  #> false

式アスクリプション 値: NonZero(T) は、静的に確かめられなければ評価地点で照合し、0 なら型不一致として panic する(§17「注釈とアスクリプション」)。

非ゼロ数値型の境界

NonZero(T) は基底型 T の部分型である。d: NonZero(Int) は Int の位置へそのまま渡せ、算術も比較もそのまま書ける。

逆向き — NonZero(T) を要求する位置(束縛・分解束縛・パラメーター・デフォルト値・結果・enum 原型の通常スロット・コンテナーの要素)へ値を渡す — では、値が次のどちらかでなければ静的エラー(型不一致)になる(static-analysis.md §2.11)。

  • 非ゼロの定数: 0 でない数値リテラル、その単項マイナス、それを束ねた不変な名前(別名の連鎖を含む)。定数同士の算術は評価しない(2 * 3 は定数として数えない)
  • 静的型が NonZero(T) の式: NonZero(T) と宣言した名前・パラメーター・結果、およびアスクリプション 式: NonZero(T)

算術の結果は NonZero(T) を引き継がない。 d: NonZero(Int) について d - 1 も -d も静的型は Int である — 区間や値同士の関係は追わない。

条件で確かめた名前はその枝で NonZero(T) に絞られる(static-analysis.md §2.3)。n != 0・n > 0・n < 0・n >= 1 のように、比較が 0 を除くことを含意する形が対象である。Float は 0.0 と -0.0 の両方を除く比較(x > 0.0・x != 0.0 && x != -0.0)だけが絞る。

f := { n: Int |
  if (n != 0) {
    d: NonZero(Int) := n
    10 / d
  } {
    0
  }
}
f 2  #> 5

期待型の無い分岐合流(static-analysis.md §3.4)では、両枝が NonZero(T) なら NonZero(T) を保ち、片方が基底型 T なら T へ合流する。

他の不変条件の書き方

NonZero(T) が型として表すのは「0 でない」だけである。範囲(「1 以上 100 以下」)・形式(「@ を含む」)・フィールド同士の関係のような不変条件は、型ではなく検査つきの構築関数で守る。値を enum に包んでタグを伏せて公開し(§17.4.2)、検査を通った値だけを Ok で返す構築関数を置けば、ファイルの外ではその構築関数を経ない値を作れない。

17.8 多重度型(使用回数を載せた型)

本節が定める型は、値を記述する型ではなく使用を制約する型である。Hikari の型が担う意味をここで一段広げる。 これまで型はすべて値について語ってきた — Int は値の種類を、NonZero(T)(§17.7)は値が 0 でないことを、構造的 interface(§17.5)は値が応答するメソッドを述べる。本節の型はそうではない。同じファイルハンドルが、ある位置では所有され、ある位置では借用される。値は何も変わっていない。

語の範囲を先に定める。多重度型とは AtMostOnce(T) / ExactlyOnce(T) の 2 つを指す — 値をこれから何回使えるかを述べる型である。Borrowed(T) と Consuming(F) はそれに付随する語彙で、前者は多重度型の値を借りた位置を、後者は受け手を消費するメソッドを表す。この 2 つは多重度そのものを述べるわけではないので、Borrowed(Borrowed(T)) のような重ね掛けには意味が無い。

多重度型コンストラクター(AtMostOnce / ExactlyOnce / Borrowed / Consuming)の基底に、同じコンストラクターをその場で重ねて書くことは、宣言の時点で型エラーとする。 重ね掛けに意味が無い以上、診断を出さずに受け取ると「書いたのに効かない」位置ができる。判定は書かれた位置の構文だけで決まり、基底が解決できない位置(型変数・解決できない名前)では報告しない。

別名を経由した重ね掛けは報告しない。 type B := Borrowed(Int) と書いてから Borrowed(B) と書く形がこれにあたる。判定が構文だけで決まることの当然の帰結で、見逃し側である。名前を追って判定する形にはしない — 追うと次の Borrowed(M) の正規の書式(M が多重度型の別名である形)と区別が付かなくなり、正しいコードを誤検出する。重ね掛けは「書いたのに効かない」だけで安全性には影響しないので、誤検出を避ける側に倒している。

Borrowed(M)(M が多重度型)は重ね掛けではなく借用の正規の書式である。 多重度型の値を借りた位置を表すのが Borrowed の役目なので、基底が多重度型であることは当然である。type H := ExactlyOnce({ … |}) に対する Borrowed(H) も、std のハンドル型に対する Borrowed(arr.Array) も、どちらもこの形にあたる。上の禁止が対象にするのは、その場でコンストラクターを 2 つ並べて書いた Borrowed(Borrowed(T)) や AtMostOnce(ExactlyOnce(T)) である。

上の性格から次の 2 つが帰結として導かれる(下記「多重度の実行時照合」)。いずれも個別の例外規定ではない。

  • 実行時に照合するものが無い — その地点に存在するのは値だけで、使用の履歴ではないため。
  • matches は基底型の判定に落ちる — 同じ理由による。

内在と文脈で性格が分かれる点も定めておく。AtMostOnce / ExactlyOnce は資源に内在する(ファイル記述子は本当に一度しか閉じられない)。Borrowed は文脈依存であり、値ではなくその位置で許された操作を述べる。

この 4 つはいずれも prelude がスコープに載せる型コンストラクターであり、新しい予約語も新しい記号も持たない(§1.2.2 / §1.4 の予約語は増えない)。Comparable / Copyable が組込の特別な型ではなく prelude 定義の構造型である(§17.5)のと同じ位置づけで、書式は List(T) / Option(T) と同じ型コンストラクターの適用に乗る。本節は型語彙・部分型関係・複製と別フローへの捕獲・実行時の扱いを定める。どの操作が値を消費し、消費済みの値への出現や未消費をどう診断するかはフロー解析の管轄で、static-analysis.md が定める。

多重度の型語彙

型 意味
AtMostOnce(T) 高々 1 回。使い残しは咎めない
ExactlyOnce(T) 丁度 1 回。未消費を診断する
Borrowed(T) 借用。消費できない
Consuming(F) F は関数型。このメソッドはレシーバーを消費する

AtMostOnce(T) / ExactlyOnce(T) / Borrowed(T) の T と、Consuming(F) の F を基底型と呼ぶ(NonZero(T) の T を基底型と呼ぶ〔§17.7〕のと同じ用法)。

これらの型コンストラクターは基底型を包むコンテナーではない。 値の構造は基底型のままで、AtMostOnce(T) の値には T のメンバー・メソッドがそのまま生えており、取り出し(unwrap)は要らない。静的なメンバー解決と結果型の推論も同じで、多重度の層を基底へ降りてから行う — h: AtMostOnce(R) の h.peek() は R のスロット peek の宣言型で解け、R に無い名前は素の record と同じく no-such-member になる(static-analysis.md §2)。変わるのはその値に課される使用の規律だけである。ただし基底型と同一の型ではない — NonZero(T) が基底型の部分型であるのに対し(§17.7)、多重度型は基底型との間にどちら向きの部分型関係も持たない。もっとも、型の照合はこの違いを見ない — 注釈・引数・結果のどの位置でも多重度の層を剥がし、基底同士で照合する。多重度は値に内在せずその位置の宣言が課すものなので、照合すべき差が型の側に無いためである。多重度の付与は宣言が行う — ある値をこれから何回使えるかは、その値を持つ名前の宣言型が決める。

照合が多重度を見ない以上、型の側だけでは多重度型の値を多重度を持たない宣言型のパラメーターへ渡す形が通ってしまう。この向きはフロー解析が禁じる(static-analysis.md §2.14 の pass-of-multiplicity-value)— 渡した先の名前が追跡対象にならず、そこで規律が消えるためである。逆向き(多重度を持たない値を多重度型の位置へ渡す形)は受け側の規律が強まるだけなので禁じない。多重度型同士の緩和は下記「多重度型の部分型関係」が定める。

Consuming(F) は §17.5 のメソッドシグネチャ契約 m: { In | Out } の位置にそのまま入るので、既存の書式の内側に収まる。

type File := AtMostOnce({
  read_at: { Int, Int | Bytes }
  sync: {| Unit }
  close: Consuming({| Unit })
|})

type Txn := ExactlyOnce({
  exec: { String | Unit }
  commit: Consuming({| Unit })
  rollback: Consuming({| Unit })
|})

態が 2 種類あるのは、注釈する対象が違うためである。Consuming(F) はメソッド(動作する側)に付くので現在分詞、Borrowed(T) は値(動作される側)に付くので過去分詞になる。この読みが効くのは結果型位置で、set: { Int, Any | Borrowed(T) } の Borrowed(T) は「借りられている T の値」であって「この位置が何かを借りる」ではない。

Consuming(F) を書けるのは多重度型のスロットに限る。多重度を持たない型に書いても消費される先が無くマークに意味が無いため、宣言の時点で型エラーとする(知らせずに無視すると「マークを書いたのに効かない」位置ができる)。

位置は構文で決める — Consuming(F) を書けるのは、多重度型コンストラクター(AtMostOnce / ExactlyOnce)の直接の基底として書いた record のスロットと、同じ位置へ型変数を書いたときそこへその場で添えた境界 record のスロットだけである。 上の File / Txn が前者、下記「基底の型変数へ境界を付ける」が後者で、それ以外の位置(束縛やパラメーターの注釈・タプルの要素・関数型のパラメーターと結果・組込タグの payload・ユーザー定義 enum の通常スロット・多重度型コンストラクター以外の型コンストラクターの引数)はすべて型エラーになる。

Borrowed(T) には同じ制限を掛けない。Consuming(F) は「レシーバーを消費する」マークなので、消費される先である多重度型が無ければ指す対象が無く、宣言の時点で意味が定まらない。Borrowed(T) が述べるのは「この位置の値は保存できない」であり、基底が何であれ指す対象がある。基底が多重度型でない Borrowed(T) は、消費の禁止が空振りするだけで保存の禁止はそのまま効く。

名前を経由して包む形(type B := { m: Consuming(F) |} の後に type T := ExactlyOnce(B))も書けない。 型は export できるので、B の宣言だけを見ても他ファイルが ExactlyOnce(m.B) と包むかどうかは分からない。この形を許すと「宣言の時点で型エラー」が原理的に成立せず、マークが効くかどうかがファイルをまたいだ後づけで決まってしまう。多重度型を直接書けば B の側に迷いが無くなる。

Consuming を含まない record を名前で置いてから包むことは引き続きできる。 禁じているのは Consuming を含む record を直接の基底以外の位置に置くことだけで、type B := { ping: {| Int } |} の後の type T := ExactlyOnce(B) は通る。

type H := AtMostOnce({ peek: {| Int }, close: Consuming({| Unit }) |})  # 通る

type B := { m: Consuming({| Unit }) |}  # エラー: 直接の基底ではない
type T := ExactlyOnce(B)

多重度型の部分型関係

  • 多重度型 M の値は、関数の引数位置に限り Borrowed(M) へ渡せる。 これが借用であり、受け側は Borrowed(M) で宣言する。
  • 保存位置ではこの緩和を認めない。 束縛・コンテナー・別フローへの捕獲・メソッド値の取り出しのいずれでも借用は置けない(下記「借用は保存できない」)。
  • ExactlyOnce(T) <: AtMostOnce(T) は許す。 使用回数の下限を捨てる方向であり、安全側だからである。基底型との間に部分型関係が無いこと(上記「これらの型コンストラクターは基底型を包むコンテナーではない」)はこの緩和の外側で、緩和は多重度型同士にしか働かない。逆向き(AtMostOnce の値を ExactlyOnce の位置へ渡す形)も型の照合は通す — 照合が基底で行われるためで、受け側の義務が強まるだけなので害が無い。判断を要するのは前者だけである — 義務を捨てる向きだけが、捨ててよいかを問う。

借用のもう 1 つの現れ方はレシーバー位置である。Consuming で包まれていないメソッド呼び出しのレシーバーはすべて借用であり、注釈は要らない。注釈無しの意味は 2 つの位置で反転している — レシーバーは注釈無しが借用、関数の引数は注釈無しが move である。反転は意図したものである。§17.5 のメソッド契約 m: { In | Out } に受け手の欄が無い — レシーバーは引数ではない — ので、レシーバーの既定は型の意味に縛られず自由に選べ、当然の方を選んだ。引数の処遇はパラメーターの型そのものが述べるため、既定は型の意味と噛み合う側に置いた。レシーバーと引数は独立に指定でき、4 通りすべてが書ける。引数の消費に注釈が要らないのは既定が move だからであって、表現できないからではない。

import fs := "std:fs"

type Pool := AtMostOnce({
  absorb: Consuming({ fs.File | Unit })  # レシーバーを消費し、引数も消費する
  give: { fs.File | Unit }  # レシーバーは借用、引数は消費
  peek: { Borrowed(fs.File) | Int }  # レシーバーも引数も借用
  seal: Consuming({ Borrowed(fs.File) | Unit })  # レシーバーを消費、引数は借用
|})

安全性は 1 本の規則で立つ — 借用したレシーバーでは Consuming メソッドを呼べない。 これにより、借用が呼び先から漏れて生き延びても閉じられないので、閉じた後の使用を作れない。

基底に型変数を置く

多重度型コンストラクターの基底には型変数を置ける — { x: AtMostOnce(a) | … } / { x: ExactlyOnce(a) | … } がその形である。これがジェネリックなコードで資源を受け渡す正書法である。

規律はそのまま働く。消費追跡の起動は宣言型が多重度型に解けるかで決まり(static-analysis.md §2.14)、基底が型変数でも層は多重度型のままだからである。したがって次の 3 つがいずれも成り立つ。

  • body に規律がかかる。 { x: AtMostOnce(a) | (x, x) } は use-after-consume、{ x: ExactlyOnce(a) | 0 } は never-consumed になる。返す・包む・別の関数へ渡すのはいずれも 1 回の消費なので通る。
  • 呼び手は渡した時点で失う。 実引数へ置くことが消費として記録されるので、渡した後にその名前を使うと use-after-consume になる。
  • 結果は追跡対象に戻る。 a が具体型に解けるので、結果を受けた名前の静的型は多重度型になる。
export {}  # 多重度型の値をトップレベルに束縛するので公開しない(§13.2)

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

new_lease := {| { ping := {| 1 }, done := {| () } |}: Lease }

hand_over := { x: ExactlyOnce(a) | x }

l: Lease := new_lease()
m := hand_over l
m.done()

境界の無い型変数を基底に置いた値のメンバーは参照できない。 型変数にスロットが無いので、body でできるのは渡す・包む・返すことである。受け取った資源の Consuming メソッドを body から呼びたいなら、基底を具体型で書く({ x: Lease | x.done() })か、下記のとおり型変数へ境界を付ける。

参照は静的検査が禁じる(static-analysis.md §2.14 の cannot-call-on-type-variable-base)。メンバーが解けない以上そのメソッドが Consuming かどうかを引く先が無く、消費とも借用とも決められないためである。素通しにすると、その位置は型検査を一つも受けないまま(存在しないメンバーでも報告が出ない)ExactlyOnce の義務だけが静かに消える。決められないことを禁じる側へ倒すのは、型変数のパラメーターへ渡せないこと(下記)と同じ判断である。

型変数({ x: a | … })のパラメーターへは渡せない。 宣言位置で多重度型に解けないため規律を起動する先が無く、素通しにすると呼び手と受け側の両方に同じ資源への経路が残る。したがって多重度型の値をそこへ置く形は静的検査が報告する(static-analysis.md §2.14 の pass-of-multiplicity-value)。資源をジェネリックに扱う関数は基底に型変数を置く形で書くこと — 書き忘れは通らない。境界(§17.2)の有無は問わない — 境界は確定できる型を絞るだけで、多重度の規律を課す先を作らないからである。

値コンストラクターの payload へは渡せる。 Ok(x) / Err(x) やユーザー定義 enum の原型は通常スロットの型に型変数を持てるが、包みが多重度を伝播する(static-analysis.md §2.14「包みは多重度を伝播する」)ので規律が消えない。入れることが 1 回の消費として記録され、取り出しでまた追跡へ戻る。

基底の型変数へ境界を付ける

基底の型変数に interface 境界(§17.2)を付ければ、その境界が宣言したメンバーは参照できる。 境界はメンバーの一覧を持つので、そのメソッドが Consuming かどうかを引く先ができる — 上の禁止が塞いでいた「決められない」がここで解ける。これがジェネリックなまま資源を閉じる正書法である。

# 古い方を閉じ、新しい方を同じ型のまま返す
swap := { old: ExactlyOnce(a: { close: Consuming({| Unit }) |}), new: ExactlyOnce(a) |
  old.close()
  new
}

境界の record には Consuming を書ける(上記「多重度の型語彙」の位置の規則)。判定は今までどおり書かれた位置の構文だけで決まり、名前は追わない。その場に添えた境界だけを認めるのはそのためである — 境界を名前で書いた形(ExactlyOnce(a: Closer))でその Closer が Consuming を持つことはありえない。Consuming を含む record を名前で置く宣言自体が通らないからである。名前で使い回したいときは全体を別名にする(type Closing := ExactlyOnce(a: { close: Consuming({| Unit }) |}))。

境界を経由したメンバーは、基底が具体 record のときとまったく同じに扱う。 境界が宣言したスロットの型が Consuming(F) ならその呼び出しは消費であり、Consuming(F) でないスロットの呼び出しは借用である。境界が宣言していない名前は no-such-member になる(下記「境界に無い名前は型エラーである」)ので、消費か借用かの判定には届かない。したがって ExactlyOnce の義務が静かに消えることはない — 借用だけを呼ぶ body は never-consumed になる。ここに新しい判断は無く、多重度の層を基底へ降りてからメンバーを解く既存の規則(上記「これらの型コンストラクターは基底型を包むコンテナーではない」)の降り先が 1 段増えるだけである。

境界が record にも不透明型にも解けないときは今までどおり禁じる。 閉じた union や原始型を境界に置いてもメンバーを列挙できないので、Consuming を引く先ができない。境界が付いたことではなく、境界がメンバーを数え上げられることが禁止を解く条件である。

この境界は基底に付くものであり、パラメーターの型そのものが型変数である位置(上記「基底に型変数を置く」)とは別である。 あちらで境界の有無を問わないのは、そこに規律を課す先が無いからで、本節が足すのは規律の届いている値のメンバーをどう解くかである。

境界への適合は静的に検査する。 x: ExactlyOnce(a: I) へ渡す値は I の要求を満たす必要があり、呼び出しで確定した型は同じシグネチャの以降の a に使う(§17.2)。通常のパラメーター注釈では実行時に照合しない。アスクリプションや型パターンで照合するときも、Consuming(F) は F として見る。Consuming は受け手の使用を述べる型語彙であり、値の形を追加しない。

境界に無い名前は型エラーである

境界が宣言していない名前のメンバー参照は no-such-member である。多重度に固有の規則ではない — 宣言した型のメンバー集合が受け手から触れる範囲になるという §17.2 の一般の規則が、境界を基底とみなすこの位置にも同じように働くだけである。

上の消費と借用の読みは、境界がその名前を宣言している場合の話である。 宣言していない名前はメンバー解決の段で止まるので、そこから先の判定には届かない。

関数値の多重度

基底が関数型の多重度型では、完全適用が消費である。 AtMostOnce({ In | Out }) は「高々 1 回だけ呼べる」、ExactlyOnce({ In | Out }) は「丁度 1 回呼ぶ」を表す。部分適用は消費ではない — 本体が走らない(§3.6)ので資源も使われず、回数の規律は下記のとおり結果の側へ移る。明示的 kick(f! / f())は本体を丁度 1 回走らせるので完全適用として数える。

type Once := AtMostOnce({ Int | Unit })

f: Once := mk()
f 1  # 消費
f 2  # エラー: use-after-consume

Consuming は書けないし、要らない。 マークを置く場所が構文として無い(Consuming を書けるのは多重度型コンストラクターの直接の基底として書いた record のスロットだけ。上記「多重度の型語彙」)うえに、置く意味も無い。record を基底に持つ型では借用メソッドと Consuming メソッドを選べるからマークが要るのに対し、関数値の操作は呼び出し 1 つしか無いので選ぶものが無い。

「手渡しは 1 回だが呼び出しは何度でも」は表せない。 その読みを採らないのは、守るものが無いからである — 資源を閉じ込めた関数値を何度でも呼べるなら資源も何度でも使われるので、多重度を載せる意味が消える。回数を制限したくないなら多重度を書かなければよい。

部分適用の結果には多重度が載る。 追跡対象の実引数(多重度型そのものと、多重度を伝播する包み)を埋めた部分適用の結果型は多重度型になる。埋めた資源はその関数値を呼んだときに丁度 1 回使われるので、回数の規律が結果へ移る。

use := { h: fs.File, n: Int | h.close() }

p := use f  # p の型は ExactlyOnce({ Int | … })
p 1  # 消費。f もここで 1 回だけ閉じられる
p 2  # エラー: use-after-consume

載せる多重度は強い方が勝つ — ExactlyOnce を 1 つでも埋めれば結果は ExactlyOnce である。弱めると「丁度 1 回」の義務が結果を呼ばないことで消える。借用の引数は消費できないので多重度を載せない。呼び先が既に多重度型なら、そこへの部分適用の結果もその多重度を引き継ぐので、多段に分けて埋めても義務が落ちない。判定の詳細と、包みの内側への伝播は static-analysis.md §2.14 が定める。

ブロックの起動回数を宣言する

ブロックを取るパラメーターを ExactlyOnce(基底が関数型)で宣言すると、そこへ渡したブロック位置は「起動が高々 1 回」になる — その内側から外側の資源を消費できる(static-analysis.md §2.14「ブロックの起動回数」)。db.transaction や arr.build と構造が同じ自前の bracket が、std でなくても書けるということである。

with_conn := { pool: Pool, f: ExactlyOnce(EffectConduit({ Borrowed(Conn) | a })) |
  c := pool.acquire()!
  r := f c
  pool.release(c)!
  r
}

lease: Lease := take_lease()
with_conn pool { c | lease.done(); c.query "select 1" }  # 外側の資源を閉じられる

ExactlyOnce は起動回数を述べ、EffectConduit は渡されたブロックの効果を呼び出し元へ伝える。
効果の透過は、return などの制御の透過とは別に宣言する(§17.9)。

載せる先は関数値の多重度そのものである。 起動回数は「呼び先がそのパラメーターをどう扱うか」だが、それを述べる位置はパラメーターの宣言型そのものであり、上記「関数値の多重度」が定めたとおり基底が関数型の多重度型では完全適用が消費である。「丁度 1 回消費する」と「丁度 1 回起動する」は同じことを別の言葉で述べており、新しい軸は要らない。呼び手が持つ関数値の多重度(何回呼べるか)と、呼び先のパラメーターの多重度(何回呼ぶか)は同じ型の同じ読みで、位置が違うだけである。

宣言は検証される。 呼び先の本体では f が追跡対象の名前なので、1 度も呼ばなければ never-consumed、2 度呼べば use-after-consume になる。「高々 1 回」の表の他の行が仕様の側で閉じているのに対し、この行は呼び先の本体が根拠を示す。

ブロックの中の消費は、呼び出しの位置での消費である。 宣言で開くブロック位置は「丁度 1 回」起動される(static-analysis.md §2.14「ブロックの起動回数」)ので、外側の値をブロックの中で消費すると、呼び出しの位置でその名前を消費したのと同じになる。義務はそこで果たされ、呼び出しの後ろで同じ名前を使えば use-after-consume になる。

AtMostOnce では開かない。 0 回の可能性が残るので「丁度 1 回」の保証にならない。Borrowed({ In | Out }) も開かない — 消費義務を持たないので起動回数について何も述べていない。宣言で開く行を足すときは、見逃しを増やさない側へ倒す。

ブロックへ渡すパラメーターは Borrowed で宣言する。 std の bracket にかかる規定(static-analysis.md §2.14)と同じで、ブロックが受け取ったハンドルを消費できると bracket 自身の後始末が壊れる。呼び先が宣言した型は注釈の無いブロックパラメーターへ流れる(static-analysis.md §2.2)ので、書き手は { c | … } と書くだけでよい。

ブロックが資源を返すとき、結果の型を決められなければ注釈が要る。
値の位置に未確定の型変数を残す形は静的エラーであり、追跡を免除する理由にはならない。
made: Lease := with_conn(pool) { c | take_lease() } と書けば、結果に必要な型を与えられる。

新しい語彙は要らない。 「このブロック位置は丁度 1 回起動する」は既存の型の綴りがそのまま述べており、マークも注釈も増えない。

借用は保存できない

借用を型として持ち、かつ保存できる設計は、例外なく生存期間の添字(region / lifetime)を型に持つことになる。保存できるなら「いつまで有効か」を型が言わねば宙に浮いた参照が作れてしまうためである。Hikari は保存を禁じることでこの添字を不要にする。

位置 借用を置けるか
束縛(g := f.chain()) 不可
コンテナー({ mutable h := b |} / [b] / タプル) 不可
別フローへの捕獲(spawn / fork / Future のブロック) 不可
メソッド値の取り出し(r := f.read_at) 不可(取り出した関数値がレシーバーへの借用を保存するため)
関数の結果 自身を返す連鎖メソッドと、Borrowed(T) を返すと宣言した関数のみ
呼び出しのレシーバーとして使う 可
引数として渡す 受け側のパラメーターが Borrowed で宣言されているときに限り可

受け側が Borrowed でないパラメーターは既定が move(上記「注釈無しの意味は 2 つの位置で反転している」)なので、そこへ渡すと借用が呼び先に保存されうる。部分型関係の側から見ても、緩和は M → Borrowed(M) の一方向だけで、Borrowed(M) → M はどの規則も許していない。

これにより借用は式スコープに閉じる — 呼び出しに使うか、別の関数へ借用として渡すか、その場で連鎖するかだけになる。生存期間が構文で決まるので、region が原理的に要らない。この禁止は書式の整理ではなく、region を回避する土台そのものである。

自身を返す連鎖メソッドは結果型を Borrowed(T) で宣言する。そうしないと b := a.set(2, 7) が同じ値への 2 つ目の名前を作る。束縛位置に借用を置けない規則がここで噛み合う。

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

借用 b: Borrowed(T) から取り出した値は、借りた側の持ち物ではない。
スロット(b.t)・タプルの要素(b.0)・分解({ t } := b)・match の payload・組込メソッドの結果とブロックの要素(b.o.unwrap!()・b.items.each { … })として取り出した値も、所有者が持つ同じ資源を指す。
そこで取り出した値の型が多重度型を含むなら、その型は Borrowed で包んだ型になる。
上表と「借用したレシーバーで Consuming メソッドを呼べない」規則が、取り出した値にもそのまま効く。

type Txn := ExactlyOnce({ commit: Consuming({| String }) |})
type Box := AtMostOnce({ t: Txn, n: Int |})
peek := { b: Borrowed(Box) |
  b.t.commit()  # エラー: b.t は Borrowed(Txn)(cannot-consume-borrowed)
  b.n + 1  # 通る(Int は多重度型を含まないので所有のまま取り出す)
}

包まなければ、借りた側で取り出した値を消費でき、所有者がもう一度消費できてしまう。
多重度型を含まない値は資源ではないので、何度使っても規律は破れず、所有のまま取り出してよい。
借用したコンテナーの要素を所有で受けるブロック(b.items.each { t: Txn | … })は、要素の型 Borrowed(Txn) を受けられないので型の不一致になる。

判定は式の推論結果の型で行う

上表が定めるのは位置であって綴りではない。その位置に現れた値の静的型が Borrowed(T) に解けるなら、値が裸の識別子であっても式であっても等しくかかる。借用を返すメソッド(下記「可変ホスト資源はすべて多重度を持つ」の set / swap / update)が日常の書き方である以上、借用の式を素通しすると上表の禁止が「裸の名前に束縛したときだけ効く」規則に痩せてしまう。

steal := { a: arr.Array(Int) | f := spawn {| a.set(0, 42); 0 }; f! }

b := a.set(0, 1)  # 束縛の行に当たる
steal b  # 引数の行に当たる
steal a.set(0, 1)  # 同じく引数の行 — 借用の式でも変わらない

同じ理由で、レシーバーが連鎖や式のとき(a.set(0, 1).frozen())も「借用したレシーバーで Consuming メソッドを呼べない」規則がかかる。

例外 — 連鎖のルートが名前を持たない所有の式のとき

その場で作った資源を連鎖のルートに持つ形だけは対象外である。

arr.array(2, 0).set(0, 1).set(1, 2).frozen()  # 通る(ルートは名前を持たない所有の式)

上表が保存を禁じるのは、借用の指す資源を別の経路が持ち続けているからである。連鎖を遡ったルートがその場で作られ名前に束縛されていない所有の式なら、その資源へ届く経路は連鎖そのものしか無い。借用が漏れて生き延びる先が無いので、規則が守る危険がそもそも生じない。これを例外にしないと「作って・書いて・確定する」一息の書き方が丸ごと書けなくなり、下記「連鎖は借用のまま書ける」と噛み合わなくなる。

ルートが名前なら例外にならない。その名前が資源を持ったまま借用経由で保存・消費される形であり、まさに上表が禁じる 2 本目の経路そのものである。ルートまで遡っても借用のままのとき(借用が呼び先から返ってきた形)も同じで、所有者は式の外にある。

借用は「読み取り専用」ではない。 借用したハンドルへ書き込めるし、連鎖もできる。禁じているのは消費だけである。

規律が届かない位置

消費追跡(static-analysis.md §2.14)の側は裸の識別子のままである。 消費は名前ごとのフロー状態なので、状態を持たせる先が名前しか無い。したがって所有の多重度型を式のまま扱う形(mk().held のようにルートが式の path など)は追跡の対象外である。ただし ExactlyOnce を含む名前の無い値を借用の位置に置く形は、値がそこで捨てられるので報告する(static-analysis.md §2.14「名前の無い値を借用で使い捨てない」)。

Consuming のメソッドの取り出しも、受け手の形を問わず禁じる(static-analysis.md §2.14 の cannot-extract-consuming)。式の値は名前を持たないので、2 度目の消費へ届く経路は取り出した関数値しか無い。取り出した関数値は何度でも呼べ、Consuming を宣言したユーザー定義の多重度型には実行時の封印も無いので、ここを塞がないと二重消費がどこでも止まらない。取り出しを塞げば、式のまま扱う所有の値は 1 度しか使えない — std の可変ホスト資源では、残る逸脱を実行時の封印が backstop として受け持つ(閉じたハンドルへの次の操作がその場で失敗する)。

呼び先が型を述べていないブロックパラメーターには借用の規律が働かない。 呼び先が宣言するブロックパラメーターの型は書き手の未注釈パラメーターへ流れる(static-analysis.md §2)ので、arr.build のようにブロックパラメーターを借用として宣言するメソッドでは注釈の有無を問わず規律が働く。届かないのは呼び先の宣言型が Any や型変数に倒れる位置で、そこには借用かどうかを言う情報がそもそも無い。

import fs := "std:fs"

checksum := { f: Borrowed(fs.File), n: Int |  # 借用。呼び出し側は f を持ったまま
  r := f.read_at(0, n)!
  bytes := r?
  Ok(bytes.length)
}

drain := { f: fs.File |  # 注釈無しなので move
  r := f.read_at(0, 4096)!
  f.close()!
  r
}

可変ホスト資源はすべて多重度を持つ

不透明で可変なホスト資源は多重度型である。 多重度は資源に内在する性質であり(Borrowed が
文脈依存であるのと対照的)、非 Copyable(§9.5)と同じ層にある。std が提供する可変ホスト資源は
下表のとおりすべてこれに従う。

ユーザー定義の型についてこれは規範であって記述ではない。可変ホスト資源そのものを作れるのは std だけだが、
ユーザーが宣言する不透明型(§17.4.2)は中身に可変ホスト資源を持てる。
そうした型の値は資源を包んでいるので、同じく多重度型で包んで扱うべきである。この規則を強制する検査は存在しない。
std を拡張する側と、資源を包む不透明型を宣言する側が守るべき規則として読む。

分岐点は「使い残しが害になるか」である。

型 多重度 Consuming メソッド
std:array の Array AtMostOnce frozen
std:map の ScratchMap AtMostOnce frozen
std:fs の File ExactlyOnce close
std:net の Conn ExactlyOnce close
std:db/sqlite の Db ExactlyOnce close
std:db/sqlite の Tx AtMostOnce 持たない

Tx が AtMostOnce で Consuming メソッドを持たないのは、閉じるのがブロック側ではないため
である。db.transaction(block) は block の結果で commit / rollback を決め、そこでハンドルを封印
する。ブロックは貸し出された Tx を使うだけなので、block のパラメーター型は Borrowed(Tx) になる
(std:array の arr.build が貸し出す Borrowed(Array(e)) と同型である)。

規則の対象は資源そのものである。 §9.5 が非 Copyable に挙げるもののうち、Future(§10)だけは
資源そのものではないので多重度を持たず、上表にも載らない — 資源ではなく多重度を伝播する包み
であり、包んだ中身の多重度がそのまま外へ出るので Future 自身に多重度を載せる必要が無い
(static-analysis.md §2.14)。

受け手を消費しないメソッドが受け手そのものを返すときは、Borrowed を返さねばならない(上記
「借用は保存できない」が定める規則を、可変ホスト資源へ当てはめたものである)。所有を返すと、消費
されていない受け手と合わせて同じ資源への経路が 2 本になり、上表が閉じたはずの穴がそのメソッド経由で
開く。連鎖のために self を返す Array の set / swap / update と ScratchMap の
set / remove / update はこの規則に従い Borrowed を返す(std/array.md §4・
std/map.md §4.1)。連鎖は借用のまま書けるので、この制約で失われる書き方は無い。

この規則が spawn の隔離を支える。 移譲した捕獲に抱かれた非 Copyable な資源を共有しても安全なのは「捕獲した後、親が
その値へ触れない」からだが、消費追跡が追うのは変数であって構造の内部ではない。可変資源そのものが
多重度を持てば、その資源をコンテナーへ入れた時点で元の名前が消費済みになるため、親側に 2 本目の経路が
残らない。追加の規則も解析も要らない。

実行時は何も変わらない。 多重度は使用を制約する型であって値の形を制約する型ではないので、
matches も copy のディスパッチも spawn の非 Copyable 捕獲検査も基底型の判定のままである
(下記「多重度の実行時照合」)。

複製と別フローへの捕獲

多重度型の値と、それをスロット・要素に持つ構造への copy(§9.5)は静的な型エラーとする。 自前の copy スロットによる上書き(§9.5「上書き」)も認めない — 認めれば f.copy! が同じ資源への 2 つ目の名前を作り、move 規律が破れる。構造へも及ぼすのは、copy が作り直すのは可変な構造だけで透過的に不変な部分は共有する(§9.5)ためである。多重度型の値をコンテナーへ入れてからコンテナーを複製すると、同じ資源への 2 本目の経路が生えてしまう。

実行時の側は変わらない — v.matches(type Copyable) も copy のディスパッチも基底型の判定のままである(下記「多重度の実行時照合」)。多重度型は使用を制約する型なので、値を見ても複製してよいかは分からない。したがってこの禁止を実行時の失敗が肩代わりすることはない — 基底型が record である多重度型(type Txn := ExactlyOnce({ … |}) の形)は実行時にはただの Copyable な値なので、塞ぐのは静的検査だけである。

多重度型の値を、別フローで走り起動が高々 1 回のブロックへ捕獲するときは、所有権の移譲とする。 対象は「行き先が別フローであり、かつ起動が高々 1 回である」という性質で決め、spawn / fork と Future のメソッド(prelude.md §9.1 / §9.6 / §9.9)がこれにあたる。捕獲した時点で親側ではその値が消費済みになる(static-analysis.md §2.14)ので、移譲された非 Copyable な実体を共有しても親からもう触れず、隔離は保たれる。spawn は静的に移譲と判定した捕獲について非 Copyable 検査を省くが、可変な構造は下記の規則で隔離複製する(同 §9.9)。起動が要素ごとに繰り返されるブロック(std:parallel の並列コンビネーター。std/parallel.md)は移譲の対象にしない — 捕獲を 1 回の消費とみなすと実体が n 回の消費である形が通ってしまうので、そこは起動回数が不明なブロックとして外側の値の消費そのものを禁じる(static-analysis.md §2.14)。

移譲が使えるのは、捕獲が消費として記録される値に限る。 静的型が多重度型そのものである値と、多重度を伝播する包み(組込タグの payload・ユーザー定義 enum の通常スロット・タプル・Future・List・record。static-analysis.md §2.14)がこれにあたる。多重度型の値を追跡に載らない構造(多重度を伝播する包みの対象外の位置)に入れてから別フローへ捕獲することは静的に禁じる — そこでは親側に値が残るので、複製した場合と同じく同じ資源への 2 本目の経路ができる。この禁止の側は起動回数を問わず、別フローで走るブロックすべてにかかる。copy の禁止と違って伝播する包みを除くのは、複製が親側に元の値を残すのに対し移譲は残さないためである。この禁止も静的検査だけが塞ぐ — spawn の非 Copyable 捕獲 panic は実行時の値を見る規則なので、基底型が record の多重度型を含む構造は素通ししてしまう。

移譲した捕獲も隔離複製する — 共有するのは非 Copyable な実体だけである。 上の根拠(親側で消費済みになるので触れない)は値そのものへの経路しか無いときにだけ正しい。基底型が record である多重度型(type Txn := ExactlyOnce({ … |}) の形)は、多重度を持たない可変な値を内部へ持てる。その値を入れても呼び手の名前は消費済みにならない(多重度を持たない値はそもそも追跡の対象ではないため。static-analysis.md §2.14)ので、捕獲した値ごと共有すると親側に 2 本目の経路が残る。メソッドを関数型スロットへ置く綴りも同じで、そのクロージャが捕獲した可変な値へ親から届く。

そこで移譲が省くのは複製そのものではなく、非 Copyable な実体の複製である。捕獲は §9.5 の copy と同じ深さで作り直し、到達グラフの中で非 Copyable な実体(不透明なホスト資源・Future)に達したらそこだけ共有する。親がその実体へ届かないことは消費追跡が保証しており(資源はすべて多重度を持つので、入れた時点で元の名前が消費済みになる。上記「可変ホスト資源はすべて多重度を持つ」)、届かない相手を共有しても経路は増えない。それ以外の可変な構造は作り直されるので、親側にどんな束縛が残っていても子の書き込みは観測できない。

この形は静的な判定を 1 つも要求しない。 移譲してよい型を型で選り分けようとすると、record のスロットに可変な値が無いことを型から決められず(型はスロットの可変性を持たない。下記「多重度の実行時照合」)、メソッドを持つ型が軒並み対象外になる。別名を追う道は下記「規律を課さないと決めたもの」で恒久的に対象外と定めた名前フィールドとコレクション要素を追い直すことになる。複製の深さは実行時の値が決めるので、どちらも要らない。

したがって移譲と複製の違いは 1 点に縮む — 複製は非 Copyable に達すると失敗するが、移譲はそこを共有して進む。spawn が移譲と判定した捕獲について非 Copyable 検査を行わない(prelude.md §9.9)のはこの 1 点の言い換えである。

同じ危険は捕獲以外の経路にも開く。 std が状態をブロックへ引き渡す経路を持つとき(std/http/server.md §13 の serve の state)、そこへ置く値も引き渡した先で後から使われる。置いた値が多重度型なら、置くことが消費として記録されるので呼び手の側の名前は使えなくなる。多重度型を含むが自身は追跡対象でない値では追跡が既に切れており、置いても消費にならないので呼び手に同じ構造が残る — 捕獲を禁じたのとまったく同じ理由で、この形も静的に禁じる(static-analysis.md §2.14 の state-not-owned)。多重度型を 1 つも含まない値は呼び手に残る写しが不変のデータでしかないので対象にしない。

多重度の実行時照合

多重度は静的な使用の規律である。
束縛・引数・結果の注釈では実行時照合しない。実行時に値だけを見ても使用の履歴や義務は分からない。
アスクリプションの照合では基底型の一致を判定するが、使用の規律も静的に満たさなければならない。

matches は基底型の判定を行う。
v.matches(type AtMostOnce(fs.File)) は値の種類について v.matches(type fs.File) と同じ判定を行う。
この判定を通ることは、所有・借用・使用回数の規律を免除する根拠にはならない。

アスクリプションの照合の省略では、基底型の一致を静的に証明できるかを判定する。
多重度の使用の規律は、照合を省略するかどうかによらず静的に検査する。

アスクリプションは資源を作る

多重度を持たない値を多重度型へアスクリプションすると(raw: Txn)、その評価地点で資源が 1 つ作られる。
同じ値から資源を 2 つ作ることはできない。 2 つ作れると、静的にはそれぞれを 1 度ずつ消費しても、実体は同じ値なので 2 度消費される。

資源を作るのは、多重度の層の基底が Consuming のスロットを持つ record の位置である(Txn の位置)。
ほかの基底は 2 度消費されても破れる約束が無い。型変数と Consuming のスロットを持たない record は消費する操作を持たない。関数の多重度が約束するのは受け手が呼ぶ回数である。std のハンドルは実行時の封印が 2 度目の消費を止める。

  • 被演算子が名前なら、アスクリプションはその名前の消費である。以後の出現は消費後の出現として静的エラーになる(static-analysis.md §2.14)。
  • 別名・関数の結果・コンテナーの中身を経て、資源にした値へもう一度アスクリプションが届いたら、そのアスクリプションの評価地点で止まる。対象は箱を持つ値(record と関数値)である。
  • 多重度型の値を多重度型へアスクリプションする形(t: Txn の t がすでに Txn)は資源を作らない。被演算子が名前なら、その名前の消費である。
  • すでに資源を含む値の一部から資源を作る形((t, raw): (Txn, Txn))は静的エラーである。新しい部分だけを先にアスクリプションする。
  • 資源を作るのはアスクリプションだけである。 箱を持つ値を、束縛・再代入・パラメーター・結果の注釈で資源を作る位置へ置く形(a: Txn := raw・use raw)は静的エラーで、raw: Txn と書く。その場で書いた関数・record のリテラル(use { commit := … |})は毎回新しい値なので、この制約を受けない。
type Txn := ExactlyOnce({ commit: Consuming({| String }) |})
raw := { commit := {| "c" } |}
a := raw: Txn
b := raw: Txn  # 静的エラー: raw は a を作ったときに消費された

other := { commit := {| "d" } |}
again := {| other }
c := again!: Txn
d := again!: Txn  # ここで止まる: c と同じ値から資源を作る

std:fs などのハンドルが持つ実行時の封印は、資源がすでに閉じているかを判定する。
これは実行時の状態に対する検査であり、静的な型と使用回数の検査とは別に維持する。

検証モードでは消費の回数を数える。 環境変数 HIKARI_VERIFY_MULTIPLICITY(hikari-command.md §13)を設定すると、実行系は多重度型の注釈を通った値を覚え、その値の消費を数える。数える消費は、Consuming メソッドの呼び出しと、多重度型の関数値の適用の 2 つである。

  • 同じ値を 2 度消費したら、その場で専用の診断を出して停止する。
  • 値の多重度は、最後に通った多重度型の注釈で決まる(Borrowed の注釈では変わらない)。AtMostOnce の注釈を通った値の中身も AtMostOnce に弱まる — コンテナーを捨てれば中身も捨てられるからである。多重度が ExactlyOnce の値を 1 度も消費しないまま実行が正常に終わったら、報告して失敗で終える。
  • panic の経路には義務を課さない(static-analysis.md §2.14「ExactlyOnce の消費義務」)。値を覚えた後に panic かキャンセル(§10.3。root の完了による放棄を含む)が起きていれば、その値は使い残しとして報告しない。
  • 数えるのは箱を持つ値(record と関数値)だけである。基底が Int などの値と、実行時の封印を持つ std のハンドルは数えない。

静的な消費追跡が通したプログラムでこれが起きたら、それは静的検査の穴である。検証モードは静的検査を実測で確かめる手段であり、通常の実行では何も数えず、意味論も変わらない。

検証モードの違反は処理系の欠陥として停止する。 2 度目の消費と使い残しは、プログラムの誤りではなく静的検査の穴を示すので、panic とは区別する。panic を受け止める位置(§16.1)でも捕まえず、専用の診断を出して終了コード 71 で停止する(hikari-command.md §5.4)。

規律を課さないと決めたもの

次は多重度の規律の対象にしない。実装が進んでも対象にしない。

  • 共有借用と排他借用の区別 — 借用は何本でも取れ、すべて書き込める。読みと書きの排他を型で分ける仕組みは持たず、可変状態の別名制御は §17.2「変性」と static-analysis.md §2.10 の型安定性の規則(「可変ローカルの型安定性」・「スロット代入の型安定性」)の管轄に留める。
  • 名前フィールドのパスとコレクション要素を多重度の規律の対象にすること — o.h のようなパスやリストの要素に、それぞれ独立した消費状態を持たせない。追跡対象にすると正しいコードを誤検出する — 同じ型のスロットへの差し替えが通るなら、o.h を消費済みと記憶していると差し替え後の使用が誤検出になる。加えてコンテナーは自由に別名が作れるので、追っても漏れる。多重度は名前フィールドも追わない側へ線を引く。コレクション要素は恒久的に対象外であり、std のコレクションについてはそこへ入れること自体を禁じる — 組込型メソッドの実引数へ多重度型の値を渡す形は pass-of-multiplicity-value になる(static-analysis.md §2.14)。std 側に抜き出す API を用意して追跡を通す道は採らない。恒久的に対象外と定めたものを追跡し直すことになり、しかも組込型メソッドは呼び先の関数型が引けないので、抜き出す API を足しても規律は復活しないからである。

要素を追跡対象にしないことと、コンテナーを対象にすることは両立する。 Hikari 側の List と record はコンテナーそのものが言語の値なので、コンテナーを束縛した名前を 1 つの追跡対象にできる(static-analysis.md §2.14「包みは多重度を伝播する」)。コンテナーを外すと取り出すたびに新しい義務が生まれる一方でコンテナーからは何も減らないので、1 つの資源に独立に果たせる義務がいくつでもできてしまう。コンテナーを追跡対象にすると取り出しがそのコンテナーの消費になり、2 度目の取り出しは消費後の出現として止まる。

record のスロットの参照はコンテナーの出現として数える。 r.held は r の出現であり、その位置で r.held の値が消費されるなら r の消費、借用されるなら r の借用である(static-analysis.md §2.14「record はコンテナーである」)。したがって r := { held := l |} から r.held を 2 度取り出す形は use-after-consume になる。

コンテナーを追跡対象にできるのは、差し替えが起きないときである。 別名を作る q := r はコンテナーの消費として記録できるが、スロットへの差し替え(r.held = l2)はコンテナーの中身を追跡から見えないまま入れ替える。取り出して消費済みになったコンテナーへ入れれば差し替え後の参照が誤検出になり、取り出す前に入れれば旧値の義務が消える。そこで多重度型を含むスロットへの代入は静的に禁じる(static-analysis.md §2.14 の assign-of-multiplicity-slot)。中身を入れ替えたいときは、名前分解({ held, n } := r)で取り出してから record を作り直す。

取り出してローカルへ移す形が規律に乗るのは、コンテナーから要素が減るときである。 ユーザー定義のコンテナーなら h, rest := o.take_h()! がこれにあたり、入れる形が消費として記録され、(要素, 残り) を返す関数で取り出せば追跡対象に戻る。コンテナーから何も減らさずに覗くだけの形は、コンテナーの側を消費として記録しない限り義務を増やすだけである。

17.9 効果型(計算が外界に対して何をするかを載せた型)

本節が定める型は、値でも使用でもなく計算を記述する型である。 §17.8 が「値を記述する型」から「使用を制約する型」へ射程を広げたのに続き、本節はさらに「その計算が外界に対して何をするか」を型に載せる。Int は値の種類を、NonZero(T)(§17.7)は値が 0 でないことを、多重度型(§17.8)は値を何回使えるかを述べる。本節の型が述べるのは、その関数を呼んだときに起きることである。

語の範囲を先に定める。効果ラベルとは prelude がスコープに載せる 8 つの名前(Io / Fs / Net / Proc / Time / Rand / Mut / Susp)を指す。効果型とは Effect(T, …) を指し、結果型 T とその計算が起こす効果ラベルの集合を述べる。EffectConduit(F) はそれに付随する語彙で、引数の効果が呼び出し元へ透過することを表す。

Effect / EffectConduit と 8 つの効果ラベルはいずれも prelude がスコープに載せる名前であり(値ではなく、型式の位置でだけ引ける。§17 冒頭)、新しい予約語も新しい記号も持たない(§1.2.2 / §1.4 の予約語は増えない)。Comparable / Copyable が組込の特別な型ではなく prelude 定義の構造型である(§17.5)のと同じ位置づけで、書式は List(T) / Option(T) と同じ型コンストラクターの適用に乗る。効果の推論・伝播の詳細と診断は static-analysis.md が定める。

効果ラベル

ラベル 意味
Io 対話デバイスへの入出力
Fs ファイルシステム
Net ネットワーク
Proc プロセス環境
Time 時計を読む
Rand 非決定
Mut 外側の可変状態への書き込み(下記「Mut の判定」)
Susp 中断点 — 呼んだフローが中断しうること。未完了 Future への ! と、中断する組込(§10.1)

どの関数がどのラベルを持つかは、関数を定める文書が決める。 prelude の組込は prelude.md §17.1、標準ライブラリは std/index.md の「モジュールの効果」と各書のメンバー表が定める。

集合は閉じている。 ユーザーが効果ラベルを追加する手段は持たない。ラベルは処理系が外界に触れる経路の分類であり、書き手が増やす対象ではないためである。

線はモジュール単位ではなく能力単位で引く。 std:time は暦の算術が大半で、外界に触るのは現在時刻を読む関数だけなので、その関数だけが Time を持ち残りは純粋である。

効果型の書式

add: { Int, Int | Int } := { x, y | x + y }  # 効果なし(従来の書き方のまま)

greet: { String | Effect(Unit, Io) } := { name |
  println "Hello, ${name}"
}

type CopyFile := { String, String | Effect(Future(Result(Unit)), Fs, Susp) }

効果は集合なので、Effect(T, …) の第 2 引数以降は順序を正規化し重複をまとめる。効果ゼロの Effect(T) は T に退化する — OneOf(A) ≡ A(§17.4)と同じ正規化であり、Effect(Int) と Int は同一の型として振る舞い、表示も Int になる。

Effect(T, …) は基底型 T を包むコンテナーではない。 値の構造は T のままで、取り出し(unwrap)は要らない。多重度型が基底型を包まない(§17.8)のと同じ規律で、帰結として本体の書き方は効果の有無で変わらない — 逐次実行は §11.1(; / 改行はシーケンス、最後の値が返り値)のままであり、bind の連鎖も専用の記法も導入しない。

効果の層は多重度の義務を素通しする。 Effect(ExactlyOnce(T), …) を結果型に宣言した関数の返り値を束縛した名前は、ExactlyOnce(T) を宣言したときとまったく同じ義務を背負う。効果の層はコンテナーではない以上そこに在るのは T の値そのものであり、値に課された規律を消す位置が無いためである。効果を書いただけで判定が変わってはならないという上の規律を、型の照合だけでなく使用の規律へも及ぼす読み方である。

層は包みと重なってよい。 効果の層の内側が多重度を伝播する包み(static-analysis.md §2.14「包みは多重度を伝播する」)なら、層を跨いだうえで包みの規則がそのまま働く — Effect(Future(Result(File)), Fs, Susp) は層 1 枚と包み 2 段の先にある File の義務を届ける。

束縛の型から効果の層が落ちるわけではない。 型の側は Effect(…) のままで、剥がすのは構造を覗く側である(上記「基底型 T を包むコンテナーではない」)。したがって束縛に別の型を注釈して食い違わせれば、診断には効果の層を付けた綴りが出る。どの診断がどの形で出るかは static-analysis.md §2.14 が定める。

type Txn := ExactlyOnce({ commit: Consuming({| Unit }) |})

begin := {| { commit := {| () } |}: Effect(Txn, Fs) }

run := {|
  t := begin()  # t は ExactlyOnce の義務を背負う
  ()  # エラー: never-consumed(効果の層は義務を消さない)
}
import fs := "std:fs"

report := { path: String |
  text := fs.read(path)!?
  println text
  Ok(text.length!)
}
# 推論される型: { String | Effect(Result(Int), Io, Fs, Susp) }

書ける位置は結果型に限る

Effect(T, …) を書けるのは関数型の結果型位置だけである。 束縛注釈・パラメーターの型・タプルの要素・組込タグの payload・ユーザー定義 enum の通常スロット・型コンストラクターの引数に書いたら宣言の時点で型エラーとする。効果は「呼んだときに起きること」なので、値を受け取る位置に書いても指す対象が無く、診断を出さずに受け取ると「書いたのに効かない」位置ができる。Consuming(F) の位置を構文で決めている(§17.8)のと同じ理由・同じ判定である。

結果型の宣言 3 形(束縛注釈・内部名注釈・body 末尾アスクリプション、§17.3)はいずれも結果型位置なので、どの形でも書ける。

伝播と部分型

  • 効果を生むのは組込だけである。 ユーザーコードは効果の葉を持たず、prelude / std の組込呼び出しだけが効果を生む。
  • 関数の効果は本体で起こる効果の和集合である。
  • 効果は、その計算を起動した地点に帰属する。 fork(block) / spawn(block) はその地点で block の効果を計上するので、f! が同じ効果を二重に計上することはない。ただし、特定のフローやフレームについて述べるラベルは、そのフローやフレームの外へ出ない。 Susp(呼んだフローが中断しうる)は子フローの外へ出ず、Mut(呼び出しフレームの外への書き込み)はフレームの内側で吸収される(下記「Mut の判定」)。子フローが中断しても起動した側は中断しないので、起動した側の中断点は結果を待つ ! であり、! が Susp を足す。
  • 宣言は包含を要求する。 結果型を宣言した関数は、宣言した効果集合が本体の効果を包含していなければならない。

効果集合の部分型関係は上向きにだけ緩む — 効果の少ない値は多い位置へ渡せるが、逆はできない。純粋な関数は Effect(T, Io) を宣言した位置へ渡せる。これは record の幅部分型(宣言より多くのスロットを持つ値が通る、§17.2)とは向きが逆であり、同じ「緩められる方向」という語で両者を読まないよう注意する。効果は「起こしうるものの上限」を述べるので、上限を上げる向きだけが安全である。

効果多相 — EffectConduit(F)

高階関数は、渡されたブロックが起こす効果をそのまま呼び出し元へ返す。この性質をそのパラメーターの型に書く。

map: { List(a), EffectConduit({ a | b }) | List(b) }
sort_by: { List(a), EffectConduit({ a | b }) | List(a) }
xs.map { x | x * 2 }  # List(Int)(効果なし)
xs.map { x | println x }  # Effect(List(Unit), Io)

EffectConduit(F) を宣言した関数の効果は「自分の本体が起こす効果 ∪ その引数に渡された値の効果」になる。効果変数(あらゆる高階関数に伝染する全称量化された変数)は導入しない — 表現力と引き換えに、すべての高階関数へ注釈負担を課すことになるためである。Consuming(F) と同じく関数型を基底に取る位置マーカーであり、基底が関数型でなければ宣言の時点で型エラーとする。

透過が効くのは、宣言した関数の中でそのパラメーターを呼ぶ位置である。 呼び出し地点が足すのはその呼び出しが渡した値の効果なので、宣言した関数の本体の中で(入れ子の関数リテラルの中を含む)パラメーターそのものを呼ぶ分と、別の透過の位置(if cond then { … } の then・EffectConduit を宣言した別の関数のパラメーター)へ渡す分は、宣言した関数の効果に数えない。

宣言した関数の外へ持ち出されうる値は、上限の効果を持つ。 値が呼び出しの外へ持ち出されて後で呼ばれると、渡した値の効果はどの呼び出し地点にも計上されない。そこで次の値は 8 つのラベルすべてを効果の上限として型に持つ。

  • 透過のパラメーターを別名・スロット・コンテナー・型変数を経て運んだ値。型は EffectConduit(F) のまま運ばれ、それを呼ぶ位置は上限の効果を持つ
  • デフォルト値を持つか mutable な透過のパラメーター。値が実引数とは限らない(実引数を省けばデフォルト値を呼び、本体で差し替えられる)ので、宣言した関数の中で呼んでも上限の効果を持つ
  • 透過のパラメーターを捕獲する入れ子の関数リテラル(名前に束ねたもの・返すもの・保存するもの)。ただし、その場で引数を埋め切って起動するもの({ … }!・conduit { … } 0)と、透過の位置へ実引数として直に渡したもの(xs.each { … }・if c { … } { … })は、値をその位置でしか使えないので上限にしない。ただし内部名を呼ぶ以外に使うリテラルは、この例外に入らない
  • 呼び先が透過の値であるか、透過のパラメーターをその段で埋めた部分適用(h(1)・invoke(h))の結果。結果は呼び先と実引数を保持する
  • 別フロー(fork・spawn、serve のハンドラー)の中で呼ぶ分。子フローは宣言した関数が戻った後も走りうる

上限なので持ち出し自体は静的エラーではない。持ち出した値を、上限を許さない位置で呼べば拒まれる。純粋な上限を書いた位置({ Int | Int } のパラメーターなど)へ透過のパラメーターを渡すと、渡した位置で拒まれる。

EffectConduit(F) を書けるのは関数のパラメーターの型だけである。 束縛の注釈・record 型の欄・データオブジェクトのスロットの型には書けず、型の中でも関数型のパラメーターの位置以外(関数型の結果・List(F) や Option(F) の要素ほか)には書けない(静的エラー)。透過は「呼び出しに渡した値の効果がその呼び出し地点に通る」という宣言なので、呼び出しに渡す位置でしか意味を持たない。保存して後で呼ぶコールバックは、基底の関数型に効果の上限を書いて受ける。保存した値の効果は、保存した型が述べる上限として型で運ばれる(下記「推論した関数型は効果を運ぶ」)。

Checkbox := { id: String, on_change: { Bool | Effect(Unit, Mut) } |  # 上限を書く
  { inner_bound me,
    mutable checked := false
    on_change := on_change  # 保存してよい(EffectConduit ではない)
    toggle: {| Effect(Unit, Mut) } := { me.on_change me.checked }
  |}
}

wrap := { h: EffectConduit({ Int | Int }) | { n: Int | h n } }  # 返す関数は上限の効果を持つ
pure: {| Int } := {| wrap { n: Int | n } 1 }  # 静的エラー: 上限の効果は純粋の宣言に収まらない

上限を書いて受けたパラメーターには、上限より少ない効果のコールバックも渡せる(下記「伝播と部分型」)が、呼んだ地点では上限の効果として扱われる。

効果透過と制御透過は別の軸である

conduit(§18.3)は制御の透過だけを述べ、効果には関与しない。 両者は独立に指定でき、片方だけを持つ関数が実在する。sort_by の key ブロックは副作用を持ちうる(prelude.md §13.4 が「副作用も 1 回」と定める)ので効果は透過させたいが、key ブロック内の break が呼び出し元のループへ抜けるとソートが途中で放り出されるため制御は透過させたくない。したがって 2 つの軸を 1 つのマークに束ねてはならない。

制御透過は値に載る前置注釈(conduit)であって型には現れない(下記「持たないと決めたもの」)。

効果の横取り、継続、効果の差し引きは提供しない。出力先や読み取りの方針を変えるときは通常の関数引数や能力 record を渡す。組込 handle は存在しないが、同名のユーザー定義は通常の名前として使える。

Mut の判定

Mut は自分の呼び出しフレームの外にある可変状態への書き込みを指す。 フレーム内で生まれフレーム内でしか触られない可変状態は呼び出し元から観測できないので、効果ではない。

sum := { xs: List(Int) |
  mutable total := 0
  xs.each { x | total = total + x }
  total: Int
}  # 効果なし

bump := { o: { score: Int |} | o.score = o.score + 1 }  # 効果は Mut

bump が Mut を持つのは、スロットの可変性が参照共有のセマンティクスを持つ(§4.1)ため、書き換えが呼び出し元から観測できるからである。

書き込みの帰属は字句で決める。 関数リテラルの本体にある書き込みは、書き込み先を宣言したリテラルに帰属する。書き込み先はローカル束縛の宣言か、受け手が確定したスロットの持ち主である(受け手の判定は static-analysis.md §2.10 の「スロット集合が確定する」に従い、判定できなければ外側に倒す)。帰属したリテラルの出口で、その書き込みの Mut は外へ出なくなる。

帰属を使えるのは、書き込みを含む関数リテラルが字句のまま届くときだけである。

  • その関数リテラル自身の本体
  • 呼び出しの位置にその場で書いた関数リテラル(ブロック引数、EffectConduit のパラメーターへの実引数)
  • 呼んだ側の本体で、関数リテラルを := で直接束ねた不変なローカル名(add := { … } の add)

3 つ目で見るのは、名前からその宣言の右辺のリテラルへの 1 段だけである。別名(g := add)・コンテナーへ入れた関数・関数の結果として返った関数・可変な名前・パラメーターで受けた関数はたどらず、その値の型が運ぶ Mut を採る(下記「推論した関数型は効果を運ぶ」)。型に載った Mut は書き込み先を述べないので、呼んだ側のどのフレームを出るときも消えない。

add_all := { xs: List(Int) |
  mutable total := 0
  xs.each { x | total = total + x }  # その場のブロック。total は add_all に帰属する
  add := { x: Int | total = total + x }  # 不変なローカル名に束ねたリテラル。同じく add_all に帰属する
  add 1
  total
}  # 効果なし

次の形では、書き込みが呼んだ側の内側で起きていても Mut が外へ出る。

mk := {|
  mutable k := 0
  { n: Int | k = k + n; k }
}

total := { xs: List(Int) |
  h := mk!  # h の型は { Int | Effect(Int, Mut) }
  xs.each { x | h x }
  h 0
}  # 効果は Mut

関数の結果として返った関数(h)のほか、inner_bound で自分の状態へ書くメソッドを、呼んだ側の内側で作ったオブジェクトに対して呼ぶ形、ブロックを別名やコンテナーを経て渡す形も同じである。純粋を要求する位置でだけ違いが観測でき、直すには宣言へ Mut を足すか、ブロックをその場に書くか、状態を借用で渡す。

借用パラメーターを通した書き込みは、その関数の型の Mut に入れない。 借用の指す可変状態は呼び手が所有しているので、その関数を呼んだ位置で、借用のパラメーターへ渡した実引数に帰属させる。

  • 実引数が呼んだ側の局所の名前なら、Mut は呼んだ側の外へ出ない
  • 実引数が呼んだ側の借用パラメーターなら、同じ規則で、さらにその呼び手へ委ねる
  • それ以外は呼んだ側の Mut になる

判定に使うのは、呼び先の関数型のパラメーターが Borrowed であることだけである。名前で直に呼んでも、値として持ち運んだ関数を呼んでも変わらない。借用パラメーターへ実際には書き込まない関数も同じに扱う。部分適用で借用のパラメーターを先に埋めたとき(p := mark(a); p(1))は、埋めた位置で実引数に帰属させる(残りの段の関数型は借用のパラメーターを持たない)。引数ゼロの kick がデフォルト値で借用のパラメーターを埋めるときは、デフォルト値が指す可変状態の所有者を呼んだ位置から決められないので、呼んだ側の Mut にする。関数と実引数を 1 つのタプルの値にまとめて capture(t) へ渡したときも、借用のパラメーターへ渡る実引数を呼んだ位置から決められないので、同じく呼んだ側の Mut にする。

mark := { a: Borrowed(arr.Array(Int)) | a.set(0, 1) }  # 型に Mut は載らない
fresh := {|
  a := arr.array(2, 0)
  mark a
  a.frozen()
}  # 効果なし(書き込み先は fresh の局所の配列)

スコープ吸収はこの規則の特別な場合である。EffectConduit なブロック引数を取る関数がそのブロックへ Borrowed(T) を貸し出すとき、ブロックが貸し出された借用へ書くだけなら、ブロックの型に Mut は載らない。この規則により、可変配列を内部で使う関数が効果を持たずに済む。

sorted := arr.build(xs.length!, 0) { a | a.set(i, v) }  # 効果なし

借用が保存できないこと(§17.8)がこの帰属を支えている。 貸し出されたハンドルは束縛にもコンテナーにも別フローにも置けないので、ブロックの外へ出られない。生存期間の添字(region)を持たずに借用を式スコープへ閉じ込めた設計が、そのまま「内部の可変性は外から観測できない」ことの根拠になっている。

fork は可変状態を共有する協調フローなので、そのブロックの Mut は透過する。spawn は捕獲した可変状態を複製して切り離す(§10.1)ので、子フローの書き込みは親から観測できず Mut を起こさない。std:parallel の並列コンビネーターも捕獲を隔離複製するが、そちらは捕獲した可変状態への書き込みそのものを実行時に拒む(std/parallel.md §1)ので、Mut を問う前に止まる。

std:parallel のコールバックは中断でき、その Susp は結果を待つ呼び手へ伝播する。
捕獲した可変状態への書き込みを拒むゲートは、そのコールバックを実行するフローにだけ効く。

効果の実行時の扱い

値を作った計算の効果は実行時に照合しない。
その地点にあるのは値であり、その値を作るまでに行われた計算ではない。
注釈の代入可能性は、効果も含めて静的に検査する。

関数型の照合は値が持つシグネチャを使う。
関数値の型には、検査器が決めた引数型・結果型・効果が載る。
matches とアスクリプションは、この型を対象の関数型に照らす。
これは関数の本体を実行して効果を観察する操作ではない。
本体から推論した効果も、明示した効果も同じように型に含まれる。

純粋を要求する位置へ、効果を持つ関数を直接渡す形は静的エラーである。
Any から関数型へ取り出すときにも、その関数値が持つ型を使う。

apply_twice: { { Int | Int }, Int | Int } := { f, x | f (f x) }
apply_twice({ n | n + 1 }, 3)  #> 5

noisy: Any := { n: Int | println n; n + 1 }
noisy.matches type { Int | Effect(Int, Io) }  #> true
noisy.matches type { Int | Int }  #> false
apply_twice: { { Int | Int }, Int | Int } := { f, x | f (f x) }
apply_twice({ n | println n; n + 1 }, 3)  # 静的エラー

効果の保証: 静的に受理したプログラムでは、効果を持つ関数値を、
その効果を許さない関数型の位置へ置くことはできない。
値の位置に関数型や効果が未確定のまま残る形は受理しない
(static-analysis.md §2.15)。

推論した関数型は効果を運ぶ

効果は型に書かれていなくても本体から決まる。そこで結果型を宣言しない関数の静的型は、本体の効果を結果型に載せる — noisy := { n: Int | println n; n } の静的型は { Int | Effect(Int, Io) } である。書き手が結果型を宣言した関数は、宣言した型がそのまま静的型になる(本体の効果が宣言に収まらなければ定義の側で静的エラーになる)。

静的型が効果を運ぶので、関数値をどこへ持ち運んでも効果は落ちない。別名を経た値・関数の戻り値・分解束縛した名前・if / when / match が合流した値・コンテナー(List・Option・Result・Future・タプル・record・ユーザー定義の総称 enum のタグ・std のコレクション)へ入れて取り出した値のどれもが、元の関数の効果を持つ。

  • 合流は効果の和を採る。 パラメーターの型が等しい関数型同士を合流すると、結果型を合流し、効果はその和になる。[pure, noisy] の要素型は { Int | Effect(Int, Io) } であり、何を取り出しても Io を持ちうる値として扱う。効果集合の部分型は上向きにだけ緩むので、両方の値を受ける型は効果の多い側である。
  • 注釈の位置ではコンテナーの中身の型まで照合する。 xs: List({ Int | Int }) := [noisy] のように、型引数や要素の位置に純粋な関数型を書いた注釈も照合の対象である。束縛・引数・ブロックパラメーターのどの位置でも同じである。
noisy := { n: Int | println n; n }
xs := [noisy]
purely: { Int | Int } := xs.first!.unwrap!  # 静的エラー
ys: List({ Int | Int }) := [noisy]  # 静的エラー
[noisy].each { f: { Int | Int } | f 1 }  # 静的エラー

Mut もほかの 7 ラベルと同じく型に載る。 推論した型に載るのは、書き込み先が本体の外にある分(上記「Mut の判定」)である。借用パラメーターを通した書き込みは載らず、呼んだ位置で実引数に帰属する。値として持ち運んだ関数を呼ぶ位置は、その値の型が持つ Mut を、ほかのラベルと同じくそのまま計上する。

可変な位置へ書く関数値も、確立した型へ静的に代入できなければならない。
その位置が許さない効果を持つ関数は、注釈の有無によらず書き込めない。
受け手の型や書き込み先の型を示せない形も静的エラーである。

関数型へのアスクリプションでは、関数値が持つシグネチャを使って照合する。
対象の型に静的に一致すると証明できた場合だけ照合を省略する。
実行済みの計算について効果を後から検査する操作は持たない。

持たないと決めたもの

次は効果の型に載せない。実装が進んでも載せない。

  • リソースごとの Mut の細分 — 「この配列への Mut」と「あの配列への Mut」を型で区別しない。区別しないため、型に載った Mut はどのフレームを出るときも消えず、書き込みが外へ出ないと言えるのは上記「Mut の判定」の字句の帰属と借用の帰属だけである。
  • 制御透過の型化 — 上記「効果透過と制御透過は別の軸である」のとおり、ControlConduit(F) は導入しない。名前を取り置いてもいない — 値位置でも型位置でも束縛が無いので、書き手が ControlConduit を別の意味で使うことは妨げられない。

18. 制御フローと制御値

break / continue(局所制御)・return(脱出)・ユーザー定義の制御構造とループ(conduit / loop)・末尾呼び出しは、いずれも §16 冒頭の「専用の例外機構や大域脱出を持たない」という原則を共有する制御構文である。これらは例外機構ではなく、回復可能エラー(§16.1)とは別系統で処理系の内部を値として伝播し境界で捕捉される制御値(Break / Continue / Return / TailCall)で実現される — だからこそ関数境界を越えず、各関数を呼び出し元から独立に読める。失敗 bail ?(§16.5)も同じ Return 制御値を用いるが、エラー処理の一部として §16 で扱う。本章はこれら制御値の意味論と、それをユーザー/prelude が self-host するための注釈(conduit / loop)・観測 primitive(capture)・末尾呼び出しの定数スタック保証をまとめる。

18.1 局所制御フロー (break / continue)

break / continue はループ反復の 局所制御 であり、§16 冒頭の「専用の例外機構や大域脱出を持たない」原則の例外ではない。API と例は prelude.md §8.5。

  • 字句スコープ: それを字句的に囲うループ (while / each 系) のブロックにのみ効く。関数定義境界を越えない — ループ内から呼び出した関数の中の break は、字句的に囲うループが無いため panic (§16.2)。これにより「呼ばれた文脈のループを遠隔で切る」動的脱出 — break が、自分を字句的に囲うループではなく、呼び出し元が実行時に積んでいるループへ届く形 — を排し、関数を呼び出し元から独立に読めるようにする。conduit 関数 (§18.3) は例外で、自分の境界で break / continue を捕捉せず素通しするため、その関数を貫いて字句的に囲うループ (呼び出し側) へ届く (builtin if / when と同じ透過)。この透過は実引数の位置に書いたブロックに限る — 名前へ束縛してから if や each へ渡したブロックの break は、書いた位置にループが無ければ panic する (§18.2「透過するのは実引数の位置に書いたブロックだけである」)。
  • 実現は特殊戻り値方式: 内部表現は Break / Continue 制御値で、回復可能エラーとは別に処理系の内部を値として伝播し、(a) 囲うループ構造、(b) 関数定義境界の両方で捕捉される。関数境界で捕捉する (越えると panic) ため、値としては伝播しても大域脱出にはならない。
  • 式としての型は Never (§17.2): break / continue はその式位置で決して値に評価されず制御がループへ移るため、型上は発散 (ボトム型 Never) する。panic / exit と同じく分岐合流の恒等元で、if (c) { v } { break! } の結果型は v の型に解ける (static-analysis.md §3)。
  • 値つき・多値 break: break(value) はループ式全体の戻り値を value にする。多値は break(a, b) または break((a, b))(両者は同義、後者の外側括弧はグルーピング)で抜ける — return と対称。, はタプル構築のため、括弧なしの break a, b は (break a), b と解釈される。break! / 通常終了時の戻り値は () (unit)。
  • ループ外での使用: 字句的に囲うループの無い箇所での break! / continue! は panic (バグ層、§16.2)。
  • 呼び出さずに参照すると静的エラー: break / continue / return は予約語ではなく prelude 束縛だが (§1.2.2)、呼び出しの先頭にしか置けない — break!・break(v)・break v・continue!・return x・return(a, b) の、呼ばれる側の位置である。それ以外の位置 (b := break の右辺・if (c) { v } { break } の枝の本体・実引数・コレクションの要素など) に書くと静的エラー (構文層) になる (static-analysis.md §1 の uncalled-control)。構文層の検査なので、entry だけでなく import 先のファイルに書いた綴りも実行前に止まる。呼ばずに書いた綴りは発火しないので、許すと { break } と書いたループが止まらず、何の診断も出ないまま回り続ける。抜けるには break! と書く。書き手が同じ綴りを束縛して覆った名前 (§1.2.2 の被覆) はその束縛を指す普通の名前で、この規則の対象外である。
  • 呼び出しへ実引数を重ねると静的エラー: 並置はカリー化した適用なので (§3.5)、return id 5 は (return id) 5 と読まれ、内側の return id が発火した時点で制御が移る。後ろの実引数は決して評価されないので、この形は静的エラー (構文層) にする (static-analysis.md §1 の curried-control)。呼び出しの結果を渡すときは括弧で包む — return (id 5)・break (f x)。break / continue も同じである。
  • ラベル付き脱出は持たない (最内ループのみ)。多重ループの一括脱出はフラグや関数分割で表現する。

18.2 脱出 (return)

return は関数本体から値を返して 脱出 する明示的構文であり、§16 冒頭の「専用の例外機構や大域脱出を持たない」原則の例外ではない (break / continue と同じ局所制御)。body の 任意の位置 に書ける — 末尾に置いた return v は v をそのまま書くのと等価 (body は元々最後の式の値を返すため、§11.1) であり、return の意義は 末尾でない位置から関数を抜けられる こと (ガード節・失敗 bail などの早期脱出の用途) にある。API と例は prelude.md §8.6。

  • 字句スコープ: return は 最も近い、実呼び出し (関数適用) で入ったユーザー関数 {...} の境界 で取り出され、その関数の戻り値になる。if / when / while / each のブロックと match のアーム body は呼び元 (ビルトインまたは match の評価) が呼ぶため 透過 — when (bad) {return v} は when を貫いて外側の関数から脱出する (break が if を貫いてループに効くのと同一経路)。自前の高階関数に渡したブロック内の return は、そのブロック自身から脱出する。ただし conduit 関数 (§18.3) は境界で return を捕捉せず素通しする — ユーザー定義の制御構造 (conduit { cond, then | … }) に渡したブロック内の return は、builtin when と同じく外側の関数から脱出する。
  • 透過は制御構造に限らない: 「ブロックを内部経路で起動する」性質は if / when / while / each に固有ではなく、ブロックを取る組込メソッド一般に及ぶ。xs.map / xs.find / o.and_then / r.map_err / ord.then のブロック内 return も、each と同じく外側の関数から脱出する — 組込はブロックの評価結果を値としてまとめてはならない (まとめると制御値がデータ構造へ漏れる)。例外は Future のメソッド (f.map / f.and_then、prelude.md §9): これらのブロックは別フローで遅延起動され、評価される時点で外側の関数は既に戻っているため脱出が成立しない。Future のブロックに return (構文糖の ? を含む) や break / continue を書くのは誤用であり、評価時に panic する — 制御値は payload に入らず、! を当てた消費側フローへ panic として伝播する (§10.2)。素通しすると return を書いた関数ではなく ! を書いた無関係な関数が脱出することになり、§18.1 が排除した動的脱出を Future 経由で復活させてしまう。誤用は static-analysis.md §2.12 が静的にも報告する。
  • 透過するのは実引数の位置に書いたブロックだけである: 組込の制御構造・ブロックを取る組込メソッド・conduit / loop 関数を貫くのは、その呼び出しの実引数の位置に字句的に書いたブロックリテラル(インラインで書いたブロック)の中の return / break / continue だけである。名前・スロット・コンテナーへ入れてから渡したブロック (b := { return 5 } の後の if c b { 0 }) の中の脱出は、ブロック自身の境界で取り出される — return はブロックの戻り値になり、break / continue は字句的に囲うループの無い形として panic する (§18.1)。capture (§18.4) が観測する転帰も同じで、そうしたブロックの転帰は Normal か panic である。透過しない関数の実引数に書いたブロックも、その関数の中で組込へ渡されたときは透過しない。conduit / loop 関数が受け取ったブロックを組込や capture へ渡す形 (§18.3 の when) は、呼び出し側が実引数の位置に書いたブロックを運ぶので透過を保つ。
    インラインで書いたかどうかは、そのリテラルの出現位置で決める。
    別のリテラルや、別のモジュールの読み込みによって、この分類は変わらない。
    • なぜか: 名前を経たブロックも透過させると、別の関数で定義したブロックの break が、そのブロックを字句的に囲わないループへ届く — §18.1 が排除した動的脱出である。透過するかはブロックを書いた位置の綴りで決まるので、静的検査も書き手も同じ答えを出せる。
  • 実現は特殊戻り値方式: 内部表現は Return 制御値 (§18.1 の Break / Continue と同系統) で、回復可能エラーとは別に処理系の内部を値として伝播し、ユーザー関数の呼び出し境界で捕捉される。break / continue が境界を越えると panic 化されるのに対し、return は捕捉時に 値を取り出して関数の戻り値にする。break / continue を消費するのは反復駆動の組込 (while / each) だけで、結果を値として使う組込 (map / filter / and_then ほか) のブロックに現れたら診断になる。
  • 式としての型は Never (§17.2): return v はその式位置で値に評価されず関数から脱出するため、型上は発散 (ボトム型 Never) する。if (c) { v } { return d } の結果型は v の型に解ける (分岐合流の恒等元、static-analysis.md §3)。脱出する値 v の型は関数の結果型 (末尾値・? の bail と合流) に別途寄与するもので、return 式そのものの Never とは独立。
  • while / each との関係: ループ本体の return はループでなく 外側の関数 から脱出する (break はループだけを抜ける)。ループは Return を消費せず素通しする。
  • 多値: タプルで返す。return(a, b) または return((a, b))(両者は同義、後者の外側括弧はグルーピング)。, はタプル構築のため括弧なしの return a, b は (return a), b と解釈される点に注意。受け側は x, y := … で分解する(§6.3)。
  • トップレベル: ファイル (暗黙 root リテラル、§13.1) のトップレベルに書いた return は そのファイルのロードを中断 する。ファイルは body を持たないので「止めて値を返す」相手がいないため、オブジェクトは生成されない — したがって「宣言されたが評価されていないスロット」が観測されることはなく、スロット集合の固定 (§2.4) は保たれる。中断は ? の bail と同じ経路で表面化する (§16.5)。break / continue が囲うループ不在で panic になるのと異なり、return は root でも意味を持つ。

std:array の Array.update・build・collect と、std:map の ScratchMap.update・insertion.build も return を外側の関数へ透過する。
ブロックから return した場合、更新結果の書き込みやハンドルの確定は行わない。

import arr := "std:array"
f := {
  arr.build(1, 0) { a | return 7 }
  9
}
f!  #> 7

18.3 制御透過関数 (conduit)

if / when / while 等の制御構造は prelude が束縛した builtin (match は 予約語) であり、ブロック (枝の body) を内部経路で起動するため return / break / continue 制御値を素通しする(§18.1 / §18.2 の「透過」)。一方、ユーザーが Hikari で同型の制御構造を書こうとして when := { cond, then | if cond then {()} } のように普通の関数で定義すると、その関数の呼び出し境界で return が unwrap され(break/continue は「ループ外」panic)、透過が途切れる。つまり透過は builtin の特権で、ユーザー関数は既定で不透過——という非対称があった。

conduit はこの非対称を埋める注釈である。関数リテラルの開き括弧の前に conduit を置くと、その関数は自分の呼び出し境界で return / break / continue を捕捉せず上位へ素通しする(builtin 制御構造と同じ扱い)。これにより制御構造をユーザー/prelude で Hikari 定義できる。

when := conduit { cond: Bool, then: {| Unit } |
  if cond then {
    ()
  }
}
unless := conduit { cond: Bool, then: {| Unit } |
  if cond {
    ()
  } then
}
# 早期 return を呼び出し元へ透過
guard := conduit { cond: Bool |
  when cond.not! {
    return()
  }
}
  • 対象は関数リテラル {...} のみ(§1.4)。conduit と { の間の空白は任意。
  • 透過するのは制御値の伝播だけ。適用規則(§3.5 / §3.6 のカリー・束縛)・スコープ・型・通常の戻り値(末尾式の値)は普通の関数と同じ。
  • 既定(conduit なし)の関数挙動は不変。conduit を付けない関数は境界で return を unwrap し、break/continue をループ外 panic にする(§18.1 / §18.2)。本注釈は後方互換な opt-in 追加で、既存コードの意味は変わらない。
  • 字句スコープの維持(§18.1): break / continue トークンは呼び出し側のブロックに字句的にあり、conduit 関数はそれを通すだけで、builtin when / if が貫通させているのと同一経路に乗る。「呼ばれた文脈のループを遠隔で切る動的脱出は持たない」は保たれる。conduit 関数の本体に裸の break! を直書きした場合は、その制御値が上位の非透過境界(通常関数 or トップレベル)まで素通しして、そこで「ループ外 break」として panic 化される(検出位置が一段上がるだけで意味は同じ)。each のようにブロックを呼んで制御値を捕まえるループの中から呼んでも同じで、ブロックはそれ自身が通常の関数なので、字句的にブロックの外で作られた脱出はブロックの境界で止まり、ループには消費されない。字句的に内側と数えるのは、呼び出しの実引数に break / continue を書いた形 (my_when(c) { break! }) である。
  • break / continue を消費するループそのものは対象外。独自 repeat / for 等、break / continue を自分で消費するループを書くには loop 注釈と capture primitive を使う(§18.4)。conduit は「ブロック起動を builtin に委譲する conduit 系制御構造」と return 透過を対象とする。

§18.1(break / continue)・§18.2(return)の「if / when / while / each のブロックは透過」という規則は、conduit 関数にも同様に及ぶ(builtin 制御構造と conduit 関数を貫いて外側の関数 / ループへ届く)。

18.4 ユーザー定義ループ (loop / capture)

conduit(§18.3)は return / break / continue を素通しするだけの conduit 系制御構造を self-host できるが、while / each のように break / continue を自分で消費するループは書けない。ループには (a) 自分が break / continue の捕捉境界だと宣言するマークと、(b) 起動したブロックの制御転帰を値として観測する手段が要る。前者が loop、後者が capture である。

capture(制御転帰の観測)

capture は prelude 束縛の値(break / while と同系で新予約語ではない)。capture(block, args…) は block を呼び出し境界でトラップせず起動(builtin each がブロックを内部経路で起動するのと同じ)し、その転帰を Control 値として返す。第 2 引数以降が block への実引数になる(capture(body, x) ≡「body(x) の起動を観測」)。

値としての capture の代表型は { {| Any } | Control } で、引数なしのブロックを受ける。直接の呼び出しでは、実際のブロックの引数型と args… を照合する。この起動契約は、別名・多相関数の戻り値・レコード欄・可変束縛を経ても保持する。

通常の関数型へ渡すときは、その契約が許すすべての入力で先頭のブロックを起動できることを要求する。例えば { {| Int } | Control } は満たすが、任意の値を先頭入力に許す { Any | Control } は満たさない。ブロックの効果も結果へ透過させる。明示の関数アスクリプションでも起動契約を評価地点で照合し、不一致なら panic する。関数型同士の一般的な不変性は変わらない。

enum Control := {
  export { Normal(value), Broke(value), Continued, Returned(value) },
  Normal := { value: Any |},
  Broke := { value: Any |},
  Continued := {},
  Returned := { value: Any |}
| OneOf(Normal, Broke, Continued, Returned) }
タグ payload 意味
Normal(v) ブロックの末尾値 正常終了
Broke(v) break の値(break! は ()、多値は tuple 1 個) break 発火(§18.1 の値つき break)
Continued なし continue 発火
Returned(v) return の値 return 発火

通常の構文呼び出し body(x) ではブロック内の return が unwrap され、break / continue は「ループ外」panic 化されて転帰を区別できない。capture は block を非トラップ経路で直接起動してこれらを生の制御値のまま値化する。ブロックを引数として渡す形(thunk capture { body(x) } ではない)なのはこのためで、thunk に包むと内側の構文呼び出し body(x) が body の境界で先にトラップされてしまう。一方 block の内部でさらに別の関数を呼びその中で break した場合は、その関数境界で「ループ外」panic になる(字句スコープ保証 §18.1 は不変。capture が観測するのは渡した block 自身の転帰のみ)。非トラップで起動するのは、capture の実引数の位置に書いたブロック (loop / conduit 関数がパラメーターで運んだものを含む) に限る。名前へ束縛してから渡したブロックは普通の呼び出しとして起動し、その転帰は Normal か panic になる (§18.2「透過するのは実引数の位置に書いたブロックだけである」)。Control は Ordering / Option / Result と同族の closed variant で、match の網羅性は静的型検査が要求する(static-analysis.md §2)。

loop(捕捉境界の宣言)

loop {...} は関数を break / continue の捕捉境界(ループ)として宣言する前置注釈。

  • runtime: 自分の呼び出し境界で return は素通しする(ループ本体の return は外側の関数へ脱出。each / while と同じ)。break / continue は本体内の capture が観測・消費するため境界には現れない。透過プロファイルは conduit(return / break / continue の全てを素通し)とは異なり、return のみ素通しする。
  • static: この関数へ渡したブロック内の break! / continue! を「ループ外」panic ではなく正当と判定し(§18.1)、Never / 発散解析がこの関数を while / each と同様ループとして扱う。
  • 対象は関数リテラル {...} のみ(§1.4)。conduit との併用は不可(透過プロファイルの衝突のため構文エラー)。
  • loop 本体に capture を介さず裸の break! / continue! を直書きした場合は、§18.1 のとおり「字句的に囲うループの無い break」として panic(ループ性は capture で観測したサブブロックを通じて実現され、loop 本体そのものは反復されないため)。

self-host 例

反復は inner 内部名(§4.2)の再帰で駆動する。
ファイルと body の go := { … go … } も、本体から左辺名を指して再帰できる。
右辺の評価中に直ちに左辺名を読む go := go とは、参照する時点が異なる。
この例の無名ドライバーには束縛名がないため inner recur を使う。
その末尾の完全適用は定数スタック保証の対象になる(§18.5)。
再送出する return 等の制御値を外へ通すため、ドライバーに conduit(§18.3)を付ける。

each の値つき break は任意の値を運ぶため、ドライバーの通常結果型は Any とする。

each := loop { xs: List(Int), body: { Int | Unit } |
  conduit { inner recur: { Int | Any }, i: Int |
    if (i < xs.length!) {
      match capture(body, xs.[i]) {
        Broke(v) => v  # ループ式の値は v(値つき break)
        Continued => recur (i + 1)  # 消費して次反復
        Normal(_) => recur (i + 1)
        Returned(v) => return v  # conduit ドライバー→loop 境界を貫き外側関数へ
      }
    } {
      ()
    }
  } 0
}

横流しコンビネーター(take_while 等)は同じ capture を使うが loop は付けず、break / continue / return を再送出してユーザーの外側文脈へ通す。再送出は conduit な補助関数 forward(Control を直接形へ送り直す)で書ける。forward は primitive ではなく prelude が conduit で定義する(reified な制御をそのまま外へ送り直す)。

forward := conduit { c: Control |
  match c {
    Normal(v) => v
    Broke(v) => break v
    Continued => continue!
    Returned(v) => return v
  }
}

# 停止位置(最初に述語が偽になった添字)を求めるドライバー。take_while / drop_while の共通核。
stop_at := conduit { xs: List(Int), pred: { Int | Bool } |
  conduit { inner recur: { Int | Int }, i: Int |
    if (i < xs.length!) {
      match capture(pred, xs.[i]) {
        Normal(true) => recur (i + 1)
        Normal(false) => i
        c: Control =>
          forward c  # Broke/Continued/Returned をユーザー文脈へ再送出
          panic "再送出した制御は通常の値を返さない"
      }
    } {
      xs.length!
    }
  } 0
}

take_while := conduit { xs: List(Int), pred: { Int | Bool } |
  xs.take stop_at(xs, pred)  # 述語が false になる手前まで
}

(catch-all で Control 値全体に名前を付けるため型付き束縛 c: Control => … を使う。match の値全体束縛は型付き束縛で行う、prelude.md §8.4。)

横流しコンビネーターのうち take_while / drop_while は実際に prelude(prelude.hika)へ self-host 移設済みである(停止位置を上記の stop_at で求め、結果リストの構築は native take / drop へ委ねる)。これにより述語内の break / continue / return がコンビネーターを貫いてユーザーの外側ループ・関数へ届く(native 実装はこれらを map / filter 同様「不可」とエラー化していた)。一方 while / each は native 実装である。partition / sort_by / sort_with も 2 リスト蓄積・native 比較が要るため native である。

なお上記 stop_at の inner-name 再帰ドライバー recur(i + 1) は §18.5 の自己末尾再帰にあたり、長い prefix でも定数スタックで回る。

18.5 末尾呼び出しと定数スタック(自己末尾再帰)

関数 f の末尾位置にある f 自身への完全適用呼び出し(自己末尾再帰)は、呼び出しスタックを増やさず反復として実行される(定数スタックで回る)。§18.4 の self-host ループドライバー(inner 内部名の recur 自己再帰)が長い入力で呼び出しの深さの上限(§16.6)に当たらないための保証である。

末尾位置

式が関数本体の末尾位置にあるとは、その値がその関数の結果になり、以降その関数内で評価が残らないことをいう。再帰的に定める:

  • 関数本体の最後の文の式は末尾位置。
  • 末尾位置の if (c) {t} {e} では、ブロック t / e の末尾式が末尾位置(条件 c は非末尾)。括弧で呼ぶ if(c, {t}, {e}) も同じ呼び出しなので(§3.9)同じ規則に従う。
  • 末尾位置の match recv { pat => body … } では、各アーム body の末尾式が末尾位置(照合対象 recv・ガードは非末尾)。照合対象を持たない match { pred => body … } も各 body 末尾式が末尾位置(述語は非末尾)。
  • 末尾位置の when では、分岐 body の末尾式が末尾位置(条件は非末尾)。括弧で呼ぶ when(c, {b}) も同じである。
  • conduit(§18.3)/ loop(§18.4)関数の本体の末尾式は、その関数の末尾位置。

この末尾位置は §18.1(break / continue)・§18.2(return)の制御値透過集合と同一である(builtin 制御構造のブロックと conduit / loop を貫く)。return がその位置から関数境界へ届くなら、その位置の self への完全適用は末尾呼び出しである(末尾=以降に評価が残らない、を加えた部分集合)。新しい透過規則は導入せず、既存の透過をそのまま使う。

対象と対象外

  • 対象は「self への完全適用」のみ。self は inner-name(inner 宣言。§4.2)が指す関数それ自身。recur(i + 1) のような単一スロット完全適用が該当する。
  • 対象外は呼び出しごとに深さを 1 段使う(定数スタックは self 末尾再帰の保証、それ以外は非保証)。深さが上限を超えると panic する(§16.6):
    • 末尾でない自己呼び出し: 1 + recur(n - 1)・f(recur(n - 1))・自己呼び出しの後に文が続く場合(自己呼び出しの値に演算・束縛・後続評価が乗るため末尾でない)。
    • 相互再帰・別関数への末尾呼び出し(proper tail calls): 定数スタックになるのは self への末尾呼び出しだけである。相互再帰も別関数への末尾呼び出しも結果は正しいが、1 段ずつ深さを使い、上限を超える深さでは panic する。定数スタックが要るなら、相互再帰を 1 つの self 再帰関数へまとめる(どちらの側かを引数で持つ)。
    • 部分適用の自己呼び出し(新しい Function 値を返すため末尾呼び出しにならない)。
    • 標準の制御構文を rebind した関数を通した位置: 末尾位置判定は unshadowed な if / when と match / conduit / loop を前提とする(§18.1 / §18.2 の透過が同じくこれらを前提とするのと同一)。これらを rebind した関数を貫く位置は定数スタック保証の対象外(1 段ずつ深さを使う形にフォールバックし、上限の内側なら結果は正しい)。

観測可能性

深い自己末尾再帰が呼び出しの深さの上限に当たらず完走することは観測可能な挙動であり、注釈は要らない(@tailrec 相当のマークは持たない — loop / conduit が既にドライバーに付く)。非末尾の再帰を末尾に書き換えれば定数スタックになる、という予測可能な性質として与える。