Ante：ランタイムクラッシュなしにリファレンスキューントと借用チェックを融合する試み

1. 概要と目的

• Ante は、即座にクラッシュするリスクなしに「リファレンスキューント」と「借用チェック」を融合させる新たな言語です。
• 主要なメリット：
  • プロトタイプの柔軟性を確保しつつ（リファレンスキューント）、最終的には高速で安全なコードへ移行できる。
  • Rust の

    RefCell

    や Swift のランタイムチェックによるランタイムパニック（クラッシュ）リスクがない。
• 現状の課題：
  • Rust (

    Rc<RefCell<T>>

    ) や Swift は、両者をシームレスに結合する道を探れず、ランタイムで高価なチェックを行わざるを得ない。
  • 統合は困難でしたが、Ante はそれを達成しました。

注意：Ante は現在進行形のプロジェクトです。一部の実装済み機能、一部は理論的であり、設計も決定待ちです。最新情報は公式サイトや Discord を参照してください。

---

2. Ante の核心概念：Shape-Stability（形状安定性）

Ante がメモリ安全性を実現する鍵となるのは「Shape-Stability（形状安定性）」という概念です。

• 定義：あるオブジェクトへの参照は、どこでどのような変異がなされたとしても、常に有効に保たれることを保証します。
• 実装例：同一の Entity に対して複数の可変借用参照（

  mut

  ）を同時に安全に持つことが可能です。

コード例：同時可変参照

type Entity = {
    energy: I32
    health: I32
}

// heal 関数：エンティティ A と B を受け取る
heal (healer: mut Entity) (target: mut Entity) = 
    healer.energy -= 10
    target.health += 10

// 同じ Entity を自分自身に適用（他害なしで OK）
self_heal (entity: mut Entity) = 
    heal entity entity

• メモリ安全性：この関数中は

  Entity

  が破壊されるため、両方の参照は有効のままです。

コード例：構造体への可変借用（フィールドも同様）

type Engine = {
    fuel: I32
}

type Spaceship = {
    engine: Engine
    name: String
}

refuel (ship: mut Spaceship) = 
    // 船のエンジンへのエイリアス参照を作成
    engine_alias: mut Engine = ship.engine
    
    // オリジナル `ship` を引き続き使用可能
    ship.engine.fuel := 200
    engine_alias.fuel := 100

• Ante の知恵：関数中は誰も

  ship

  またはそのフィールドを破壊しないため、形状安定性が保たれます。
• 比較：Rust では同一データへの複数の

  &mut

  参照は禁止されていますが、Ante では可能です。

---

3. リファレンスキューント (

shared

) と明示的な構文

共有可変性（Shared Mutability）の能力を、ランタイムエラーなしに実装します。

shared mut type

の使い方

型定義の前に

shared

を付加することで、その型が自動的にリファレンスキューントされます。

shared mut

タイプを持つものはロックなしでフィールドを変異できます。

type Engine = {
    fuel: I32
}

// 自動リファレンスキューントされた共有可変型
shared mut type Spaceship = {
    engine: Engine
    name: String
}

launch (var ship: Spaceship) = 
    set_fuel (mut ship.engine) // ロック不要でフィールドへアクセス可能

set_fuel (engine: mut Engine) = 
    engine.fuel := 100

• 違い：明示的な

  shared

  キーワードを使用しない場合、型はスタック上にインライン化され、単一所有性を保証されます。

明示的な構文（後述する理由のため）

より明確な

Rc Spaceship

のような構文に切り替えると以下のようになります。

type Engine = { fuel: I32 }
type Spaceship = { engine: Engine, name: String }

launch (var ship: Rc Spaceship) = 
    set_fuel (mut ship.engine)
set_fuel (engine: mut Engine) = 
    engine.fuel := 100

• shared mut type Spaceship

  →

  type Spaceship

• var ship: Spaceship

  →

  var ship: Rc Spaceship

---

4. Union（並集型）の扱いと Unsafe プロブレム

Union は速度向上に優れますが、通常はメモリ安全性を保証しにくいものです。Ante でどう扱うか見てみましょう。

問題：Unsafeな悪戯

type Engine = | StringTheoryEngine (str: String) | ImpulseEngine (fuel: I32)

type Spaceship = { engine: Engine, name: String }

// 両方の船を渡す場合、セグメンテーションフォールト（クラッシュ）のリスクがある！
launch (var ship: Rc Spaceship) (var other_ship: Rc Spaceship) = 
    match uniq ship.engine
    | StringTheoryEngine str -> 
        // エラー：他の変異により `ship` が破壊される可能性あり
        other_ship.engine := ImpulseEngine 0x42 
        str.[0] := 'z' // ストリングを直接書き換える（危ない）
    | ImpulseEngine fuel -> ()

Ant の規則：Union と Mutable 引用

Ante は以下のルールを守ります。

1. Union に対する

   mut

   引用を持つ場合：そのバリエーションの一つへの

   mut

   引用を作成することは禁止されます（他の変異で破壊される可能性があるため）。
2. 構造体に対する

   mut

   引用の場合：フィールドの一つへの

   mut

   引用は作成可能です（形状安定性があるため）。

理想的なエラーメッセージ（未実装だが方向性）

Ante は、以下のように拒否すべき理想です。

match uniq ship.engine
| StringTheoryEngine str ->
    // error: `other_ship.engine` を変異させることは、使用中の `ship.engine` がドロップされる可能性を有する
    other_ship.engine := ImpulseEngine 0x42 
    str.[0] := 'z'

---

5.

uniq

（排他的可変参照）とユニークコンバージョン

Union のコンテンツへの安全な可変参照を可能にするために、Ante は

uniq

という機構を導入します。

uniq

とは何か？

• 定義：「排他的可変参照」。
• 意味：変数が

  uniq Spaceship

  を含む場合、そのオブジェクトに対する利用可能な唯一の参照となります。

  set_fuel (engine: uniq Engine) (other: mut Engine) = 
      // engine への他の参照は存在しないことが保証されている
  

Union に

uniq

がどう役立つか

Union フィールドの恣意的な変異を防ぎつつ、安全にコンテンツを操作したい場合です。

launch (var ship: Rc Spaceship) = 
    match uniq ship.engine // match 文には uniq 引用が必要です
    | StringTheoryEngine str -> 
        // safe! StringTheoryEngine への uniq 引用を取得
        str.[0] := 'z' 
    | ImpulseEngine fuel -> ()

• Ante のアプローチ：追加のランタイムオーバーヘッドなし。
• 理由：関数中に誰も

  ship.engine

  を変えないことをコンパイラが理解しているためです。

uniq

コンバージョン（スコープ制御）

Ante の重要な洞察は、スコープ内で他にそのオブジェクトを参照する可能性があるものがない限り、一時的に

uniq

引用を取得できることです。

type Engine = | StringTheoryEngine (str: String) | ImpulseEngine (fuel: I32)

type Spaceship = { engine: Engine, name: String }

launch (var ship: Rc Spaceship) = 
    // Start scope: 他の Spaceship 参照はアクセス不可
    match uniq ship.engine
    | StringTheoryEngine str -> 
        str.[0] := 'z' 
    | ImpulseEngine fuel -> ()
    // End scope

• C の概念に似ていますが：多数のポインタが存在しても、与えられたスコープでは「restrict ポインタ」のみが使用可能です。
• Rust との違い：Rust は「他に参照があるかも」と不安になりますが、Ante は「このスコープ内で使わなければ uniq を作成できる」と宣言します。

制限事項：間接的参照も禁止

• エラー例 1：別の

  Rc Spaceship

  を使うと失敗します（Spaceship に間接的に参照するため）。

  launch (var ship: Rc Spaceship) (var other_ship: Rc Spaceship) = 
      match uniq ship.engine
      | StringTheoryEngine str -> 
          // error: `other_ship.engine` は `ship.engine` とエイリアスを持つ可能性がある
          other_ship.engine := ImpulseEngine 0x42 
          ...
  

• エラー例 2：型が Spaceship を含める構造体（

  HasAShip

  ）も使用不可です。
• 許可例：Spaceship を含まない変数（例：

  I32

  の

  new_fuel

  ）は使用可能です。

関数呼び出しでのユニーク化（Across Function Call）

関数呼び出し自体が

mut

から

uniq

への変換を実行できます。

foo (var ship: Rc Spaceship) (new_res: Resonator) = 
    // Start scope
    maybe_use_resonator ship new_res // ここでは uniq に変換される
    // End scope

maybe_use_resonator (u_ship: uniq Spaceship) (new_res: Resonator) = 
    match u_ship.engine
    | WarpEngine resonators -> resonators.push new_res
    | ImpulseEngine fuel -> ()

• 引数に Spaceship 参照を持つものがなければ、コンパイラは

  uniq

  変換を許可します。

値の返却における制限と拡張

• 制限：関数から直接

  uniq

  引用を返すことは禁止されます（ローカルな一意性を保てないため）。

  // error: local uniq ref を uniq として返すことはできない
  get_converted (foo: mut Foo): uniq Foo = foo 
  

• 解決策：

  local uniq

  を明示して戻せます。

  get_converted (foo: mut Foo): local uniq Foo = foo // OK
  

---

6. 統一的原理への展望と結論

Ant の洞察について

Ant は一時的に

Rc Spaceship

（共有参照）を

uniq Spaceship

（排他的借用参照）に変換でき、ランタイムエラーなしで運用できることを実証しました。

• 課題：型解析の脆さ。「Engine から Spaceship への到達が可能か？」を再帰的に確認するには、API 変更（フィールド追加など）が脆弱性を招く可能性があります。
• 将来の選択肢：
  • Group Borrowing / Flix の手法：共有可変型に匿名だがユニークなブランドを与え、要素型ではなくブランドで一意性を区別する。
  • 効果系（Effect System）：

    Mutates 'a

    などの追加の効果を型解析から外し、コンパイラが同じ変数からの影響を保障する。
  • ランタイムチェック：ユーザーに参照が異なるオブジェクトを指すことを確認するロジックや unsafe API を安全にラップする機能。
  • コンパイル時追跡：エイリアス化されていない値（例：

    Rc

    の中ではなくローカル変数）を追跡し、ローカルユニークスコープ内で自由に使えるようにする。

より広範な図景

メモリ安全性設計の領域は大きく変化しています。

• かつての常識：共有可変借用は不可能（Rust の基本）。
• 現在の潮流：
  • Ante：ローカルユニーク性規則を通じて共有可変であっても唯一の借用参照を取得できる。
  • Vale：純粋関数を通じて不変借用参照を取得可能。
  • Group Borrowing：形状安定でなくても共有可変借用参照が作れる。
  • Rust の GhostCell/QCell：オブジェクトグラフの相互参照が可能。

これは単なるトリックではなく、統一的な原理への接近かもしれません。

結論として、私達は山頂まで登るために新しい技術（ツール）が必要となります。Ante はその一つのステップであり、メモリ安全性の新たな進歩への第一歩です。

---

補足：Rust の Cell との比較

器用な Rust ユーザーは「Cell を入れることとの違い」を問うでしょう。

Ante vs Rust (Cell)

Ante のアプローチ（簡潔）

type Spaceship = {
    fuel: I32
    status: String
}

add_to_name (var ship: Rc Spaceship) = 
    // ステータス文字列への直接的な参照を取得
    status_ref: mut String = ship.status.as_mut() 
    status_ref += " (refueling)"

Rust のアプローチ（Cell 必須）

struct Spaceship {
    fuel: Cell<i32>,
    status: Cell<String>,
}

fn add_to_name(ship: Rc<Spaceship>) {
    // &String を取得できないため、&Cell を介して置換処理が必要
    let mut status = ship.status.get().replace(String::new()); 
    status += " (refueling)";
    ship.status.replace(status); // 元の場所にスワップ必須
}

Rust の Cell に伴うリスク

Rust はデフォルト値の置き換えと復元を強制されます。ここには以下の欠点があります。

• 不要な初期化：空文字列

  ""

  などのデフォルトインスタンス作成を強制する。
• ミスリの発生：最後の置換呼び出し（戻し）を忘れるリスクがある。
• 競合の可能性：スワップ間にある間、他者が値を読もうとすると未定義動作やパニックの可能性がある。

Ante はこれらを異なったアプローチで扱い、コンパイラが強制する「誰もアクセスできない」期間（ユニーク参照）を通じて安全に操作を行います。