HN 日本語サマリー

← 一覧へ戻る
プログラミング

Ante: ボローチェッキングと参照カウンティングを融合する新しい方法

Ante: A new way to blend borrow checking and reference counting (verdagon.dev)

100 pointsby g0xA52A2A23 コメント

要約

Anteは、参照カウンティングとボローチェッキングをランタイムクラッシュなしで融合させる、これまで不可能とされてきた新しいアプローチを提案するプログラミング言語です。RustやSwiftなどの既存言語が抱える参照管理の問題を解決し、柔軟性とパフォーマンスを両立させることを目指しています。特に、シェイプ安定性(Shape-Stability)という概念と、共有ミュータビリティ(shared mutability)のサポートにより、安全かつ効率的なメモリ管理を実現します。

全文翻訳

Ante: ボローチェックと参照カウントを組み合わせる新しい方法

クラッシュなしにボローチェックと参照カウントを融合!

2026年6月28日 —

Anteは、誰もが不可能だと思っていたことへの第一歩を踏み出しました。それは、ランタイムクラッシュなしに参照カウントとボローチェックを融合させることです。0

これは非常に有望です。なぜなら、将来的にはそれぞれの方式が適している場面で、クラッシュのリスクなしにより簡単に使用できるようになることを意味するからです。もしそのような言語があれば、参照カウントで柔軟にゲームをプロトタイプし、徐々に高速なボローチェックされたコードに移行させることができます。1

多くの言語が試みてきましたが、メインストリームの言語でこれらをシームレスに組み合わせる方法を見つけたものはありません。

Rustは試みましたが、Rustの参照カウント型 Rc を使用する際に、しばしば RefCell(例: Rc<RefCell<Spaceship>>)が必要となり、誤った使い方をするとランタイムでクラッシュする可能性があります。2 3 rustc がコンパイル時に Rc の適切な使用法をチェックできれば良いのですが!4 5

Swiftも、その新しいボローシステムで試みましたが、高コストな ランタイムチェックがあり、誤った使い方をするとランタイムでクラッシュします。

参照カウントとボローチェックを融合させるのは、以下で説明する理由から、非常に難しいことがわかりました。

では、Anteについて話しましょう!

Anteは開発中のプロジェクトです!この一部は実装されており、一部はまだ理論段階であり、設計は流動的です。現在も活発に開発が進められていますので、Anteの進捗はサイトやDiscordでフォローしてください!

Ante: ボローチェックと参照カウントを組み合わせる新しい方法

0

具体的には、AnteはランタイムパニックやRustのRefCellやSwiftの排他性チェックに伴うオーバーヘッドなしに、ミュータブルなオブジェクトに対する参照カウントとボローチェックの融合方法を見つけました。

1

これは私がValeに取り組んでいるのと同じ理由に近いです!しかしValeは世代別参照を使用しており、しばしばこれらのプログラム停止の危険性があります。

2

例えば、同時に2人がそれにユニークな(読み書き可能な)参照を取得するとクラッシュします。

3

try_borrow() や try_borrow_mut() メソッドもあり、パニックはしませんが、問題を別の場所に移動させるだけです。

4

そして残念ながら、GhostCell / QCellはカウントされません。それらは他の制限をもたらし、RefCellのドロップイン代替にはなりません。

5

Cellはありますが、その内部への参照を取得することはできません。例えば、&Cell<(T, U)> から &Cell<U> を取得することはできません。Rustは一般的に内部ミュータビリティを使用する際に多くの摩擦があり、多くのユーザーがそれを避けるようになります。

Ante

Anteは、よりシンプルなRust、メモリ安全性とスレッド安全性を備えたシステムプログラミング言語を目指しています。単一所有権とボローチェックを備えているため、値はインライン(スタック上、または含まれる構造体/配列内)に配置されます。

そして、ユーザーがシンプルさを優先したい場合は、型に shared キーワードをオプトインすることで参照カウントを利用できます。

例えば、このスニペットは赤黒木をバランスさせます:

// ColorはRまたはBのいずれかです
shared type Color = | R | B

// RbTreeはEmptyまたはTreeのいずれかです
shared type RbTree t =
    | Empty
    | Tree Color (RbTree t) t (RbTree t)

// あらゆる要素型tのRbTreeのためのバランス関数
balance (tree: RbTree t) {Copy t}: RbTree t =
    match tree
    | Tree B (Tree R (Tree R a x b) y c) z d
    | Tree B (Tree R a x (Tree R b y c)) z d
    | Tree B a x (Tree R (Tree R b y c) z d)
    | Tree B a x (Tree R b y (Tree R c z d)) -> Tree R (Tree B a x b) y (Tree B c z d)
    | other -> other

私は通常Cスタイルの構文を好みますが、それでもこれは美しいと認めざるを得ません。そして、それは簡潔でもあります。Pythonの同等物と同じくらい小さく、C++の同等物やRustの同等物よりも小さいです。

しかし、私にとって最も興味深いのは、Anteがメモリ安全性において何をしているかということです。Anteは共有ミュータブルなスーパーパワーを持っています:参照カウントされたデータをミュータブルにボローしたい場合、ランタイムエラーのリスクを冒す必要はありません。RustやSwiftでさえ、このようなことはできません。

共有ミュータビリティのスーパーパワーについて話す前に、基本から始めましょう。ボローチェックをどのように行うかを見て、それから参照カウントを混ぜ合わせます。

シェイプ・ステイビリティ

Anteにはシェイプ・ステイビリティという概念があります。これは「形状が安定したものの参照は、他の場所でどのような変更が行われても常に有効である」という意味です6。

これにより、Anteコードは同じ構造体に対して同時に複数のミュータブルなボロー参照を持つことができます。

前提として、Entityの2つのミュータブル参照を取る heal 関数を以下に示します:

type Entity =
    energy: I32
    health: I32

heal (healer: mut Entity) (target: mut Entity) =
    healer.energy -= 10
    target.health += 10

Anteでは、heal を両方のパラメータに同じEntityで呼び出すことができます。例えば、エンティティが自分自身を癒す場合です:

self_heal (entity: mut Entity) =
    heal entity entity

healer の変更は、Entityへの共有参照を無効にすることはできません7。そのため、コンパイラはこのコードを有効なものとして受け入れます。

言い換えれば、healer と target が同じEntityを指している可能性がある場合でも、これはメモリ安全です。このコードではEntityを破壊することはできないため、両方の参照は有効なままです。

次に、もう少し複雑にしてみましょう。

Anteコードは、構造体自体、またはその構造体のフィールド、あるいはそれらのフィールドのフィールドに対して、同時に複数のミュータブルなボロー参照を持つことができます。

例えば、ここでは船へのミュータブルなボロー参照と、船のエンジンへのミュータブルなボロー参照を同時に持っています。

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はこれが完全にメモリ安全であることを知っています。なぜなら、この関数の間、誰も船を破壊できないため、そのエンジンや燃料を破壊することもできないからです。

言い換えれば、これらの参照はシェイプ・ステイブルなデータに向けられています。

RustやSwiftに詳しい人は、これに驚くでしょう:

  • Rustでは、同じデータに対して複数の &mut 参照を指すことはできません。8
  • Swiftでも、同じデータに対して複数の &mut 参照を指すことはできません。

では、参照カウントを混ぜ合わせてみましょう!

6

ここでは、「有効」とはデリファレンス可能であることを意味します。メモリの安全性や未定義の動作を危険にさらすことなく、参照をデリファレンスできます。

7

Rustで &mut Spaceship を使用して、それが指す Spaceship を破壊できないのと同様です。Rustでさえ、同じ Spaceship ローカル変数に複数の &mut Spaceship 参照を指すことは完全に安全です。

8

Cellを使って近いことができる場合もありますが、AnteがRustのCellよりも進んでいる理由については付録セクションを参照してください。

参照カウント

上記の能力は、以下で見るように、参照カウントと完璧に適合します。

Anteでは、型定義の前に shared を付けると、その型は自動的に参照カウントされることを意味します。9

そして、shared mut 型を持っている場合、set_fuel が Spaceship の Engine フィールドに対して行っているように、ロックなしでフィールドを変更できます:

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

このスニペットを以下でさらに説明しますが、今のところ:これはRustの同等物やSwiftの同等物に似ていますが、Rustの .borrow_mut() やSwiftの自動ランタイム排他性チェックのクラッシュリスクはありません。

launch はミュータブルな Engine ボロー参照を作成できます。なぜなら、launch は Spaceship を保持し続けるため、エンジンが生き続けることを知っているからです。

より一般的には:共有ミュータブル型のフィールドに対しては、常にミュータブルなボロー参照を作成できます。たとえそれらが共有されていてもです。10

9

少なくとも今のところは。最終的には、アプリケーション(コードではなく)がメモリ管理の方法を設定できるようになります。例えば、RC、GC、またはカスタムメカニズムを介してです。

10

ただし、それらのフィールド内のものに対して常にミュータブルなボロー参照を取得できるわけではありません。後で詳しく説明します。それには異なるメカニズムがあります。

より明示的な構文

ここからは、後述の理由から、shared mut type のシンタックスシュガーではなく、より明示的な Rc Spaceship 構文を使用します。

より明示的な Rc 構文を使用すると、上記のコードスニペットは次のようになります:11

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 になりました

11

ここでは、Rc の内容にフィールドアクセスできるAnteの構文を想定しています。それがなければ、これは set_fuel (ship.as_mut ()).engine のようになるかもしれません。

ユニオン

ユニオンは速度に非常に優れています。12 私たちはユニオンが好きです。

残念ながら、ユニオンは悪名高いほど安全ではなく、メモリ安全な言語がそれらをうまくサポートするのは困難です。

その理由を見るために、以下の例を見てみましょう。ここでは Engine がユニオンであり、それを使って危険な操作をしようとしています。

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 ->
        other_ship.engine := ImpulseEngine 0x42
        str.[0] := 'z'
    | ImpulseEngine fuel ->
        ()

このプログラムは、ship と other_ship の両方に同じ Spaceship を渡すと、セグメンテーション違反を起こす可能性があります!

このため、Anteは上記のプログラムのコンパイルを拒否する必要があります。Anteにはこのルールがあります:

ユニオンに対するミュータブルなボロー参照を持っている場合、そのバリアントのミュータブルなボロー参照を作成することはできません。

これは、前の構造体ルールとは反対です:

構造体に対するミュータブルなボロー参照を持っている場合、そのフィールドのミュータブルなボロー参照を作成できます。

理想的な世界では、Anteは次のようなエラーで上記のプログラムを拒否するでしょう:

    match uniq ship.engine
    | StringTheoryEngine str ->
        // error: Mutating `other_ship.engine` may cause `ship.engine` to be dropped while still in use
        // note: `other_ship.engine` is an `Engine` which may alias with `ship.engine`
        other_ship.engine := ImpulseEngine 0x42
        str.[0] := 'z'
    | ImpulseEngine fuel ->
        ()

しかし、Anteはどうやってそれを知るのでしょうか?それは可能なのでしょうか?

可能です!Anteがこのエラーを出すのは、ship.engine が一時的なユニーク変換を経由したからです。

では、それはどういう意味で、uniq とは何でしょうか?

12

ユニオンは、その内容をインラインで保持するため、キャッシュミス(または「ポインタチェイシング」)が少なくなるため、速度が非常に速いです。例えば、C言語で次のようなユニオンがある場合:

union Engine {
  StringTheoryEngine ste;
  ImpuseEngine ie;
};

そしてそれが Spaceship の中にある場合:

struct Spaceship {
  Engine engine;
};

StringTheoryEngine と ImpulseEngine は Spaceship のメモリ内に存在します。

Javaのような他の言語では、これは行われず、代わりに Engine をインターフェースにし、Spaceship が Engine ポインタを含むようにします。

ポインタは遅いです。ユニオンは速いです。AnteはここではC言語に似ています。

ユニーク参照

uniq は「排他的なミュータブル参照」を意味します。

変数が uniq Spaceship を含む場合、それはその Spaceship への唯一使用可能な参照です。13

set_fuel (engine: uniq Engine) (other: mut Engine) =
    // ここでは、他に `engine` を指すものがないことを知っています

これは一般的に単独ではあまり役に立ちませんが、ユニオンの内容を指すことは可能になります。

13

Anteの uniq Spaceship は、Rustの &mut Spaceship に似ています。

ユニークがユニオンを助ける方法

同じデータへの他のエイリアスが存在する可能性があるため、ユニオンフィールドの任意変更を許可するのは安全ではありません。

例えば、あるユーザーが Maybe String から String を保持している間に、別のユーザーがそれを None に変更する可能性があります。

あるいは、上記の例で見たように、誰かが文字列の文字への参照を保持している間に、そのコンテナを破壊しました。

言語は通常、参照カウント(Swift)または共有ミュータビリティの完全な禁止(Rust)のいずれかによって、この問題を修正します。

しかし、上記の安全でないプログラムを防ぎたい一方で、ユニオンの内容へのミュータブルな参照を安全に持つプログラムを許可したいのです:

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

type Spaceship =
    engine: Engine
    name: String

launch (var ship: Rc Spaceship) =
    match uniq ship.engine // match文はuniq参照を必要とします
    | StringTheoryEngine str -> // StringTheoryEngineへのuniq参照を取得
        str.[0] := 'z'
    | ImpulseEngine fuel ->
        ()

例えばSwiftやRustの同等プログラムは、残念ながら追加のランタイムオーバーヘッド/チェックを追加することで、この安全なプログラムを許可しています。

幸いなことに、Anteは追加のランタイムオーバーヘッド/チェックを必要としません。なぜなら、この関数内にいる間、誰も ship.engine を変更していないことを理解しているからです。

Anteは、その一時的なユニーク変換メカニズムのおかげで、これを理解しています。

ユニーク変換

Anteの洞察は、一時的にユニークな参照を取得できるということです。ただし、そのスコープ内では、それへの参照を持つ可能性のある他のものを一切アクセスしないという条件付きです。

例えば、ユニーク変換を伴うプログラムを以下に示します。コメントはスコープの開始と終了を示しています:

match uniq ?

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

type Spaceship =
    engine: Engine
    name: String

launch (var ship: Rc Spaceship) =
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを開始
    match uniq ship.engine
    | StringTheoryEngine str ->
        str.[0] := 'z'
    | ImpulseEngine fuel ->
        ()
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを終了

ユニーク参照は、// Start scope と // End scope のコメントの間(より具体的には、ship の宣言から最後の使用まで)のスコープ内に存在します。

ユニーク参照が存在する間、Anteは、間接的に Spaceship を含む可能性のある既存の他の変数の使用を防ぎます。

Rustは「他の参照がどこかに存在する可能性があるため」ユニークの存在を妨げますが、Anteは、それらの参照をこのスコープで使用しない限り、ユニークを作成できると述べています。

これは重要なニュアンスです。ユニークな Spaceship は、その Spaceship への唯一の参照ではありません。それは単に唯一使用可能な参照です。これはC言語に似ており、オブジェクトへのポインタは複数存在できますが、特定のスコープでは restrict ポインタのみが使用できます。Anteはこのニュアンスを利用しています。

ただし、いくつかの制限があります。

そのスコープ内で(例えば、Spaceship を間接的に含む可能性のある別の Rc Spaceship)他のローカル変数を使用した場合、コンパイルエラーが発生します:

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

type Spaceship =
    engine: Engine
    name: String

launch (var ship: Rc Spaceship) (var other_ship: Rc Spaceship) =
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを開始
    match uniq ship.engine
    | StringTheoryEngine str ->
        // error: Mutating `other_ship.engine` may cause `ship.engine` to be dropped while still in use
        // note: `other_ship.engine` is an `Engine` which may alias with `ship.engine`
        other_ship.engine := ImpulseEngine 0x42
        str.[0] := 'z'
    | ImpulseEngine fuel ->
        ()
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを終了

これは、ship が一時的にユニークな Spaceship に変換されている間に other_ship にアクセスしているため、エラーとなります。

間接的に Spaceship を含む可能性のあるものも使用できません14。そのため、これも拒否されます:

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

type Spaceship =
    engine: Engine
    name: String

type HasAShip =
    ship: Rc Spaceship

launch (var ship: Rc Spaceship) (var other: HasAShip) =
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを開始
    match uniq ship.engine
    | StringTheoryEngine str ->
        // error: Mutating `other.ship.engine` may cause `ship.engine` to be dropped while still in use
        // note: `other.ship.engine` is an `Engine` which may alias with `ship.engine`
        other.ship.engine := ImpulseEngine 0x42
        str.[0] := 'z'
    | ImpulseEngine fuel ->
        ()
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを終了

整数 new_fuel のような他のものは使用できることに注意してください:

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

type Spaceship =
    engine: Engine
    name: String

launch (var ship: Rc Spaceship) (new_fuel: I32) =
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを開始
    match uniq ship.engine
    | StringTheoryEngine str ->
        str.[0] := 'z'
    | ImpulseEngine fuel ->
        fuel := new_fuel
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを終了

new_fuel は単なる I32 であり、Spaceship への参照を含むことができないため、使用できます。単なる整数です。

14

また、Spaceship が follow_ship: Rc Spaceship のようなフィールドを含んでいた場合も拒否されます。なぜなら、そのユニークな Spaceship はそのフィールドからも到達可能になるからです。したがって、一般的に、再帰型に対して mut から uniq への変換を行うことはできません。

関数呼び出しを跨いで

以下は、関数呼び出しの一部として mut から uniq への変換を行う例です。

type Resonator =
    resonance: I32

type Engine =
    | ImpulseEngine (fuel: I32)
    | WarpEngine (resonators: Vec Resonator)

type Spaceship =
    engine: Engine
    name: String

foo (var ship: Rc Spaceship) (new_res: Resonator) =
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを開始
    maybe_use_resonator ship new_res // ここで `uniq` に変換されます
    // Spaceshipを含む可能性のある他の変数を誰もアクセスできないスコープを終了

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

覚えておいてください、ルールは、一時的にユニークな参照を取得できるということです。ただし、そのスコープ内では、それへの参照を持つ可能性のある他のものを一切アクセスしないという条件付きです。

コメントからわかるように、コンパイラは maybe_use_resonator の呼び出しサイトをチェックするだけでよく、引数に Spaceship への参照を含む可能性のあるものが含まれていないことを確認します。そして、唯一の他の引数(Resonator)はそうではないため、問題ありません!

値の返却

mut から uniq への変換における主な制限は、変換されたユニーク参照を関数から返すことができないことです:15

get_converted (foo: mut Foo): uniq Foo =
    // mut -> uniq への変換を試みる
    foo  // error: `local uniq` refs cannot be returned as `uniq`

幸いなことに、返される参照がローカルユニークであると指定することで、目的を達成できます:

get_converted (foo: mut Foo): local uniq Foo =
    // mut -> local uniq への変換
    foo

実際、mut 参照から uniq 参照に変換する際には、常に内部的にこれが起こっています。ほとんどの場合、通常の uniq 参照として使用できますが、値を返す際には明示的に指定する必要があります。

15

これが許可された場合、返されたユニーク参照は、変換された参照とエイリアスする可能性のあるスコープ内の変数が使用されないことを保証するコンパイラチェックなしに使用される可能性があります。

Anteはここに何かを見出していると思う

Anteは、ランタイムエラーなしに Rc 参照(Rc Spaceship)をユニークなボロー参照(uniq Spaceship)に一時的に変換できるというのは、非常に大きな前進です。16

しかし、欠点もあります。Jake(Anteの作成者)が私に強調したように、これには型分析が必要です。「Engine から Spaceship に到達できるか?」という質問に答えるには、コンパイラは Engine とそれが含むすべてを再帰的に調べる必要があり、何も Spaceship を含まないことを確認する必要があります。これは非常に壊れやすい可能性があります。構造体にフィールドを追加することは、APIの破壊的な変更になり得ます。

そのため、Jakeはその保証を維持するためのより良い方法を探しており、有望な選択肢があります:

  • グループボローイングとFlixの参照からヒントを得て17、Rc のような各共有ミュータブル型には、匿名だがユニークな型でブランド付けできます。コンパイラはそのブランドを使用して、要素型ではなく、複数の値をユニークさのために区別できます。これにより、文字列のような一般的な型は、他の値内に現れる可能性が高く、現在の型ベースのチェックからブロックされるため、変換が容易になります。
  • そこから、Mutates 'a のような効果を共有型を変更する際に追加すれば、型分析を完全に削除できます。コンパイラは、各 Mutates 'a 効果が同じ変数から来ていることを確認するだけで済みます。
  • ランタイムオプションもあります。例えば、言語はユーザーが2つの参照が異なるオブジェクトを指しているかどうかを確認できるようにしたり、チェックを表現するためのロジックを提供したり、安全なAPIにラップするためのアンセーフチェックを提供したりできます。
  • コンパイラは、例えば Rc の内部に間接的に格納されていないため、エイリアスされていない値のセットを追跡できます。コンパイラがこれを行った場合、これらの値のいずれもローカルユニーク変数のスコープ内で、それが含む型に関係なく使用できます。

他にも選択肢があると思います:

  • Ponyのisoパーミッションに似ており、iso Spaceship が外部への参照を持たないことを保証します(ただし、isoの制限により、1人しか指せないという制約はありません)。
  • 「この構造体の内部を見ることができるが、外部への参照は使用できない」という一時的なパーミッションがあれば、ここで役立つかもしれません。

これらの可能性のある角度があっても、難しいのはそれを使いやすくすることです。JakeのAnteの目標は、使用可能で、読みやすく、シンプルなものを作ることです。最大の柔軟性を提供しながらそれを行うことは、常に難しいです。

16

これは、ある意味では、コンパイル時のRefCellであり、C++ユーザーが古くから内面化してきたものです。Jakeはそれをメモリ安全アプローチに組み込む方法を見つけました。

17

私と他の数人は最近この角度を探求しています。

より広い視野

よく見ると、メモリ安全設計の領域で非常に興味深いことが起こっているのがわかります。

かつて、私たちは「共有ミュータブルボローイング」が可能だと思っていました。これは、他の人が自分の参照を通してそれを変更できる場合でも、それにボローされた参照を持つことができるということです。実際、Rustはその信念に基づいて構築されています。

しかし、例外がたくさん積み上がり始めています:

  • Anteでは、ローカルユニークネスルールを通じて、共有ミュータブルであったデータに対してユニークなボロー参照を取得できます。
  • Valeでは、純粋関数を通じて、共有ミュータブルであったデータに対して不変なボロー参照を取得できます。
  • グループボローイングでは、コンパイラは、シェイプ・ステイブルでなくても、あらゆるものに対して共有ミュータブルなボロー参照を作成できます。
  • RustのGhostCellを使用すると、オブジェクトのグラフは自由に互いを指すことができます(ただし、いずれか1つに対するミュータブルな参照は1つしか持てません)。

これは単なるトリックの寄せ集めではありません。これは宇宙が私たちに、統一原則がすぐそこにあると強く語りかけているのです。

その統一原則は、今は謎めいて説明を省略しておきます。もしそれが何かわかるなら、コメントを残してください!

結論

少し禅になりましょう。私たちは水のようなものです。山と谷に満ちた複雑な風景の中を流れています。最小抵抗の道に従って谷に流れ込み、あまり見通せないのは簡単です。山を登って遠くを見るのは難しいです。

だからこそ、このような記事があるのです!新しいテクニックは、私たちが山を登り、より遠くを見るのを助けるためのツールです。私たちがする必要があるのは、ツールを追加し続けることだけです。そうすれば、必然的にメモリ安全性の次の大きな進歩を見つけるでしょう。

このような記事を楽しんでいるなら、RSSフィード、r/vale、Twitter、Blueskyを購読して、最新情報を入手してください。Anteの開発をフォローするには、ウェブサイトとDiscordをチェックしてください。

では!

— Evan

付録: RustのCellとの比較

賢いRustユーザーは、「これは構造体にCellを入れるのとどう違うのか?」と尋ねるでしょう。

質問を例示するために、Anteのプログラムと、その下のCellを使用した同等のRustプログラムを以下に示します:

type Spaceship =
    fuel: I32
    status: String

// 例: "Enterprise" を "Enterprise (refueling)" に変更します
add_to_name (var ship: Rc Spaceship) =
    status_ref: mut String = (ship.as_mut ()).status // status String自体への参照を取得
    status_ref += " (refueling)"

そしてRustバージョン:

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

// 例: "Enterprise" を "Enterprise (refueling)" に変更します
fn add_to_name(ship: Rc<Spaceship>) {
    let status_ref = &ship.status; // &String は取得できないが、&Cell<String> は取得できる
    let mut status = status_ref.replace(String::new()); // 一時的に何かを置き換える
    status += " (refueling)";
    status_ref.replace(status); // 変更された名前を元に戻す
}

Rustにはここに制限があります:Rc<Spaceship> が与えられた場合、追加できる &mut String を取得する方法はありません。そのため、代わりにデフォルト値(String の場合は "")を挿入し、後で戻すことを忘れないようにする必要があります。

これにはいくつかの欠点があります:

  • "" のような「デフォルト」インスタンスを作成する必要があります。C#やGolangを使ったことがある人なら、これを要求されるのがどれほど悪いかを知っているでしょう。
  • リスクがあります:最後の replace 呼び出しを忘れて、元に戻せなかったらどうなるでしょうか?
  • 別のリスク:値が置き換えられている間にステータスを読み取ったらどうなるでしょうか?

最後の点は聞き覚えがあるでしょう:この Cell は基本的に RefCell です!

Anteはこれを異なるアプローチで扱います。ステータス文字列への参照を一時的に取得できるようにし、コンパイラがその間誰もそれにアクセスできないことを強制します。