Comprehensive Rust へようこそ 🦀

これは、Google の Android チームが開発した無料の Rust コースです。このコース では、基本的な構文から、ジェネリクスやエラーハンドリングのような高度なトピック まで、Rust の全範囲を扱います。

コースの最新バージョンは https://google.github.io/comprehensive-rust/ で確認できます。これを別の場所で 読んでいる場合は、更新についてそちらを確認してください。

このコースは他の言語でも利用できます。ページ右上で希望の言語を選択するか、 利用可能なすべての翻訳の一覧については 翻訳 ページを確認してください。

このコースは PDF 版 でも利用できます。

このコースの目的は、Rust を学んでもらうことです。受講者は Rust について何も知ら ないことを前提とし、次を目指します:

• Rust の構文と言語について包括的に理解してもらう。
• 既存のプログラムを修正し、Rust で新しいプログラムを書けるようになってもらう。
• Rust の一般的なイディオムを紹介する。

最初の 4 日間のコースを Rust Fundamentals と呼びます。

この基礎の上に、1 つ以上の専門トピックをさらに深く学ぶこともできます:

• Android: Android プラットフォーム開発 (AOSP) で Rust を使う半日 コースです。これには、C、C++、Java との相互運用が含まれます。
• Chromium: Chromium ベースのブラウザーで Rust を使う半日コース です。これには、C++ との相互運用や、Chromium にサードパーティ製 crate を含める 方法が含まれます。
• ベアメタル: ベアメタル (組み込み) 開発で Rust を使う終日 クラスです。マイクロコントローラーとアプリケーションプロセッサーの両方を扱い ます。
• 並行性: Rust の並行性に関する終日クラスです。古典的な 並行性（スレッドとミューテックスを使用したプリエンプティブなスケジューリング） と、async/await による並行性（future を使用した協調的マルチタスク）の両方を 扱います。

対象外

Rust は大きな言語であり、数日ですべてを扱うことはできません。 このコースの対象外の一部は次のとおりです:

• マクロの開発方法を学ぶこと: 代わりに the Rust Book と Rust by Example を参照してください。

前提

このコースでは、受講者がすでにプログラミングの方法を知っていることを前提として います。Rust は静的型付け言語であり、Rust のアプローチをよりよく説明したり対比 したりするために、C や C++ と比較することがあります。

Python や JavaScript のような動的型付け言語でのプログラミング方法を知っていれ ば、問題なくついていくことができるでしょう。

コースの運営

このページはコースの講師向けです。

ここでは、Google 社内でこのコースをどのように運営してきたかについて、 背景情報を少し紹介します。

通常、講義は午前 9:00 から午後 4:00 まで実施し、その間に 1 時間の昼休みを 挟みます。これにより、午前の講義に 3 時間、午後の講義に 3 時間を充てることが できます。どちらのセッションにも複数回の休憩と、受講者が演習に取り組む時間が 含まれます。

コースを実施する前に、次のことを行っておくとよいでしょう。

1. コース教材に慣れておいてください。重要なポイントを強調できるよう、 スピーカーノートを用意しています（ぜひスピーカーノートの追加にも ご協力ください！）。発表時には、スピーカーノートをポップアップで 開いておくようにしてください（“Speaker Notes” の横にある小さな矢印の リンクをクリックします）。そうすれば、クラスに見せる画面をすっきり 保てます。

2. 日程を決めてください。このコースは 4 日間かかるため、2 週間に分けて 日程を組むことをお勧めします。受講者からは、コースの間に間隔があると、 こちらが提供する情報を整理しやすくなって役立つ、という声が寄せられて います。

3. 対面参加者を収容できる十分な広さの部屋を確保してください。受講者数は 15〜25 人を推奨します。これは、参加者が気軽に質問できる十分に小さな 規模であり、同時に 1 人の講師でも質問に答える時間を確保できる規模でも あります。部屋には、自分用と受講者用の 机 があることを確認して ください: 全員が座ってノート PC で作業できる必要があります。特に、 講師としてかなりの量のライブコーディングを行うため、演台はあまり 役に立ちません。

4. コース当日は、準備のために少し早めに部屋に入ってください。 プレゼンテーションには、ノート PC 上で動かしている mdbook serve を 直接使うことをお勧めします（インストール手順を参照して ください）。そうすることで、ページを切り替える際の遅延がなく、最適な パフォーマンスを確保できます。また、自分のノート PC を使えば、あなたや 受講者が誤字を見つけたその場で修正できます。

5. 演習は、各自または少人数のグループで解いてもらってください。通常、 午前と午後にそれぞれ 30〜45 分を演習に充てます（解答の振り返りの時間を 含みます）。行き詰まっていないか、何か手伝えることはないか、必ず声を かけてください。複数の人が同じ問題に直面しているのを見かけたら、その ことをクラス全体に共有し、解決策を示してください。たとえば、標準 ライブラリのどこに関連情報があるかを示すとよいでしょう。

以上です。コース運営の成功を祈っています！ 私たちにとってそうであった ように、あなたにとっても楽しいものになることを願っています！

今後もコースを改善し続けられるよう、終了後にぜひ フィードバックをお寄せください。うまくいった点や、さらに改善できる 点をぜひお聞かせください。受講者の皆さんからの フィードバックも大歓迎です！

コース構成

このページはコース講師向けです。

Rust の基礎

最初の 4 日間が Rust Fundamentals に相当します。各日はテンポよく進み、幅広いトピックを扱います！

not found - {{%course outline Fundamentals}}

深掘り

4 日間の Rust Fundamentals に加えて、さらに専門的なトピックも扱います。

Rust in Android

Rust in Android の深掘りコースは、Android プラットフォーム開発で Rust を使う方法を扱う半日コースです。これには、C、C++、Java との相互運用も含まれます。

AOSP チェックアウト が必要です。同じマシン上で コースリポジトリ もチェックアウトし、src/android/ ディレクトリを AOSP チェックアウトのルートに移動してください。これにより、Android ビルドシステムが src/android/ 内の Android.bp ファイルを認識できるようになります。

エミュレータまたは実機で adb sync が動作することを確認し、src/android/build_all.sh を使ってすべての Android サンプルを事前にビルドしてください。スクリプトを読んでどのコマンドが実行されるかを確認し、それらを手動で実行しても動作することを確かめてください。

Rust in Chromium

Rust in Chromium の深掘りコースは、Chromium ブラウザの一部として Rust を使う方法を扱う半日コースです。これには、Chromium の gn ビルドシステムで Rust を使うこと、サードパーティライブラリ（「クレート」）の取り込み、C++ との相互運用が含まれます。

Chromium をビルドできる必要があります — 速度の面では、デバッグ用の component build が 推奨 されますが、どのビルドでも動作します。ビルドした Chromium ブラウザを実行できることを確認してください。

Bare-Metal Rust

Bare-Metal Rust の深掘りコースは、ベアメタル（組み込み）開発で Rust を使う方法を扱う 1 日コースです。マイクロコントローラとアプリケーションプロセッサの両方を扱います。

マイクロコントローラのパートでは、事前に BBC micro:bit v2 開発ボードを購入しておく必要があります。全員が ウェルカムページ に記載されているとおりに、いくつかのパッケージをインストールする必要があります。

Rustでの並行性

Concurrency in Rust の深掘りコースは、古典的な並行性と async/await による並行性を扱う 1 日コースです。

新しいクレートをセットアップし、依存関係をダウンロードしてすぐに使えるようにしておく必要があります。その後、サンプルを src/main.rs にコピー＆ペーストして試すことができます。

cargo init concurrency
cd concurrency
cargo add tokio --features full
cargo run

not found - {{%course outline Concurrency}}

Idiomatic Rust

Idiomatic Rust の深掘りコースは、Rust のイディオムとパターンを扱う 2 日間のコースです。

このコースを始める前に、Rust Fundamentals の内容を一通り理解しておくべきです。

not found - {{%course outline Idiomatic Rust}}

Unsafe（作業中）

Unsafe の深掘りコースは、Rust 言語の unsafe を扱う 2 日間のコースです。Rust の安全性保証の基礎、unsafe の必要性、unsafe コードのレビュー手順、FFI の基礎、そして通常なら借用チェッカーに拒否されるデータ構造の構築を扱います。

not found - {{%course outline Unsafe}}

進め方

このコースは非常にインタラクティブに進めることを意図しており、質問をきっかけに Rust の探求を進めていくことをお勧めします！

キーボードショートカット

mdBook には、いくつか便利なキーボードショートカットがあります。

• Arrow-Left: 前のページに移動します。
• Arrow-Right: 次のページに移動します。
• Ctrl + Enter: フォーカスのあるコードサンプルを実行します。
• s: 検索バーをアクティブにします。

翻訳

このコースは、素晴らしいボランティアの方々によってさまざまな言語に 翻訳されています:

• ポルトガル語（ブラジル） は @rastringer, @hugojacob, @joaovicmendes, @henrif75 による翻訳です。
• 中国語（簡体字） は @suetfei, @wnghl, @anlunx, @kongy, @noahdragon, @superwhd, @SketchK, @nodmp による翻訳です。
• 中国語（繁体字） は @hueich, @victorhsieh, @mingyc, @kuanhungchen, @johnathan79717 による翻訳です。
• ペルシア語 は @DannyRavi, @javad-jafari, @Alix1383, @moaminsharifi, @hamidrezakp, @mehrad77 による翻訳です。
• 日本語 は @CoinEZ-JPN, @momotaro1105, @HidenoriKobayashi, @kantasv による翻訳です。
• 韓国語 は @keispace, @jiyongp, @jooyunghan, @namhyung による 翻訳です。
• スペイン語 は @deavid による翻訳です。
• ウクライナ語 は @git-user-cpp, @yaremam, @reta による翻訳です。

右上の言語選択メニューを使って、言語を切り替えてください。

未完成の翻訳

現在進行中の翻訳も数多くあります。ここでは、最近更新された翻訳への リンクを掲載しています:

• アラビア語 は @younies による翻訳です。
• ベンガル語 は @raselmandol による翻訳です。
• フランス語 は @KookaS, @vcaen, @AdrienBaudemont による 翻訳です。
• ドイツ語 は @Throvn, @ronaldfw による翻訳です。
• イタリア語 は @henrythebuilder, @detro による翻訳です。

翻訳の完全な一覧と現在の状況は、最終更新時点の一覧 または コースの最新版に同期された一覧 でも参照できます。

この取り組みに協力したい場合は、始め方について 手順 を参照して ください。翻訳に関する調整は イシュートラッカー で行われています。

Cargo を使う

Rust について読み始めると、すぐに Cargo に出会うでしょう。これは、Rust エコシステムで Rust アプリケーションをビルドして実行するために使われる標準ツールです。ここでは、Cargo とは何か、より広いエコシステムの中でどのような位置付けにあるのか、そしてこのトレーニングの中でどのように位置付けられるのかを簡単に概説します。

インストール

https://rustup.rs/ の手順に従ってください。

これにより、Cargo ビルドツール (cargo) と Rust コンパイラ (rustc) がインストールされます。また、異なるコンパイラバージョンをインストールするために使えるコマンドラインユーティリティ rustup も利用できるようになります。

Rust をインストールしたら、エディタや IDE が Rust で動作するように設定するべきです。ほとんどのエディタは rust-analyzer と連携することでこれを実現します。rust-analyzer は、VS Code、Emacs、Vim/Neovim など多くの環境向けに、自動補完や定義へのジャンプ機能を提供します。RustRover という別の IDE も利用できます。

Rust エコシステム

Rust エコシステムは多数のツールで構成されており、主なものは次のとおりです:

• rustc: .rs ファイルをバイナリやその他の中間形式に変換する Rust コンパイラ。

• cargo: Rust の依存関係マネージャー兼ビルドツール。Cargo は、 通常 https://crates.io でホストされている依存関係をダウンロードでき、 プロジェクトをビルドするときにそれらを rustc に渡します。Cargo には 組み込みのテストランナーも含まれており、ユニットテストの実行に使われます。

• rustup: Rust ツールチェーンのインストーラー兼アップデーター。このツールは、 新しい Rust のバージョンがリリースされたときに rustc と cargo を インストールおよび更新するために使用されます。さらに、rustup は標準 ライブラリのドキュメントもダウンロードできます。複数の Rust バージョンを 同時にインストールしておくことができ、rustup を使って必要に応じて それらを切り替えられます。

このトレーニングのコードサンプル

このトレーニングでは、主にブラウザから実行できる例を通して Rust 言語を 学びます。これによりセットアップがはるかに簡単になり、全員に一貫した体験を 提供できます。

Cargo をインストールしておくことも引き続き推奨されます。そうすることで 演習が進めやすくなります。最終日には、依存関係の扱い方を学ぶための、 より大きな演習を行います。そのためには Cargo が必要です。

このコースのコードブロックは完全にインタラクティブです:

// 著作権 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    println!("Edit me!");
}

テキストボックスにフォーカスがあるときは、Ctrl + Enter で コードを実行できます。

Cargo を使ってローカルでコードを実行する

自分のシステムでコードを試してみたい場合は、まず Rust をインストールする必要があります。これを行うには、Rust Book の手順に従ってください。これにより、動作する rustc と cargo が手に入るはずです。本稿執筆時点では、最新の安定版 Rust リリースのバージョン番号は次のとおりです。

% rustc --version
rustc 1.69.0 (84c898d65 2023-04-16)
% cargo --version
cargo 1.69.0 (6e9a83356 2023-04-12)

Rust は後方互換性を維持しているため、これより新しいバージョンでも使用できます。

ここまで準備できたら、このトレーニングにある例の 1 つから Rust バイナリをビルドするために、次の手順に従ってください。

1. コピーしたい例の「Copy to clipboard」ボタンをクリックします。

2. cargo new exercise を使って、コード用の新しい exercise/ ディレクトリを作成します。

   $ cargo new exercise
        Created binary (application) `exercise` package
   

3. exercise/ に移動し、cargo run を使ってバイナリをビルドして実行します。

   $ cd exercise
   $ cargo run
      Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)
       Finished dev [unoptimized + debuginfo] target(s) in 0.75s
        Running `target/debug/exercise`
   Hello, world!
   

4. src/main.rs にあるひな形コードを自分のコードに置き換えます。たとえば、前のページの例を使う場合は、src/main.rs を次のようにします。

   // Copyright 2022 Google LLC
   // SPDX-License-Identifier: Apache-2.0
   
   fn main() {
       println!("Edit me!");
   }

5. cargo run を使って、更新したバイナリをビルドして実行します。

   $ cargo run
      Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)
       Finished dev [unoptimized + debuginfo] target(s) in 0.24s
        Running `target/debug/exercise`
   Edit me!
   

6. cargo check を使うと、プロジェクトのエラーをすばやく確認できます。cargo build を使うと、実行せずにコンパイルできます。通常のデバッグビルドでは、出力は target/debug/ にあります。最適化されたリリースビルドを生成するには、cargo build --release を使ってください。生成先は target/release/ です。

7. Cargo.toml を編集することで、プロジェクトに依存関係を追加できます。cargo コマンドを実行すると、不足している依存関係は自動的にダウンロードおよびコンパイルされます。

1日目へようこそ

これは Rust Fundamentals の初日です。今日は幅広い範囲の トピックを扱います。

• Rust の基本構文: 変数、スカラー型と複合型、列挙型、構造体、 参照、関数、メソッド。
• 型と型推論。
• 制御フロー構文: ループ、条件分岐など。
• ユーザー定義型: 構造体と列挙型。

スケジュール

session outline

Hello, World

segment outline

Rust とは何か？

Rust は新しいプログラミング言語で、2015 年に 1.0 がリリースされました:

• Rust は C++ と似た役割を担う静的コンパイル言語です
  • rustc はバックエンドとして LLVM を使用します。
• Rust は多くのプラットフォームとアーキテクチャをサポートしています:
  • x86, ARM, WebAssembly, …
  • Linux, Mac, Windows, …
• Rust は幅広いデバイスで使用されています:
  • ファームウェアやブートローダー、
  • スマートディスプレイ、
  • 携帯電話、
  • デスクトップ、
  • サーバー。

Rust の利点

Rust の主な特長:

• コンパイル時のメモリ安全性 - メモリバグの大きな分類全体を コンパイル時に防止できる

  • 未初期化変数がない。
  • 二重解放がない。
  • 解放後使用がない。
  • NULL ポインタがない。
  • ロック解除し忘れたミューテックスがない。
  • スレッド間のデータ競合がない。
  • イテレータの無効化がない。

• 未定義の実行時動作がない - Rust の文が何をするかが未規定のままに なることは決してない

  • 配列アクセスでは境界チェックが行われる。
  • 整数オーバーフローは定義されている（panic またはラップアラウンド）。

• モダンな言語機能 - より高水準な言語と同等の表現力と使いやすさを 備えている

  • 列挙型とパターンマッチング。
  • ジェネリクス。
  • オーバーヘッドのない FFI。
  • ゼロコスト抽象化。
  • 優れたコンパイラエラー。
  • 組み込みの依存関係マネージャー。
  • テストの組み込みサポート。
  • 優れた Language Server Protocol サポート。

プレイグラウンド

Rust Playground は、短い Rust プログラムを実行するための簡単な方法を提供して おり、このコースの例や演習の基盤にもなっています。最初に表示される “hello-world” プログラムを実行してみてください。便利な機能がいくつか あります。

• “Tools” の下にある rustfmt オプションを使うと、コードを「標準的な」 方法で整形できます。

• Rust には、コードを生成するための主な「プロファイル」が 2 つあります: Debug（実行時チェックが多く、最適化は少ない）と Release（実行時チェックが少なく、 最適化が多い）です。これらは上部の “Debug” から利用できます。

• 興味があれば、“…” の下にある “ASM” を使って、生成されたアセンブリ コードを見ることができます。

型と値

segment outline

Hello, World

最も単純な Rust プログラムである、古典的な Hello World プログラムから始めましょう:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    println!("Hello 🌍!");
}

ここでわかること:

• 関数は fn で定義します。
• main 関数はプログラムのエントリポイントです。
• ブロックは、C や C++ と同様に波かっこで区切ります。
• 文は ; で終わります。
• println はマクロであり、呼び出し時の ! で示されます。
• Rust の文字列は UTF-8 でエンコードされており、任意の Unicode 文字を含められます。

変数

Rust は静的型付けによって型安全性を提供します。変数束縛は let で行います。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let x: i32 = 10;
    println!("x: {x}");
    // x = 20;
    // println!("x: {x}");
}

値

以下は、基本的な組み込み型と、各型のリテラル値の構文です。

各型のビット幅は次のとおりです。

• iN、uN、fN は N ビット幅です。
• isize と usize はポインタの幅です。
• char は 32 ビット幅です。
• bool は 8 ビット幅です。

算術

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn interproduct(a: i32, b: i32, c: i32) -> i32 {
    return a * b + b * c + c * a;
}

fn main() {
    println!("result: {}", interproduct(120, 100, 248));
}

型推論

Rust は、変数がどのように 使われるか を見て型を決定します。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn takes_u32(x: u32) {
    println!("u32: {x}");
}

fn takes_i8(y: i8) {
    println!("i8: {y}");
}

fn main() {
    let x = 10;
    let y = 20;

    takes_u32(x);
    takes_i8(y);
    // takes_u32(y);
}

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let x = 3.14;
    let y = 20;
    assert_eq!(x, y);
    // エラー: `{float} == {integer}` に対する実装がありません
}

演習: フィボナッチ

フィボナッチ数列は [0, 1] から始まります。n > 1 の場合、次の数は直前の 2 つの数の和です。

n 番目のフィボナッチ数を計算する関数 fib(n) を書いてください。この関数はいつ panic しますか？

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn fib(n: u32) -> u32 {
    if n < 2 {
        // ベースケース。
        return todo!("ここを実装してください");
    } else {
        // 再帰ケース。
        return todo!("ここを実装してください");
    }
}

fn main() {
    let n = 20;
    println!("fib({n}) = {}", fib(n));
}

解答

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn fib(n: u32) -> u32 {
    if n < 2 {
        return n;
    } else {
        return fib(n - 1) + fib(n - 2);
    }
}

fn main() {
    let n = 20;
    println!("fib({n}) = {}", fib(n));
}

ここでは、関数から値を返すために return 構文を使っています。講座の後半では、 ブロック内の最後の式が自動的に返されることを学びます。これにより、より簡潔な スタイルのために return キーワードを省略できるようになります。

if の条件 n < 2 には括弧は不要で、これは Rust の標準的な スタイルです。

パニック

この演習では、この関数がいつパニックするかを問います。フィボナッチ数列は 非常に急速に増加します。u32 では、n が 48 に達すると、計算された値は 32 ビット整数の上限 (4,294,967,295) をオーバーフローします。

Rust では、整数演算は デバッグモード（cargo run を使うときの デフォルト）でオーバーフローを検査します。オーバーフローが発生すると、 プログラムはパニックし（エラーメッセージを表示してクラッシュし）ます。 リリースモード（cargo run --release）では、オーバーフローチェックは デフォルトで無効になっており、値はラップアラウンドし （モジュラー演算）、誤った結果を生成します。

制御フローの基本

segment outline

ブロックとスコープ

• Rust のブロックには、波かっこ {} で囲まれた一連の式が含まれます。
• ブロックの最後の式によって、ブロック全体の値と型が 決まります。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let z = 13;
    let x = {
        let y = 10;
        dbg!(y);
        z - y
    };
    dbg!(x);
    // dbg!(y);
}

最後の式が ; で終わる場合、結果の値と型は () になります。

変数のスコープは、それを囲むブロック内に限定されます。

if 式

if 式 は、他の言語の if 文とまったく同じように使用します。

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let x = 10;
    if x == 0 {
        println!("zero!");
    } else if x < 100 {
        println!("biggish");
    } else {
        println!("huge");
    }
}

さらに、if は式としても使用できます。各ブロックの最後の式が、 if 式の値になります。

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let x = 10;
    let size = if x < 20 { "small" } else { "large" };
    println!("number size: {}", size);
}

match 式

match は、値を1つ以上の選択肢と照合するために使用できます:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let val = 1;
    match val {
        1 => println!("one"),
        10 => println!("ten"),
        100 => println!("one hundred"),
        _ => {
            println!("something else");
        }
    }
}

if 式と同様に、match も値を返すことができます。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let flag = true;
    let val = match flag {
        true => 1,
        false => 0,
    };
    println!("The value of {flag} is {val}");
}

ループ

Rust には、while、loop、for という 3 つのループ用キーワードがあります:

while

while キーワード は他の言語の場合とほぼ同じように動作し、条件が真である限りループ本体を 実行します。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut x = 200;
    while x >= 10 {
        x = x / 2;
    }
    dbg!(x);
}

for

for ループ は、値の範囲または コレクション内の要素を反復処理します:

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    for x in 1..5 {
        dbg!(x);
    }

    for elem in [2, 4, 8, 16, 32] {
        dbg!(elem);
    }
}

loop

loop 文は、break するまで ひたすらループし続けます。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut i = 0;
    loop {
        i += 1;
        dbg!(i);
        if i > 100 {
            break;
        }
    }
}

break と continue

次のイテレーションをすぐに開始したい場合は、 continue を使用します。

何らかの種類のループを途中で抜けたい場合は、 break を使用します。 loop では、これに省略可能な式を指定でき、その式が loop 式の値になります。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut i = 0;
    loop {
        i += 1;
        if i > 5 {
            break;
        }
        if i % 2 == 0 {
            continue;
        }
        dbg!(i);
    }
}

ラベル

continue と break はどちらも、ネストしたループを抜けるために使う 省略可能なラベル引数を受け取れます:

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let s = [[5, 6, 7], [8, 9, 10], [21, 15, 32]];
    let mut elements_searched = 0;
    let target_value = 10;
    'outer: for i in 0..=2 {
        for j in 0..=2 {
            elements_searched += 1;
            if s[i][j] == target_value {
                break 'outer;
            }
        }
    }
    dbg!(elements_searched);
}

関数

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn gcd(a: u32, b: u32) -> u32 {
    if b > 0 { gcd(b, a % b) } else { a }
}

fn main() {
    dbg!(gcd(143, 52));
}

マクロ

マクロはコンパイル時に Rust コードへ展開され、可変個の引数を取ることができます。末尾に ! が付くことで区別されます。Rust の 標準ライブラリには、便利なマクロがいくつも含まれています。

• println!(format, ..) は標準出力に 1 行出力し、std::fmt で説明されている 書式設定を適用します。
• format!(format, ..) は println! と同様に動作しますが、結果を 文字列として返します。
• dbg!(expression) は式の値をログに出力し、それを返します。
• todo!() はコードの一部を未実装として示します。実行されると panic します。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn factorial(n: u32) -> u32 {
    let mut product = 1;
    for i in 1..=n {
        product *= dbg!(i);
    }
    product
}

fn fizzbuzz(n: u32) -> u32 {
    todo!()
}

fn main() {
    let n = 4;
    println!("{n}! = {}", factorial(n));
}

演習: コラッツ数列

コラッツ数列 は、0より大きい任意の n₁ に対して、次のように定義されます:

• n_i が 1 であれば、数列は n_i で終了します。
• n_i が偶数であれば、n_i+1 = n_i / 2 となります。
• n_i が奇数であれば、n_i+1 = 3 * n_i + 1 となります。

たとえば、n₁ = 3 から始めると:

• 3 は奇数なので、n₂ = 3 * 3 + 1 = 10;
• 10 は偶数なので、n₃ = 10 / 2 = 5;
• 5 は奇数なので、n₄ = 3 * 5 + 1 = 16;
• 16 は偶数なので、n₅ = 16 / 2 = 8;
• 8 は偶数なので、n₆ = 8 / 2 = 4;
• 4 は偶数なので、n₇ = 4 / 2 = 2;
• 2 は偶数なので、n₈ = 1; そして
• 数列は終了します。

与えられた初期 n に対するコラッツ数列の長さを計算する関数を 作成してください。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// Determine the length of the collatz sequence beginning at `n`.
fn collatz_length(mut n: i32) -> u32 {
  todo!("ここを実装してください")
}

fn main() {
    println!("Length: {}", collatz_length(11)); // should be 15
}

解答

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// Determine the length of the collatz sequence beginning at `n`.
fn collatz_length(mut n: i32) -> u32 {
    let mut len = 1;
    while n > 1 {
        n = if n % 2 == 0 { n / 2 } else { 3 * n + 1 };
        len += 1;
    }
    len
}

fn main() {
    println!("Length: {}", collatz_length(11)); // should be 15
}

この解答では、いくつかの重要な Rust の機能を示しています。

• mut 引数: n 引数は mut n として宣言されています。これにより、ローカル変数 n は関数スコープ内で可変になります。整数は値渡しされる Copy 型であるため、これは呼び出し元の値には影響しません。
• if 式: Rust の if は式であり、値を生成することを意味します。if/else ブロックの結果を直接 n に代入しています。これは、各分岐の中で n = ... と書くよりも簡潔です。
• 暗黙の return: 関数は len で終わっており（セミコロンなし）、これが自動的に返されます。

お帰りなさい

session outline

タプルと配列

segment outline

配列

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut a: [i8; 5] = [5, 4, 3, 2, 1];
    a[2] = 0;
    println!("a: {a:?}");
}

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut a: [i8; 5] = [5, 4, 3, 2, 1];
    a[6] = 0;
    println!("a: {a:?}");
}

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn get_index() -> usize {
    6
}

fn main() {
    let mut a: [i8; 5] = [5, 4, 3, 2, 1];
    a[get_index()] = 0;
    println!("a: {a:?}");
}

タプル

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let t: (i8, bool) = (7, true);
    dbg!(t.0);
    dbg!(t.1);
}

配列の反復

for 文は配列に対する反復をサポートしています（ただしタプルはサポートしていません）。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let primes = [2, 3, 5, 7, 11, 13, 17, 19];
    for prime in primes {
        for i in 2..prime {
            assert_ne!(prime % i, 0);
        }
    }
}

パターンと分配束縛

Rust では、パターンマッチを使って、タプルのようなより大きな値をその構成要素に分解して束縛できます。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn check_order(tuple: (i32, i32, i32)) -> bool {
    let (left, middle, right) = tuple;
    left < middle && middle < right
}

fn main() {
    let tuple = (1, 5, 3);
    println!(
        "{tuple:?}: {}",
        if check_order(tuple) { "ordered" } else { "unordered" }
    );
}

演習: ネストした配列

配列には他の配列を含めることができます:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

let array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];

この変数の型は何ですか？

上のような配列を使って、行列を転置する（行を列にする）関数 transpose を書いてください:

以下のコードを https://play.rust-lang.org/ にコピーして、関数を実装してください。 この関数は 3×3 行列に対してのみ動作します。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
    todo!()
}

fn main() {
    let matrix = [
        [101, 102, 103], // <-- the comment makes rustfmt add a newline
        [201, 202, 203],
        [301, 302, 303],
    ];

    println!("Original:");
    for row in matrix {
        println!("{row:?}");
    }

    let transposed = transpose(matrix);

    println!("\nTransposed:");
    for row in transposed {
        println!("{row:?}");
    }
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {
    let mut result = [[0; 3]; 3];
    for i in 0..3 {
        for j in 0..3 {
            result[j][i] = matrix[i][j];
        }
    }
    result
}

fn main() {
    let matrix = [
        [101, 102, 103], // <-- the comment makes rustfmt add a newline
        [201, 202, 203],
        [301, 302, 303],
    ];

    println!("Original:");
    for row in matrix {
        println!("{row:?}");
    }

    let transposed = transpose(matrix);

    println!("\nTransposed:");
    for row in transposed {
        println!("{row:?}");
    }
}

• 配列型: 型 [[i32; 3]; 3] は、サイズ 3 の配列を表し、 各要素自体が 3 個の i32 からなる配列です。これは、多次元 配列を Rust で通常表現する方法です。
• 初期化: result は、値を埋める前にゼロ ([[0; 3]; 3]) で 初期化します。Rust では、すべての変数は使用前に初期化されている 必要があり、安全な Rust には「未初期化メモリ」という概念は ありません。
• Copy セマンティクス: Copy 型 (i32 など) の配列自体も Copy です。 matrix を関数に渡すと、値渡しによってコピーされます。変数 result は、新しい別個の配列です。
• 反復: 標準的な範囲 (0..3) を使った for ループで、添字を反復 処理します。Rust には強力なイテレータもあり、それらは後で見ますが、 この行列の転置ではインデックス指定が分かりやすいやり方です。

リファレンス

segment outline

共有参照

参照は、その値の所有権を取得することなく別の値にアクセスするための手段であり、「借用」とも呼ばれます。共有参照は読み取り専用で、参照されるデータは変更できません。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let a = 'A';
    let b = 'B';

    let mut r: &char = &a;
    dbg!(r);

    r = &b;
    dbg!(r);
}

型 T への共有参照の型は &T です。参照値は & 演算子で作成します。* 演算子は参照を「デリファレンス」し、その値を取り出します。

排他的参照

排他的参照は、可変参照とも呼ばれ、参照先の値を変更できる 参照です。型は &mut T です。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut point = (1, 2);
    let x_coord = &mut point.0;
    *x_coord = 20;
    println!("point: {point:?}");
}

スライス

スライスは、より大きなコレクションの一部へのビューを提供します：

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let a: [i32; 6] = [10, 20, 30, 40, 50, 60];
    println!("a: {a:?}");

    let s: &[i32] = &a[2..4];
    println!("s: {s:?}");
}

• スライスは、切り出し元の型からデータを借用します。

文字列

これで、Rust における 2 つの文字列型を理解できます。

• &str は UTF-8 エンコードされたバイトのスライスであり、&[u8] に似ています。
• String は UTF-8 エンコードされたバイトの所有権を持つバッファであり、Vec<T> に似ています。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let s1: &str = "World";
    println!("s1: {s1}");

    let mut s2: String = String::from("Hello ");
    println!("s2: {s2}");

    s2.push_str(s1);
    println!("s2: {s2}");

    let s3: &str = &s2[2..9];
    println!("s3: {s3}");
}

参照の有効性

Rust では、参照を常に安全に使用できるようにするための、参照に関する いくつかのルールが適用されます。その 1 つは、参照は決して null に ならないというルールで、これにより null チェックなしで安全に使用 できます。もう 1 つ、ここで見ておくルールは、参照の寿命が、参照先の データの寿命を 超える ことはできない、というものです。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let x_ref = {
        let x = 10;
        &x
    };
    dbg!(x_ref);
}

演習: 幾何学

点を [f64;3] として表現し、3 次元幾何学のためのいくつかのユーティリティ関数を作成します。関数シグネチャは自分で決めてください。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// 各座標の二乗を合計し、その平方根を取ることでベクトルの大きさを
// 計算します。平方根の計算には `sqrt()` メソッドを使用します。
// たとえば `v.sqrt()` のようにします。


fn magnitude(...) -> f64 {
    todo!()
}

// ベクトルの大きさを計算し、その大きさで各座標を割ることでベクトルを
// 正規化します。


fn normalize(...) {
    todo!()
}

// 以下の `main` を使って自分の実装をテストしてください。

fn main() {
    println!("Magnitude of a unit vector: {}", magnitude(&[0.0, 1.0, 0.0]));

    let mut v = [1.0, 2.0, 9.0];
    println!("Magnitude of {v:?}: {}", magnitude(&v));
    normalize(&mut v);
    println!("Magnitude of {v:?} after normalization: {}", magnitude(&v));
}

解答

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// Calculate the magnitude of the given vector.
fn magnitude(vector: &[f64; 3]) -> f64 {
    let mut mag_squared = 0.0;
    for coord in vector {
        mag_squared += coord * coord;
    }
    mag_squared.sqrt()
}

/// Change the magnitude of the vector to 1.0 without changing its direction.
fn normalize(vector: &mut [f64; 3]) {
    let mag = magnitude(vector);
    for item in vector {
        *item /= mag;
    }
}

fn main() {
    println!("Magnitude of a unit vector: {}", magnitude(&[0.0, 1.0, 0.0]));

    let mut v = [1.0, 2.0, 9.0];
    println!("Magnitude of {v:?}: {}", magnitude(&v));
    normalize(&mut v);
    println!("Magnitude of {v:?} after normalization: {}", magnitude(&v));
}

ユーザー定義型

segment outline

名前付きフィールドを持つ構造体

C や C++ と同様に、Rust は独自の構造体をサポートしています:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Person {
    name: String,
    age: u8,
}

fn describe(person: &Person) {
    println!("{} is {} years old", person.name, person.age);
}

fn main() {
    let mut peter = Person {
        name: String::from("Peter"),
        age: 27,
    };
    describe(&peter);

    peter.age = 28;
    describe(&peter);

    let name = String::from("Avery");
    let age = 39;
    let avery = Person { name, age };
    describe(&avery);
}

タプル構造体

フィールド名が重要でない場合は、タプル構造体を使用できます:

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Point(i32, i32);

fn main() {
    let p = Point(17, 23);
    println!("({}, {})", p.0, p.1);
}

これは、単一フィールドのラッパー（newtype と呼ばれます）によく使われます:

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct PoundsOfForce(f64);
struct Newtons(f64);

fn compute_thruster_force() -> PoundsOfForce {
    todo!("Ask a rocket scientist at NASA")
}

fn set_thruster_force(force: Newtons) {
    // ...
}

fn main() {
    let force = compute_thruster_force();
    set_thruster_force(force);
}

列挙型

enum キーワードを使うと、いくつかの異なる バリアントを持つ型を作成できます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
enum Direction {
    Left,
    Right,
}

#[derive(Debug)]
enum PlayerMove {
    Pass,                        // 単純なバリアント
    Run(Direction),              // タプルバリアント
    Teleport { x: u32, y: u32 }, // 構造体バリアント
}

fn main() {
    let dir = Direction::Left;
    let player_move: PlayerMove = PlayerMove::Run(dir);
    println!("On this turn: {player_move:?}");
}

型エイリアス

型エイリアスは、別の型に対する名前を作成します。この 2 つの型は互いに置き換えて使用できます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

enum CarryableConcreteItem {
    Left,
    Right,
}

type Item = CarryableConcreteItem;

// 型エイリアスは、長くて複雑な型でより便利です:
use std::cell::RefCell;
use std::sync::{Arc, RwLock};
type PlayerInventory = RwLock<Vec<Arc<RefCell<Item>>>>;

const

定数はコンパイル時に評価され、その値は使用されるすべての箇所にインライン展開されます:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

const DIGEST_SIZE: usize = 3;
const FILL_VALUE: u8 = calculate_fill_value();

const fn calculate_fill_value() -> u8 {
    if DIGEST_SIZE < 10 { 42 } else { 13 }
}

fn compute_digest(text: &str) -> [u8; DIGEST_SIZE] {
    let mut digest = [FILL_VALUE; DIGEST_SIZE];
    for (idx, &b) in text.as_bytes().iter().enumerate() {
        digest[idx % DIGEST_SIZE] = digest[idx % DIGEST_SIZE].wrapping_add(b);
    }
    digest
}

fn main() {
    let digest = compute_digest("Hello");
    println!("digest: {digest:?}");
}

const 値を生成するためにコンパイル時に呼び出せるのは、const が付いた関数だけです。ただし、const 関数は実行時に呼び出すこともできます。

static

静的変数はプログラムの実行全体を通して存続するため、 移動しません:

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

static BANNER: &str = "Welcome to RustOS 3.14";

fn main() {
    println!("{BANNER}");
}

Rust RFC Book で述べられているように、これらは使用時にインライン化されず、 実際に対応するメモリ位置を持ちます。これは unsafe コードや組み込みコードで有用であり、 変数はプログラムの実行全体を通して存続します。グローバルスコープの値に オブジェクト同一性を必要とする理由がない場合は、一般に const が 好まれます。

演習: エレベーターイベント

エレベーター制御システム内のイベントを表すデータ構造を作成します。 さまざまなイベントを構築するための型と関数は、自分で定義してください。 型を {:?} でフォーマットできるようにするため、#[derive(Debug)] を使用してください。

この演習では、main がエラーなく実行されるように、データ構造を作成して 値を設定するだけで十分です。コースの次のパートでは、これらの構造から データを取り出す方法を扱います。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#![allow(dead_code)]

#[derive(Debug)]
/// An event in the elevator system that the controller must react to.
enum Event {
    // TODO: 必要なバリアントを追加する
}

/// A direction of travel.
#[derive(Debug)]
enum Direction {
    Up,
    Down,
}

/// The car has arrived on the given floor.
fn car_arrived(floor: i32) -> Event {
    todo!()
}

/// The car doors have opened.
fn car_door_opened() -> Event {
    todo!()
}

/// The car doors have closed.
fn car_door_closed() -> Event {
    todo!()
}

/// A directional button was pressed in an elevator lobby on the given floor.
fn lobby_call_button_pressed(floor: i32, dir: Direction) -> Event {
    todo!()
}

/// A floor button was pressed in the elevator car.
fn car_floor_button_pressed(floor: i32) -> Event {
    todo!()
}

fn main() {
    println!(
        "A ground floor passenger has pressed the up button: {:?}",
        lobby_call_button_pressed(0, Direction::Up)
    );
    println!("The car has arrived on the ground floor: {:?}", car_arrived(0));
    println!("The car door opened: {:?}", car_door_opened());
    println!(
        "A passenger has pressed the 3rd floor button: {:?}",
        car_floor_button_pressed(3)
    );
    println!("The car door closed: {:?}", car_door_closed());
    println!("The car has arrived on the 3rd floor: {:?}", car_arrived(3));
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#![allow(dead_code)]

#[derive(Debug)]
/// An event in the elevator system that the controller must react to.
enum Event {
    /// A button was pressed.
    ButtonPressed(Button),

    /// The car has arrived at the given floor.
    CarArrived(Floor),

    /// The car's doors have opened.
    CarDoorOpened,

    /// The car's doors have closed.
    CarDoorClosed,
}

/// A floor is represented as an integer.
type Floor = i32;

/// A direction of travel.
#[derive(Debug)]
enum Direction {
    Up,
    Down,
}

/// A user-accessible button.
#[derive(Debug)]
enum Button {
    /// A button in the elevator lobby on the given floor.
    LobbyCall(Direction, Floor),

    /// A floor button within the car.
    CarFloor(Floor),
}

/// The car has arrived on the given floor.
fn car_arrived(floor: i32) -> Event {
    Event::CarArrived(floor)
}

/// The car doors have opened.
fn car_door_opened() -> Event {
    Event::CarDoorOpened
}

/// The car doors have closed.
fn car_door_closed() -> Event {
    Event::CarDoorClosed
}

/// A directional button was pressed in an elevator lobby on the given floor.
fn lobby_call_button_pressed(floor: i32, dir: Direction) -> Event {
    Event::ButtonPressed(Button::LobbyCall(dir, floor))
}

/// A floor button was pressed in the elevator car.
fn car_floor_button_pressed(floor: i32) -> Event {
    Event::ButtonPressed(Button::CarFloor(floor))
}

fn main() {
    println!(
        "A ground floor passenger has pressed the up button: {:?}",
        lobby_call_button_pressed(0, Direction::Up)
    );
    println!("The car has arrived on the ground floor: {:?}", car_arrived(0));
    println!("The car door opened: {:?}", car_door_opened());
    println!(
        "A passenger has pressed the 3rd floor button: {:?}",
        car_floor_button_pressed(3)
    );
    println!("The car door closed: {:?}", car_door_closed());
    println!("The car has arrived on the 3rd floor: {:?}", car_arrived(3));
}

• データを持つ列挙型: Rust の enum バリアントはデータを持てます。CarArrived(Floor) は整数を持ち、ButtonPressed(Button) はネストされた Button enum を持ちます。これにより、Event は型安全な方法で豊富な状態の集合を表現できます。
• 型エイリアス: type Floor = i32 は i32 に意味的な名前を与えます。これにより可読性は向上しますが、コンパイラにとって Floor は依然として単なる i32 です。
• #[derive(Debug)]: この属性は、{:?} を使って列挙型を出力用にフォーマットするコードを自動生成するために使います。これがなければ、fmt::Debug トレイトを手動で実装する必要があります。
• ネストされた列挙型: Button enum は Event::ButtonPressed の中にネストされています。この階層構造は、複雑なドメインをモデル化するために Rust でよく使われます。

2日目へようこそ

これまでに Rust の基礎を学びました。

• 基本型: 整数、ブール値、文字、タプル、配列。
• 制御フロー: if 式、ループ、match 式。
• 関数: 関数の定義方法と呼び出し方法。
• ユーザー定義型: struct と enum を使ったデータのモデリング。
• 参照: & と &mut による基本的な借用。

これで、Rust であらゆる型を構築し、基本的なロジックを実装できるようになりました！

スケジュール

session outline

パターン マッチング

segment outline

反駁不能なパターン

1日目では、パターンを使って複合値を 分解 する方法を簡単に見ました。ここでそれを振り返りつつ、パターンで表現できるほかのいくつかのことについて見ていきましょう:

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn takes_tuple(tuple: (char, i32, bool)) {
    let a = tuple.0;
    let b = tuple.1;
    let c = tuple.2;

    // これは上と同じことを行います。
    let (a, b, c) = tuple;

    // 最初の要素は無視し、2番目と3番目だけを束縛します。
    let (_, b, c) = tuple;

    // 最後の要素以外をすべて無視します。
    let (.., c) = tuple;
}

fn main() {
    takes_tuple(('a', 777, true));
}

値のマッチング

match キーワードを使うと、値を 1 つ以上の パターン に照合できます。パターン は C や C++ の switch と同様に単純な値にもできますが、より複雑な条件を表現する ためにも使えます:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[rustfmt::skip]
fn main() {
    let input = 'x';
    match input {
        'q'                       => println!("Quitting"),
        'a' | 's' | 'w' | 'd'     => println!("Moving around"),
        '0'..='9'                 => println!("Number input"),
        key if key.is_lowercase() => println!("Lowercase: {key}"),
        _                         => println!("Something else"),
    }
}

パターン内の変数（この例では key）は、match アーム内で使用できる バインディングを作成します。これについては次のスライドでさらに学びます。

match ガードがあると、そのアームは条件が真の場合にのみマッチします。条件が 偽なら、後続のケースのチェックが続行されます。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[rustfmt::skip]
fn main() {
    let input = 'a';
    match input {
        key if key.is_uppercase() => println!("Uppercase"),
        key => if input == 'q' { println!("Quitting") },
        _   => println!("Bug: this is never printed"),
    }
}

構造体

タプルと同様に、構造体もマッチングによって分解できます。

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Move {
    delta: (i32, i32),
    repeat: u32,
}

#[rustfmt::skip]
fn main() {
    let m = Move { delta: (10, 0), repeat: 5 };

    match m {
        Move { delta: (0, 0), .. }        => println!("Standing still"),
        Move { delta: (x, 0), repeat }    => println!("{repeat} step x: {x}"),
        Move { delta: (0, y), repeat: 1 } => println!("Single step y: {y}"),
        _                                 => println!("Other move"),
    }
}

列挙型

タプルと同様に、列挙型もマッチによって分解できます。

パターンは、値の一部に変数を束縛するためにも使えます。これは、 型の構造を調べる方法です。まずは単純な enum 型から始めましょう。

// 著作権 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

enum Result {
    Ok(i32),
    Err(String),
}

fn divide_in_two(n: i32) -> Result {
    if n % 2 == 0 {
        Result::Ok(n / 2)
    } else {
        Result::Err(format!("cannot divide {n} into two equal parts"))
    }
}

fn main() {
    let n = 100;
    match divide_in_two(n) {
        Result::Ok(half) => println!("{n} divided in two is {half}"),
        Result::Err(msg) => println!("sorry, an error happened: {msg}"),
    }
}

ここでは、各アームを使って Result の値を 分解 しています。最初の アームでは、half は Ok バリアントの中の値に束縛されます。2 番目のアームでは、 msg はエラーメッセージに束縛されます。

let による制御フロー

Rust には、他の言語とは異なる制御フロー構文がいくつかあります。これらは パターンマッチングに使用されます。

• if let 式
• while let 式
• let else 式

if let 式

この if let 式 を使うと、値がパターンに一致するかどうかに応じて異なるコードを実行できます:

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::time::Duration;

fn sleep_for(secs: f32) {
    let result = Duration::try_from_secs_f32(secs);

    if let Ok(duration) = result {
        std::thread::sleep(duration);
        println!("slept for {duration:?}");
    }
}

fn main() {
    sleep_for(-10.0);
    sleep_for(0.8);
}

while let 文

if let と同様に、 while let というバリアントがあり、値をパターンに対して繰り返しテストします。

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut name = String::from("Comprehensive Rust 🦀");
    while let Some(c) = name.pop() {
        dbg!(c);
    }
    // （文字列を逆順にするもっと効率的な方法はあります！）
}

ここで String::pop は、文字列が空になるまでは Some(c) を返し、その後は None を返します。 while let を使うことで、すべての要素に対して反復を続けられます。

let else 文

パターンにマッチさせて関数から返る一般的なケースでは、 let else を使います。 「else」側は発散しなければなりません（return、break、または panic。つまり、ブロックの末尾まで到達してそのまま抜けることはできません）。

// 著作権 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn hex_or_die_trying(maybe_string: Option<String>) -> Result<u32, String> {
    let s = if let Some(s) = maybe_string {
        s
    } else {
        return Err(String::from("None を受け取りました"));
    };

    let first_byte_char = if let Some(first) = s.chars().next() {
        first
    } else {
        return Err(String::from("空の文字列を受け取りました"));
    };

    let digit = if let Some(digit) = first_byte_char.to_digit(16) {
        digit
    } else {
        return Err(String::from("16進数の桁ではありません"));
    };

    Ok(digit)
}

fn main() {
    println!("結果: {:?}", hex_or_die_trying(Some(String::from("foo"))));
}

#![allow(unused)]
fn main() {
// 著作権 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn hex_or_die_trying(maybe_string: Option<String>) -> Result<u32, String> {
    let Some(s) = maybe_string else {
        return Err(String::from("None を受け取りました"));
    };

    let Some(first_byte_char) = s.chars().next() else {
        return Err(String::from("空の文字列を受け取りました"));
    };

    let Some(digit) = first_byte_char.to_digit(16) else {
        return Err(String::from("16進数の桁ではありません"));
    };

    Ok(digit)
}
}

演習: 式の評価

算術式のためのシンプルな再帰的評価器を書いてみましょう。

小さな算術式の例として 10 + 20 があり、これは 30 に評価されます。この式は木として表現できます。

より大きく複雑な式として (10 * 9) + ((3 - 4) * 5) があり、これは 85 に評価されます。これはさらに大きな木として表現されます。

コードでは、この木を 2 つの型で表現します。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// An operation to perform on two subexpressions.
#[derive(Debug)]
enum Operation {
    Add,
    Sub,
    Mul,
    Div,
}

/// An expression, in tree form.
#[derive(Debug)]
enum Expression {
    /// An operation on two subexpressions.
    Op { op: Operation, left: Box<Expression>, right: Box<Expression> },

    /// A literal value
    Value(i64),
}

ここでの Box 型はスマートポインタであり、コースの後半で詳しく扱います。式は、テストにあるとおり Box::new で「ボックス化」できます。ボックス化された式を評価するには、デリファレンス演算子 (*) を使って「アンボックス」します: eval(*boxed_expr)。

次のコマンドで新しい Cargo ライブラリプロジェクトを作成してください。

cargo new --lib evaluator

以下のコードを src/lib.rs ファイルにコピー＆ペーストしてください。

次に eval の実装を始めてください。最終的なライブラリがテストに合格することを cargo test で確認してください。todo!() を使い、テストを 1 つずつ通していくとよいでしょう。#[ignore] を使えば、テストを一時的にスキップすることもできます。

#[test]
#[ignore]
fn test_value() { .. }

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// An operation to perform on two subexpressions.
#[derive(Debug)]
enum Operation {
    Add,
    Sub,
    Mul,
    Div,
}

/// An expression, in tree form.
#[derive(Debug)]
enum Expression {
    /// An operation on two subexpressions.
    Op { op: Operation, left: Box<Expression>, right: Box<Expression> },

    /// A literal value
    Value(i64),
}

fn eval(e: Expression) -> i64 {
    todo!()
}

#[test]
fn test_value() {
    assert_eq!(eval(Expression::Value(19)), 19);
}

#[test]
fn test_sum() {
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Add,
            left: Box::new(Expression::Value(10)),
            right: Box::new(Expression::Value(20)),
        }),
        30
    );
}

#[test]
fn test_recursion() {
    let term1 = Expression::Op {
        op: Operation::Mul,
        left: Box::new(Expression::Value(10)),
        right: Box::new(Expression::Value(9)),
    };
    let term2 = Expression::Op {
        op: Operation::Mul,
        left: Box::new(Expression::Op {
            op: Operation::Sub,
            left: Box::new(Expression::Value(3)),
            right: Box::new(Expression::Value(4)),
        }),
        right: Box::new(Expression::Value(5)),
    };
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Add,
            left: Box::new(term1),
            right: Box::new(term2),
        }),
        85
    );
}

#[test]
fn test_zeros() {
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Add,
            left: Box::new(Expression::Value(0)),
            right: Box::new(Expression::Value(0))
        }),
        0
    );
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Mul,
            left: Box::new(Expression::Value(0)),
            right: Box::new(Expression::Value(0))
        }),
        0
    );
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Sub,
            left: Box::new(Expression::Value(0)),
            right: Box::new(Expression::Value(0))
        }),
        0
    );
}

#[test]
fn test_div() {
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Div,
            left: Box::new(Expression::Value(10)),
            right: Box::new(Expression::Value(2)),
        }),
        5
    )
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// An operation to perform on two subexpressions.
#[derive(Debug)]
enum Operation {
    Add,
    Sub,
    Mul,
    Div,
}

/// An expression, in tree form.
#[derive(Debug)]
enum Expression {
    /// An operation on two subexpressions.
    Op { op: Operation, left: Box<Expression>, right: Box<Expression> },

    /// A literal value
    Value(i64),
}

fn eval(e: Expression) -> i64 {
    match e {
        Expression::Op { op, left, right } => {
            let left = eval(*left);
            let right = eval(*right);
            match op {
                Operation::Add => left + right,
                Operation::Sub => left - right,
                Operation::Mul => left * right,
                Operation::Div => left / right,
            }
        }
        Expression::Value(v) => v,
    }
}

#[test]
fn test_value() {
    assert_eq!(eval(Expression::Value(19)), 19);
}

#[test]
fn test_sum() {
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Add,
            left: Box::new(Expression::Value(10)),
            right: Box::new(Expression::Value(20)),
        }),
        30
    );
}

#[test]
fn test_recursion() {
    let term1 = Expression::Op {
        op: Operation::Mul,
        left: Box::new(Expression::Value(10)),
        right: Box::new(Expression::Value(9)),
    };
    let term2 = Expression::Op {
        op: Operation::Mul,
        left: Box::new(Expression::Op {
            op: Operation::Sub,
            left: Box::new(Expression::Value(3)),
            right: Box::new(Expression::Value(4)),
        }),
        right: Box::new(Expression::Value(5)),
    };
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Add,
            left: Box::new(term1),
            right: Box::new(term2),
        }),
        85
    );
}

#[test]
fn test_zeros() {
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Add,
            left: Box::new(Expression::Value(0)),
            right: Box::new(Expression::Value(0))
        }),
        0
    );
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Mul,
            left: Box::new(Expression::Value(0)),
            right: Box::new(Expression::Value(0))
        }),
        0
    );
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Sub,
            left: Box::new(Expression::Value(0)),
            right: Box::new(Expression::Value(0))
        }),
        0
    );
}

#[test]
fn test_div() {
    assert_eq!(
        eval(Expression::Op {
            op: Operation::Div,
            left: Box::new(Expression::Value(10)),
            right: Box::new(Expression::Value(2)),
        }),
        5
    )
}

メソッドとトレイト

segment outline

メソッド

Rust では、新しい型に関数を関連付けることができます。これは impl ブロックで行います:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
struct CarRace {
    name: String,
    laps: Vec<i32>,
}

impl CarRace {
    // レシーバなし、静的メソッド
    fn new(name: &str) -> Self {
        Self { name: String::from(name), laps: Vec::new() }
    }

    // self への排他的な借用による読み書きアクセス
    fn add_lap(&mut self, lap: i32) {
        self.laps.push(lap);
    }

    // self への共有の読み取り専用借用アクセス
    fn print_laps(&self) {
        println!("Recorded {} laps for {}:", self.laps.len(), self.name);
        for (idx, lap) in self.laps.iter().enumerate() {
            println!("Lap {idx}: {lap} sec");
        }
    }

    // self の排他的な所有権（後で扱います）
    fn finish(self) {
        let total: i32 = self.laps.iter().sum();
        println!("Race {} is finished, total lap time: {}", self.name, total);
    }
}

fn main() {
    let mut race = CarRace::new("Monaco Grand Prix");
    race.add_lap(70);
    race.add_lap(68);
    race.print_laps();
    race.add_lap(71);
    race.print_laps();
    race.finish();
    // race.add_lap(42);
}

self 引数は「レシーバ」、つまりそのメソッドが作用するオブジェクトを 指定します。 メソッドでよく使われるレシーバには、いくつかの共通パターンがあります:

• &self: 共有かつ不変の参照を使って、呼び出し元からオブジェクトを 借用します。その後もオブジェクトは再び使用できます。
• &mut self: 一意で可変な参照を使って、呼び出し元からオブジェクトを 借用します。その後もオブジェクトは再び使用できます。
• self: オブジェクトの所有権を取得し、呼び出し元からムーブします。 メソッドがそのオブジェクトの所有者になります。所有権が明示的に 移譲されない限り、メソッドから戻るときにそのオブジェクトはドロップ （メモリ解放）されます。完全な所有権を持つことは、自動的に可変であることを意味するわけではありません。
• mut self: 上と同じですが、メソッドがオブジェクトを変更できます。
• レシーバなし: これは構造体上の静的メソッドになります。通常、慣例的に new と呼ばれるコンストラクタを作るために使われます。

トレイト

Rust では、トレイトを使って型を抽象化できます。トレイトはインターフェースに似ています。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

trait Pet {
    /// このペットの発言を 1 つ返します。
    fn talk(&self) -> String;

    /// このペットにあいさつする文字列をターミナルに出力します。
    fn greet(&self);
}

トレイトを実装する

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

trait Pet {
    fn talk(&self) -> String;

    fn greet(&self) {
        println!("Oh you're a cutie! What's your name? {}", self.talk());
    }
}

struct Dog {
    name: String,
    age: i8,
}

impl Pet for Dog {
    fn talk(&self) -> String {
        format!("Woof, my name is {}!", self.name)
    }
}

fn main() {
    let fido = Dog { name: String::from("Fido"), age: 5 };
    dbg!(fido.talk());
    fido.greet();
}

スーパートレイト

トレイトは、それを実装する型に対して、スーパートレイト と呼ばれる他のトレイトの実装も要求できます。ここでは、Pet を実装する任意の型は Animal を実装しなければなりません。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

trait Animal {
    fn leg_count(&self) -> u32;
}

trait Pet: Animal {
    fn name(&self) -> String;
}

struct Dog(String);

impl Animal for Dog {
    fn leg_count(&self) -> u32 {
        4
    }
}

impl Pet for Dog {
    fn name(&self) -> String {
        self.0.clone()
    }
}

fn main() {
    let puppy = Dog(String::from("Rex"));
    println!("{} has {} legs", puppy.name(), puppy.leg_count());
}

関連型

関連型は、トレイトの実装によって提供されるプレースホルダー型です。

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
struct Meters(i32);
#[derive(Debug)]
struct MetersSquared(i32);

trait Multiply {
    type Output;
    fn multiply(&self, other: &Self) -> Self::Output;
}

impl Multiply for Meters {
    type Output = MetersSquared;
    fn multiply(&self, other: &Self) -> Self::Output {
        MetersSquared(self.0 * other.0)
    }
}

fn main() {
    println!("{:?}", Meters(10).multiply(&Meters(20)));
}

導出

サポートされているトレイトは、次のようにしてカスタム型に自動実装できます。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug, Clone, Default)]
struct Player {
    name: String,
    strength: u8,
    hit_points: u8,
}

fn main() {
    let p1 = Player::default(); // Default トレイトは `default` コンストラクタを追加します。
    let mut p2 = p1.clone(); // Clone トレイトは `clone` メソッドを追加します。
    p2.name = String::from("EldurScrollz");
    // Debug トレイトは `{:?}` を使った出力をサポートします。
    println!("{p1:?} vs. {p2:?}");
}

演習: Logger トレイト

log メソッドを持つトレイト Logger を使って、シンプルなロギングユーティリティを設計してみましょう。進行状況をログに出力する可能性があるコードは、&impl Logger を受け取れるようになります。テストでは、これによってメッセージをテストのログファイルに出力できます。一方、本番ビルドでは、メッセージをログサーバーに送信できます。

ただし、以下で与えられている StderrLogger は、冗長性に関係なくすべてのメッセージをログに出力します。あなたの課題は、最大冗長性を超えるメッセージを無視する VerbosityFilter 型を書くことです。

これは一般的なパターンです。つまり、トレイト実装をラップする構造体が、その同じトレイトを実装し、その過程で振る舞いを追加するというものです。「Generics」セグメントでは、ラッパーをラップ対象の型に対してジェネリックにする方法を見ていきます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

trait Logger {
    /// Log a message at the given verbosity level.
    fn log(&self, verbosity: u8, message: &str);
}

struct StderrLogger;

impl Logger for StderrLogger {
    fn log(&self, verbosity: u8, message: &str) {
        eprintln!("verbosity={verbosity}: {message}");
    }
}

/// Only log messages up to the given verbosity level.
struct VerbosityFilter {
    max_verbosity: u8,
    inner: StderrLogger,
}

// TODO: `VerbosityFilter` に `Logger` トレイトを実装する。

fn main() {
    let logger = VerbosityFilter { max_verbosity: 3, inner: StderrLogger };
    logger.log(5, "FYI");
    logger.log(2, "Uhoh");
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

trait Logger {
    /// Log a message at the given verbosity level.
    fn log(&self, verbosity: u8, message: &str);
}

struct StderrLogger;

impl Logger for StderrLogger {
    fn log(&self, verbosity: u8, message: &str) {
        eprintln!("verbosity={verbosity}: {message}");
    }
}

/// Only log messages up to the given verbosity level.
struct VerbosityFilter {
    max_verbosity: u8,
    inner: StderrLogger,
}

impl Logger for VerbosityFilter {
    fn log(&self, verbosity: u8, message: &str) {
        if verbosity <= self.max_verbosity {
            self.inner.log(verbosity, message);
        }
    }
}

fn main() {
    let logger = VerbosityFilter { max_verbosity: 3, inner: StderrLogger };
    logger.log(5, "FYI");
    logger.log(2, "Uhoh");
}

ジェネリクス

segment outline

ジェネリック関数

Rust はジェネリクスをサポートしており、これにより、使用または格納される型に対してアルゴリズムやデータ構造 （ソートや二分木など）を抽象化できます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn pick<T>(cond: bool, left: T, right: T) -> T {
    if cond { left } else { right }
}

fn main() {
    println!("picked a number: {:?}", pick(true, 222, 333));
    println!("picked a string: {:?}", pick(false, 'L', 'R'));
}

トレイト境界

ジェネリクスを扱うときは、型に何らかのトレイトの実装を要求して、そのトレイトのメソッドを呼び出せるようにしたいことがよくあります。

これは T: Trait で指定できます。

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn duplicate<T: Clone>(a: T) -> (T, T) {
    (a.clone(), a.clone())
}

struct NotCloneable;

fn main() {
    let foo = String::from("foo");
    let pair = duplicate(foo);
    println!("{pair:?}");
}

ジェネリックなデータ型

ジェネリクスを使うと、具体的なフィールド型を抽象化できます。前の セグメントの演習に戻ると、次のようになります:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

pub trait Logger {
    /// 指定された詳細度レベルでメッセージをログに記録します。
    fn log(&self, verbosity: u8, message: &str);
}

struct StderrLogger;

impl Logger for StderrLogger {
    fn log(&self, verbosity: u8, message: &str) {
        eprintln!("verbosity={verbosity}: {message}");
    }
}

/// 指定された詳細度レベル以下のメッセージだけをログに記録します。
struct VerbosityFilter<L> {
    max_verbosity: u8,
    inner: L,
}

impl<L: Logger> Logger for VerbosityFilter<L> {
    fn log(&self, verbosity: u8, message: &str) {
        if verbosity <= self.max_verbosity {
            self.inner.log(verbosity, message);
        }
    }
}

fn main() {
    let logger = VerbosityFilter { max_verbosity: 3, inner: StderrLogger };
    logger.log(5, "FYI");
    logger.log(2, "Uhoh");
}

ジェネリックトレイト

トレイトも、型や関数と同じようにジェネリックにできます。トレイトのパラメータ には、使用時に具体的な型が与えられます。たとえば、From<T> トレイトは 型変換を定義するために使われます。

#![allow(unused)]
fn main() {
// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

pub trait From<T>: Sized {
    fn from(value: T) -> Self;
}
}

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
struct Foo(String);

impl From<u32> for Foo {
    fn from(from: u32) -> Foo {
        Foo(format!("Converted from integer: {from}"))
    }
}

impl From<bool> for Foo {
    fn from(from: bool) -> Foo {
        Foo(format!("Converted from bool: {from}"))
    }
}

fn main() {
    let from_int = Foo::from(123);
    let from_bool = Foo::from(true);
    dbg!(from_int);
    dbg!(from_bool);
}

impl Trait

トレイト境界と同様に、impl Trait 構文は関数の引数や戻り値で使用できます。

// 著作権 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

// 次の糖衣構文:
//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {
fn add_42_millions(x: impl Into<i32>) -> i32 {
    x.into() + 42_000_000
}

fn pair_of(x: u32) -> impl std::fmt::Debug {
    (x + 1, x - 1)
}

fn main() {
    let many = add_42_millions(42_i8);
    dbg!(many);
    let many_more = add_42_millions(10_000_000);
    dbg!(many_more);
    let debuggable = pair_of(27);
    dbg!(debuggable);
}

dyn Trait

ジェネリクスによる静的ディスパッチのためにトレイトを使うことに加えて、Rust はトレイトオブジェクトによる型消去された動的ディスパッチのためにトレイトを使うこともサポートしています。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Dog {
    name: String,
    age: i8,
}
struct Cat {
    lives: i8,
}

trait Pet {
    fn talk(&self) -> String;
}

impl Pet for Dog {
    fn talk(&self) -> String {
        format!("Woof, my name is {}!", self.name)
    }
}

impl Pet for Cat {
    fn talk(&self) -> String {
        String::from("Miau!")
    }
}

// ジェネリクスと静的ディスパッチを使用する。
fn generic(pet: &impl Pet) {
    println!("Hello, who are you? {}", pet.talk());
}

// 型消去と動的ディスパッチを使用する。
fn dynamic(pet: &dyn Pet) {
    println!("Hello, who are you? {}", pet.talk());
}

fn main() {
    let cat = Cat { lives: 9 };
    let dog = Dog { name: String::from("Fido"), age: 5 };

    generic(&cat);
    generic(&dog);

    dynamic(&cat);
    dynamic(&dog);
}

演習: ジェネリックな min

この短い演習では、Ord トレイトを使って 2 つの値の最小値を 決定するジェネリックな min 関数を実装します。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::cmp::Ordering;

// TODO: テストで使用される `min` 関数を実装する。

#[test]
fn integers() {
    assert_eq!(min(0, 10), 0);
    assert_eq!(min(500, 123), 123);
}

#[test]
fn chars() {
    assert_eq!(min('a', 'z'), 'a');
    assert_eq!(min('7', '1'), '1');
}

#[test]
fn strings() {
    assert_eq!(min("hello", "goodbye"), "goodbye");
    assert_eq!(min("bat", "armadillo"), "armadillo");
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::cmp::Ordering;

fn min<T: Ord>(l: T, r: T) -> T {
    match l.cmp(&r) {
        Ordering::Less | Ordering::Equal => l,
        Ordering::Greater => r,
    }
}

#[test]
fn integers() {
    assert_eq!(min(0, 10), 0);
    assert_eq!(min(500, 123), 123);
}

#[test]
fn chars() {
    assert_eq!(min('a', 'z'), 'a');
    assert_eq!(min('7', '1'), '1');
}

#[test]
fn strings() {
    assert_eq!(min("hello", "goodbye"), "goodbye");
    assert_eq!(min("bat", "armadillo"), "armadillo");
}

お帰りなさい

session outline

クロージャ

segment outline

クロージャの構文

クロージャは縦棒を使って作成します: |..| ..。

// 著作権 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    // 簡潔な構文では、引数と戻り値の型を推論できます:
    let double_it = |n| n * 2;
    dbg!(double_it(50));

    // あるいは、型を指定し、本体を波かっこで囲んで完全に明示的にできます:
    let add_1f32 = |x: f32| -> f32 { x + 1.0 };
    dbg!(add_1f32(50.));
}

キャプチャ

クロージャは、定義された環境から変数をキャプチャできます。

// 著作権 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let max_value = 5;
    let clamp = |v| {
        if v > max_value { max_value } else { v }
    };

    dbg!(clamp(1));
    dbg!(clamp(3));
    dbg!(clamp(5));
    dbg!(clamp(7));
    dbg!(clamp(10));
}

クロージャトレイト

クロージャまたはラムダ式の型には名前を付けられません。しかし、これらは 特別な Fn、 FnMut、および FnOnce トレイトを実装しています。

特別な型 fn(..) -> T は関数ポインタを表します。これは、関数のアドレス、 または何もキャプチャしないクロージャのいずれかです。

// 著作権 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn apply_and_log(
    func: impl FnOnce(&'static str) -> String,
    func_name: &'static str,
    input: &'static str,
) {
    println!("Calling {func_name}({input}): {}", func(input))
}

fn main() {
    let suffix = "-itis";
    let add_suffix = |x| format!("{x}{suffix}");
    apply_and_log(&add_suffix, "add_suffix", "senior");
    apply_and_log(&add_suffix, "add_suffix", "appendix");

    let mut v = Vec::new();
    let mut accumulate = |x| {
        v.push(x);
        v.join("/")
    };
    apply_and_log(&mut accumulate, "accumulate", "red");
    apply_and_log(&mut accumulate, "accumulate", "green");
    apply_and_log(&mut accumulate, "accumulate", "blue");

    let take_and_reverse = |prefix| {
        let mut acc = String::from(prefix);
        acc.push_str(&v.into_iter().rev().collect::<Vec<_>>().join("/"));
        acc
    };
    apply_and_log(take_and_reverse, "take_and_reverse", "reversed: ");
}

演習: ログフィルター

今朝作成したジェネリックなロガーをベースに、クロージャを使ってログメッセージをフィルタリングする Filter を実装してください。フィルタリング述語を通過したものは、内部のロガーに送信します。

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

pub trait Logger {
    /// Log a message at the given verbosity level.
    fn log(&self, verbosity: u8, message: &str);
}

struct StderrLogger;

impl Logger for StderrLogger {
    fn log(&self, verbosity: u8, message: &str) {
        eprintln!("verbosity={verbosity}: {message}");
    }
}

// TODO: `Filter` を定義して実装する。

fn main() {
    let logger = Filter::new(StderrLogger, |_verbosity, msg| msg.contains("yikes"));
    logger.log(5, "FYI");
    logger.log(1, "yikes, something went wrong");
    logger.log(2, "uhoh");
}

解答

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

pub trait Logger {
    /// Log a message at the given verbosity level.
    fn log(&self, verbosity: u8, message: &str);
}

struct StderrLogger;

impl Logger for StderrLogger {
    fn log(&self, verbosity: u8, message: &str) {
        eprintln!("verbosity={verbosity}: {message}");
    }
}

/// Only log messages matching a filtering predicate.
struct Filter<L, P> {
    inner: L,
    predicate: P,
}

impl<L, P> Filter<L, P>
where
    L: Logger,
    P: Fn(u8, &str) -> bool,
{
    fn new(inner: L, predicate: P) -> Self {
        Self { inner, predicate }
    }
}
impl<L, P> Logger for Filter<L, P>
where
    L: Logger,
    P: Fn(u8, &str) -> bool,
{
    fn log(&self, verbosity: u8, message: &str) {
        if (self.predicate)(verbosity, message) {
            self.inner.log(verbosity, message);
        }
    }
}

fn main() {
    let logger = Filter::new(StderrLogger, |_verbosity, msg| msg.contains("yikes"));
    logger.log(5, "FYI");
    logger.log(1, "yikes, something went wrong");
    logger.log(2, "uhoh");
}

• クロージャの格納: クロージャを構造体に格納するには、ジェネリック型 パラメータ（ここでは P）を使います。これは、Rust の各クロージャが コンパイラによって生成される一意の無名型を持つためです。
• Fn トレイト境界: 境界 P: Fn(u8, &str) -> bool は、P が 指定された引数と戻り値の型で関数として呼び出せることをコンパイラに 伝えます。log は &self を受け取るため、predicate には不変にしか アクセスできないので、Fn（FnMut や FnOnce ではなく）を使います。
• フィールドの呼び出し: (self.predicate)(...) を使ってクロージャを 呼び出します。self.predicate を囲む括弧は、predicate という名前の メソッド呼び出しとフィールド自体の呼び出しを区別するために必要です。

標準ライブラリの型

segment outline

標準ライブラリ

Rust には標準ライブラリが付属しており、Rust のライブラリやプログラムで使われる共通の型の集合を確立するのに役立ちます。これにより、2 つのライブラリは両方とも同じ String 型を使うため、円滑に連携できます。

実際、Rust の標準ライブラリには core、alloc、std という複数の層があります。

• core には、libc、アロケータ、さらにはオペレーティングシステムの存在にも依存しない、最も基本的な型と関数が含まれます。
• alloc には、Vec、Box、Arc など、グローバルなヒープアロケータを必要とする型が含まれます。
• 組み込み Rust アプリケーションは通常 core のみを使用し、ときには alloc も使用します。

ドキュメント

Rust には豊富なドキュメントがあります。たとえば次のようなものです。

• ループ に関するすべての詳細。
• u8 のようなプリミティブ型。
• Option や BinaryHeap のような標準ライブラリの型。

ドキュメントを表示するには、rustup doc --std または https://std.rs を使用します。

実際のところ、自分のコードにもドキュメントを付けることができます。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// 第1引数が第2引数で割り切れるかどうかを判定します。
///
/// 第2引数が 0 の場合、結果は false です。
fn is_divisible_by(lhs: u32, rhs: u32) -> bool {
    if rhs == 0 {
        return false;
    }
    lhs % rhs == 0
}

内容は Markdown として扱われます。公開されているすべての Rust ライブラリ crate は、 rustdoc ツールを使って docs.rs で自動的にドキュメント化されます。こうしたパターンを使って API のすべての public な要素をドキュメント化するのが Rust らしい書き方です。

要素の内側（たとえばモジュールの内側）から要素をドキュメント化するには、//! または /*! .. */ を使います。これらは「内部ドキュメントコメント」と呼ばれます。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! このモジュールには、整数の割り切りに関する機能が含まれています。

Option

すでに Option<T> の使用例をいくつか見てきました。これは、型 T の値、または何もない状態のいずれかを保持します。たとえば、 String::find は Option<usize> を返します。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let name = "Löwe 老虎 Léopard Gepardi";
    let mut position: Option<usize> = name.find('é');
    dbg!(position);
    assert_eq!(position.unwrap(), 14);
    position = name.find('Z');
    dbg!(position);
    assert_eq!(position.expect("Character not found"), 0);
}

Result

Result は Option に似ていますが、操作の成功または失敗を、それぞれ 異なる enum バリアントで表します。これはジェネリックで、Result<T, E> の形を取り、T は Ok バリアントで使われ、E は Err バリアントに現れます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::fs::File;
use std::io::Read;

fn main() {
    let file: Result<File, std::io::Error> = File::open("diary.txt");
    match file {
        Ok(mut file) => {
            let mut contents = String::new();
            if let Ok(bytes) = file.read_to_string(&mut contents) {
                println!("Dear diary: {contents} ({bytes} bytes)");
            } else {
                println!("Could not read file content");
            }
        }
        Err(err) => {
            println!("The diary could not be opened: {err}");
        }
    }
}

String

String は、拡張可能な UTF-8 エンコード文字列です:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut s1 = String::new();
    s1.push_str("Hello");
    println!("s1: len = {}, capacity = {}", s1.len(), s1.capacity());

    let mut s2 = String::with_capacity(s1.len() + 1);
    s2.push_str(&s1);
    s2.push('!');
    println!("s2: len = {}, capacity = {}", s2.len(), s2.capacity());

    let s3 = String::from("🇨🇭");
    println!("s3: len = {}, number of chars = {}", s3.len(), s3.chars().count());
}

String は Deref<Target = str> を実装しているため、String に対して str のすべてのメソッドを呼び出せます。

Vec

Vec は、標準のサイズ変更可能なヒープ割り当てバッファです:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut v1 = Vec::new();
    v1.push(42);
    println!("v1: len = {}, capacity = {}", v1.len(), v1.capacity());

    let mut v2 = Vec::with_capacity(v1.len() + 1);
    v2.extend(v1.iter());
    v2.push(9999);
    println!("v2: len = {}, capacity = {}", v2.len(), v2.capacity());

    // 要素を指定してベクタを初期化するための標準的なマクロ。
    let mut v3 = vec![0, 0, 1, 2, 3, 4];

    // 偶数の要素だけを保持する。
    v3.retain(|x| x % 2 == 0);
    println!("{v3:?}");

    // 連続する重複要素を削除する。
    v3.dedup();
    println!("{v3:?}");
}

Vec は Deref<Target = [T]> を実装しているため、Vec に対してスライスのメソッドを呼び出せます。

HashMap

HashDoS 攻撃に対する保護を備えた標準のハッシュマップ:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::collections::HashMap;

fn main() {
    let mut page_counts = HashMap::new();
    page_counts.insert("Adventures of Huckleberry Finn", 207);
    page_counts.insert("Grimms' Fairy Tales", 751);
    page_counts.insert("Pride and Prejudice", 303);

    if !page_counts.contains_key("Les Misérables") {
        println!(
            "We know about {} books, but not Les Misérables.",
            page_counts.len()
        );
    }

    for book in ["Pride and Prejudice", "Alice's Adventure in Wonderland"] {
        match page_counts.get(book) {
            Some(count) => println!("{book}: {count} pages"),
            None => println!("{book} is unknown."),
        }
    }

    // 何も見つからなかった場合に値を挿入するには、.entry() メソッドを使用します。
    for book in ["Pride and Prejudice", "Alice's Adventure in Wonderland"] {
        let page_count: &mut i32 = page_counts.entry(book).or_insert(0);
        *page_count += 1;
    }

    dbg!(page_counts);
}

演習: Counter

この演習では、非常に単純なデータ構造を取り上げて、それをジェネリックにします。 これは、 std::collections::HashMap を使って、どの値が現れたかと、それぞれが何回出現したかを追跡します。

Counter の初期バージョンは、u32 値でしか動作しないようにハードコードされています。 追跡する値の型に対して struct とそのメソッドをジェネリックにし、そのようにして Counter が任意の型の値を追跡できるようにしてください。

早く終わったら、 entry メソッドを使って、count メソッドの実装に必要なハッシュ検索の回数を半分にしてみてください。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::collections::HashMap;

/// Counter は、型 T の各値が現れた回数を数えます。
struct Counter {
    values: HashMap<u32, u64>,
}

impl Counter {
    /// 新しい Counter を作成します。
    fn new() -> Self {
        Counter {
            values: HashMap::new(),
        }
    }

    /// 指定された値の出現を数えます。
    fn count(&mut self, value: u32) {
        if self.values.contains_key(&value) {
            *self.values.get_mut(&value).unwrap() += 1;
        } else {
            self.values.insert(value, 1);
        }
    }

    /// 指定された値が現れた回数を返します。
    fn times_seen(&self, value: u32) -> u64 {
        self.values.get(&value).copied().unwrap_or_default()
    }
}

fn main() {
    let mut ctr = Counter::new();
    ctr.count(13);
    ctr.count(14);
    ctr.count(16);
    ctr.count(14);
    ctr.count(14);
    ctr.count(11);

    for i in 10..20 {
        println!("saw {} values equal to {}", ctr.times_seen(i), i);
    }

    let mut strctr = Counter::new();
    strctr.count("apple");
    strctr.count("orange");
    strctr.count("apple");
    println!("got {} apples", strctr.times_seen("apple"));
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::collections::HashMap;
use std::hash::Hash;

/// Counter counts the number of times each value of type T has been seen.
struct Counter<T> {
    values: HashMap<T, u64>,
}

impl<T: Eq + Hash> Counter<T> {
    /// Create a new Counter.
    fn new() -> Self {
        Counter { values: HashMap::new() }
    }

    /// Count an occurrence of the given value.
    fn count(&mut self, value: T) {
        *self.values.entry(value).or_default() += 1;
    }

    /// Return the number of times the given value has been seen.
    fn times_seen(&self, value: T) -> u64 {
        self.values.get(&value).copied().unwrap_or_default()
    }
}

fn main() {
    let mut ctr = Counter::new();
    ctr.count(13);
    ctr.count(14);
    ctr.count(16);
    ctr.count(14);
    ctr.count(14);
    ctr.count(11);

    for i in 10..20 {
        println!("saw {} values equal to {}", ctr.times_seen(i), i);
    }

    let mut strctr = Counter::new();
    strctr.count("apple");
    strctr.count("orange");
    strctr.count("apple");
    println!("got {} apples", strctr.times_seen("apple"));
}

標準ライブラリのトレイト

segment outline

比較

これらのトレイトは値同士の比較をサポートします。これらのトレイトを実装するフィールドを含む型では、これらのトレイトをすべて導出できます。

PartialEq と Eq

PartialEq は部分同値関係であり、必須メソッド eq と、デフォルト実装されたメソッド ne を持ちます。== 演算子と != 演算子はこれらのメソッドを呼び出します。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Key {
    id: u32,
    metadata: Option<String>,
}
impl PartialEq for Key {
    fn eq(&self, other: &Self) -> bool {
        self.id == other.id
    }
}

Eq は完全な同値関係（反射的、対称的、推移的）であり、PartialEq を含意します。完全な同値関係を必要とする関数では、トレイト境界として Eq を使用します。

PartialOrd と Ord

PartialOrd は、partial_cmp メソッドを持つ半順序を定義します。これは <、<=、>=、> 演算子を実装するために使われます。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::cmp::Ordering;
#[derive(Eq, PartialEq)]
struct Citation {
    author: String,
    year: u32,
}
impl PartialOrd for Citation {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        match self.author.partial_cmp(&other.author) {
            Some(Ordering::Equal) => self.year.partial_cmp(&other.year),
            author_ord => author_ord,
        }
    }
}

Ord は、cmp が Ordering を返す全順序です。

演算子

演算子オーバーロードは std::ops のトレイトを通じて実装されます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug, Copy, Clone)]
struct Point {
    x: i32,
    y: i32,
}

impl std::ops::Add for Point {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        Self { x: self.x + other.x, y: self.y + other.y }
    }
}

fn main() {
    let p1 = Point { x: 10, y: 20 };
    let p2 = Point { x: 100, y: 200 };
    println!("{p1:?} + {p2:?} = {:?}", p1 + p2);
}

From と Into

型は From と Into を実装して、型変換を容易にします。 as とは異なり、これらのトレイトは情報を失わず、失敗しない変換に対応します。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let s = String::from("hello");
    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);
    let one = i16::from(true);
    let bigger = i32::from(123_i16);
    println!("{s}, {addr}, {one}, {bigger}");
}

From が実装されると、Into は自動的に実装されます。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let s: String = "hello".into();
    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();
    let one: i16 = true.into();
    let bigger: i32 = 123_i16.into();
    println!("{s}, {addr}, {one}, {bigger}");
}

キャスト

Rust には 暗黙的な 型変換はありませんが、as による明示的なキャストはサポートされています。これらは、定義されている範囲では一般に C のセマンティクスに従います。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let value: i64 = 1000;
    println!("as u16: {}", value as u16);
    println!("as i16: {}", value as i16);
    println!("as u8: {}", value as u8);
}

as の結果は Rust では 常に 定義されており、プラットフォーム間で一貫しています。これは、符号を変えたり、より小さい型にキャストしたりする場合の直感に合わないことがあります。ドキュメントを確認し、明確にするためのコメントを添えてください。

as によるキャストは比較的鋭利なツールで、誤って使いやすく、将来の保守作業で使用される型や型内の値の範囲が変わると、微妙なバグの原因になり得ます。キャストは、無条件の切り捨てを意図していることを示したい場合にのみ使うのが最善です（たとえば、高位ビットに何が入っているかに関係なく、u64 の下位 32 ビットを as u32 で選択する場合）。

失敗しないキャスト（たとえば u32 から u64）では、そのキャストが実際に失敗しないことを明確にするため、as よりも From や Into を使うことを優先してください。失敗する可能性のあるキャストでは、収まるものと収まらないものを分けて扱いたい場合に TryFrom と TryInto を利用できます。

Read と Write

Read と BufRead を使うと、u8 のソースを抽象化できます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::io::{BufRead, BufReader, Read, Result};

fn count_lines<R: Read>(reader: R) -> usize {
    let buf_reader = BufReader::new(reader);
    buf_reader.lines().count()
}

fn main() -> Result<()> {
    let slice: &[u8] = b"foo\nbar\nbaz\n";
    println!("lines in slice: {}", count_lines(slice));

    let file = std::fs::File::open(std::env::current_exe()?)?;
    println!("lines in file: {}", count_lines(file));
    Ok(())
}

同様に、Write を使うと u8 のシンクを抽象化できます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::io::{Result, Write};

fn log<W: Write>(writer: &mut W, msg: &str) -> Result<()> {
    writer.write_all(msg.as_bytes())?;
    writer.write_all("\n".as_bytes())
}

fn main() -> Result<()> {
    let mut buffer = Vec::new();
    log(&mut buffer, "Hello")?;
    log(&mut buffer, "World")?;
    println!("Logged: {buffer:?}");
    Ok(())
}

Default トレイト

Default トレイトは、型のデフォルト値を生成します。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug, Default)]
struct Derived {
    x: u32,
    y: String,
    z: Implemented,
}

#[derive(Debug)]
struct Implemented(String);

impl Default for Implemented {
    fn default() -> Self {
        Self("John Smith".into())
    }
}

fn main() {
    let default_struct = Derived::default();
    dbg!(default_struct);

    let almost_default_struct =
        Derived { y: "Y is set!".into(), ..Derived::default() };
    dbg!(almost_default_struct);

    let nothing: Option<Derived> = None;
    dbg!(nothing.unwrap_or_default());
}

演習: ROT13

この例では、古典的な “ROT13” 暗号 を実装します。このコードを プレイグラウンドにコピーし、不足している部分を実装してください。結果が引き続き有効な UTF-8 になるように、ASCII の英字のみを回転させてください。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::io::Read;

struct RotDecoder<R: Read> {
    input: R,
    rot: u8,
}

// `RotDecoder` に対して `Read` トレイトを実装します。

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn joke() {
        let mut rot =
            RotDecoder { input: "Gb trg gb gur bgure fvqr!".as_bytes(), rot: 13 };
        let mut result = String::new();
        rot.read_to_string(&mut result).unwrap();
        assert_eq!(&result, "To get to the other side!");
    }

    #[test]
    fn binary() {
        let input: Vec<u8> = (0..=255u8).collect();
        let mut rot = RotDecoder::<&[u8]> { input: input.as_slice(), rot: 13 };
        let mut buf = [0u8; 256];
        assert_eq!(rot.read(&mut buf).unwrap(), 256);
        for i in 0..=255 {
            if input[i] != buf[i] {
                assert!(input[i].is_ascii_alphabetic());
                assert!(buf[i].is_ascii_alphabetic());
            }
        }
    }
}

それぞれ 13 文字回転する 2 つの RotDecoder インスタンスを連結すると、何が起こるでしょうか？

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::io::Read;

struct RotDecoder<R: Read> {
    input: R,
    rot: u8,
}

impl<R: Read> Read for RotDecoder<R> {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
        let size = self.input.read(buf)?;
        for b in &mut buf[..size] {
            if b.is_ascii_alphabetic() {
                let base = if b.is_ascii_uppercase() { 'A' } else { 'a' } as u8;
                *b = (*b - base + self.rot) % 26 + base;
            }
        }
        Ok(size)
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn joke() {
        let mut rot =
            RotDecoder { input: "Gb trg gb gur bgure fvqr!".as_bytes(), rot: 13 };
        let mut result = String::new();
        rot.read_to_string(&mut result).unwrap();
        assert_eq!(&result, "To get to the other side!");
    }

    #[test]
    fn binary() {
        let input: Vec<u8> = (0..=255u8).collect();
        let mut rot = RotDecoder::<&[u8]> { input: input.as_slice(), rot: 13 };
        let mut buf = [0u8; 256];
        assert_eq!(rot.read(&mut buf).unwrap(), 256);
        for i in 0..=255 {
            if input[i] != buf[i] {
                assert!(input[i].is_ascii_alphabetic());
                assert!(buf[i].is_ascii_alphabetic());
            }
        }
    }
}

Day 3 へようこそ

これで、コアとなる言語機能をすべて見てきました。

• 基礎: 基本的な型、制御フロー、関数、データ構造。
• パターンマッチング: データを効果的に分解すること。
• ポリモーフィズム: メソッド、Trait、Generics。
• 標準ライブラリ: Option、Result、Vec、 String のような重要な型を使うこと。
• クロージャ: 環境をキャプチャできる無名関数。

あらゆる型を記述し、それに振る舞いを関連付けることができます。ここからは視点を切り替えて、 これらの概念をメモリ管理とシステム設計に適用していきます。

スケジュール

session outline

メモリ管理

segment outline

プログラムメモリのレビュー

プログラムは 2 つの方法でメモリを割り当てます:

• スタック: ローカル変数のための連続したメモリ領域。

  • 値のサイズは固定で、コンパイル時にわかります。
  • 非常に高速: スタックポインタを動かすだけです。
  • 管理が容易: 関数呼び出しに従います。
  • メモリ局所性が高いです。

• ヒープ: 関数呼び出しの外にある値を格納する領域。

  • 値のサイズは動的で、実行時に決まります。
  • スタックよりわずかに低速: 多少の管理処理が必要です。
  • メモリ局所性は保証されません。

例

String を作成すると、固定サイズのメタデータはスタックに、動的なサイズの データ、つまり実際の文字列はヒープに配置されます:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let s1 = String::from("Hello");
}

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut s1 = String::from("Hello");
    s1.push(' ');
    s1.push_str("world");
    // 家でこれを試さないでください！教育目的のみです。
    // String はそのレイアウトについて何の保証もしないため、これにより
    // 未定義動作が発生する可能性があります。
    unsafe {
        let (capacity, ptr, len): (usize, usize, usize) = std::mem::transmute(s1);
        println!("capacity = {capacity}, ptr = {ptr:#x}, len = {len}");
    }
}

メモリ管理のアプローチ

従来、言語は大まかに 2 つのカテゴリに分けられてきました。

• 手動メモリ管理による完全な制御: C, C++, Pascal, …
  • プログラマが、いつヒープメモリを割り当てたり解放したりするかを決めます。
  • ポインタが依然として有効なメモリを指しているかどうかを、プログラマが判断しなければなりません。
  • 研究が示すように、プログラマはミスを犯します。
• 実行時の自動メモリ管理による完全な安全性: Java, Python, Go, Haskell, …
  • ランタイムシステムが、メモリが参照できなくなるまで解放されないことを 保証します。
  • 通常は、参照カウントまたはガベージコレクションで実装されます。

Rust は新たな組み合わせを提供します。

正しいメモリ管理をコンパイル時に強制することによる、完全な制御 と 安全性。

これは、明示的な所有権の概念によって実現されています。

所有権

すべての変数束縛には、それが有効な スコープ があり、そのスコープ外で変数を使用するとエラーになります。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Point(i32, i32);

fn main() {
    {
        let p = Point(3, 4);
        dbg!(p.0);
    }
    dbg!(p.1);
}

その変数がその値を 所有している と言います。すべての Rust の値には、常にちょうど 1 つの所有者がいます。

スコープの終わりで、変数は ドロップ され、データは解放されます。ここではデストラクタが実行され、リソースを解放できます。

ムーブセマンティクス

代入を行うと、変数間で_所有権_が移動します：

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let s1 = String::from("Hello!");
    let s2 = s1;
    dbg!(s2);
    // dbg!(s1);
}

• s1 から s2 への代入によって所有権が移動します。
• s1 がスコープを抜けても、何も起こりません。何も所有していないためです。
• s2 がスコープを抜けると、文字列データは解放されます。

s2 へムーブする前：

s2 へムーブした後：

関数に値を渡すと、その値は関数 パラメータに代入されます。これにより所有権が移動します：

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn say_hello(name: String) {
    println!("Hello {name}")
}

fn main() {
    let name = String::from("Alice");
    say_hello(name);
    // say_hello(name);
}

std::string s1 = "Cpp";
std::string s2 = s1;  // s1 のデータを複製する。

Clone

ときには、値のコピーを 作りたくなる ことがあります。Clone トレイトはこれを実現します。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn say_hello(name: String) {
    println!("Hello {name}")
}

fn main() {
    let name = String::from("Alice");
    say_hello(name.clone());
    say_hello(name);
}

Copy型

ムーブセマンティクスがデフォルトですが、特定の型はデフォルトでコピーされます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let x = 42;
    let y = x;
    dbg!(x); // Copy でなければアクセスできない
    dbg!(y);
}

これらの型は Copy トレイトを実装しています。

自分で定義した型でも、コピーセマンティクスを使うようにオプトインできます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Copy, Clone, Debug)]
struct Point(i32, i32);

fn main() {
    let p1 = Point(3, 4);
    let p2 = p1;
    println!("p1: {p1:?}");
    println!("p2: {p2:?}");
}

• 代入後、p1 と p2 はどちらもそれぞれのデータを所有します。
• また、p1.clone() を使ってデータを明示的にコピーすることもできます。

Drop トレイト

Drop を実装する値は、スコープを抜けるときに実行するコードを指定できます:

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Droppable {
    name: &'static str,
}

impl Drop for Droppable {
    fn drop(&mut self) {
        println!("Dropping {}", self.name);
    }
}

fn main() {
    let a = Droppable { name: "a" };
    {
        let b = Droppable { name: "b" };
        {
            let c = Droppable { name: "c" };
            let d = Droppable { name: "d" };
            println!("Exiting innermost block");
        }
        println!("Exiting next block");
    }
    drop(a);
    println!("Exiting main");
}

演習: ビルダー型

この例では、すべてのデータを所有する複雑なデータ型を実装します。 新しい値を便利な関数を使って少しずつ構築できるようにするために、「ビルダーパターン」を使用します。

欠けている部分を埋めてください。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
enum Language {
    Rust,
    Java,
    Perl,
}

#[derive(Clone, Debug)]
struct Dependency {
    name: String,
    version_expression: String,
}

/// A representation of a software package.
#[derive(Debug)]
struct Package {
    name: String,
    version: String,
    authors: Vec<String>,
    dependencies: Vec<Dependency>,
    language: Option<Language>,
}

impl Package {
    /// Return a representation of this package as a dependency, for use in
    /// building other packages.
    fn as_dependency(&self) -> Dependency {
        todo!("1")
    }
}

/// A builder for a Package. Use `build()` to create the `Package` itself.
struct PackageBuilder(Package);

impl PackageBuilder {
    fn new(name: impl Into<String>) -> Self {
        todo!("2")
    }

    /// Set the package version.
    fn version(mut self, version: impl Into<String>) -> Self {
        self.0.version = version.into();
        self
    }

    /// Set the package authors.
    fn authors(mut self, authors: Vec<String>) -> Self {
        todo!("3")
    }

    /// Add an additional dependency.
    fn dependency(mut self, dependency: Dependency) -> Self {
        todo!("4")
    }

    /// Set the language. If not set, language defaults to None.
    fn language(mut self, language: Language) -> Self {
        todo!("5")
    }

    fn build(self) -> Package {
        self.0
    }
}

fn main() {
    let base64 = PackageBuilder::new("base64").version("0.13").build();
    dbg!(&base64);
    let log =
        PackageBuilder::new("log").version("0.4").language(Language::Rust).build();
    dbg!(&log);
    let serde = PackageBuilder::new("serde")
        .authors(vec!["djmitche".into()])
        .version(String::from("4.0"))
        .dependency(base64.as_dependency())
        .dependency(log.as_dependency())
        .build();
    dbg!(serde);
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
enum Language {
    Rust,
    Java,
    Perl,
}

#[derive(Clone, Debug)]
struct Dependency {
    name: String,
    version_expression: String,
}

/// A representation of a software package.
#[derive(Debug)]
struct Package {
    name: String,
    version: String,
    authors: Vec<String>,
    dependencies: Vec<Dependency>,
    language: Option<Language>,
}

impl Package {
    /// Return a representation of this package as a dependency, for use in
    /// building other packages.
    fn as_dependency(&self) -> Dependency {
        Dependency {
            name: self.name.clone(),
            version_expression: self.version.clone(),
        }
    }
}

/// A builder for a Package. Use `build()` to create the `Package` itself.
struct PackageBuilder(Package);

impl PackageBuilder {
    fn new(name: impl Into<String>) -> Self {
        Self(Package {
            name: name.into(),
            version: "0.1".into(),
            authors: Vec::new(),
            dependencies: Vec::new(),
            language: None,
        })
    }

    /// Set the package version.
    fn version(mut self, version: impl Into<String>) -> Self {
        self.0.version = version.into();
        self
    }

    /// Set the package authors.
    fn authors(mut self, authors: Vec<String>) -> Self {
        self.0.authors = authors;
        self
    }

    /// Add an additional dependency.
    fn dependency(mut self, dependency: Dependency) -> Self {
        self.0.dependencies.push(dependency);
        self
    }

    /// Set the language. If not set, language defaults to None.
    fn language(mut self, language: Language) -> Self {
        self.0.language = Some(language);
        self
    }

    fn build(self) -> Package {
        self.0
    }
}

fn main() {
    let base64 = PackageBuilder::new("base64").version("0.13").build();
    dbg!(&base64);
    let log =
        PackageBuilder::new("log").version("0.4").language(Language::Rust).build();
    dbg!(&log);
    let serde = PackageBuilder::new("serde")
        .authors(vec!["djmitche".into()])
        .version(String::from("4.0"))
        .dependency(base64.as_dependency())
        .dependency(log.as_dependency())
        .build();
    dbg!(serde);
}

スマートポインタ

segment outline

Box<T>

Box は、ヒープ上のデータを指す所有ポインタ です:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let five = Box::new(5);
    println!("five: {}", *five);
}

Box<T> は Deref<Target = T> を実装しているため、 T のメソッドを Box<T> に対して直接呼び出せます。

再帰的なデータ型や動的なサイズを持つデータ型は、ポインタによる間接参照なしでは インラインに格納できません。Box はその間接参照を実現します:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
enum List<T> {
    /// 空でないリスト: 最初の要素と残りのリスト。
    Element(T, Box<List<T>>),
    /// 空のリスト。
    Nil,
}

fn main() {
    let list: List<i32> =
        List::Element(1, Box::new(List::Element(2, Box::new(List::Nil))));
    println!("{list:?}");
}

Rc

Rc は参照カウント方式の共有ポインタです。複数の場所から同じデータを参照 する必要がある場合に使用します:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::rc::Rc;

fn main() {
    let a = Rc::new(10);
    let b = Rc::clone(&a);

    dbg!(a);
    dbg!(b);
}

各 Rc は、強参照と弱参照、および値を含む同じ共有データ構造を 指します:

• マルチスレッドのコンテキストでは Arc と Mutex を参照して ください。
• 共有ポインタを Weak ポインタへ ダウングレード して、適切に ドロップされる循環参照を作成できます。

所有権を持つトレイトオブジェクト

前に、トレイトオブジェクトを参照とともに使用する方法、たとえば &dyn Pet を見ました。 しかし、Box のようなスマートポインタとトレイトオブジェクトを組み合わせて使用し、 所有権を持つトレイトオブジェクト Box<dyn Pet> を作ることもできます。

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Dog {
    name: String,
    age: i8,
}
struct Cat {
    lives: i8,
}

trait Pet {
    fn talk(&self) -> String;
}

impl Pet for Dog {
    fn talk(&self) -> String {
        format!("ワン、私の名前は{}です！", self.name)
    }
}

impl Pet for Cat {
    fn talk(&self) -> String {
        String::from("ニャー！")
    }
}

fn main() {
    let pets: Vec<Box<dyn Pet>> = vec![
        Box::new(Cat { lives: 9 }),
        Box::new(Dog { name: String::from("Fido"), age: 5 }),
    ];
    for pet in pets {
        println!("こんにちは、あなたは誰ですか？ {}", pet.talk());
    }
}

pets を割り当てた後のメモリレイアウト:

演習: 二分木

二分木は、すべてのノードが 2 つの子ノード（左と右）を持つ木構造の データ構造です。各ノードが値を格納する木を作成します。あるノード N について、N の左部分木にあるすべてのノードはより小さい値を含み、N の右部分木にあるすべてのノードはより大きい値を含みます。ある値は木に 1 回だけ格納されるものとします。つまり、重複するノードはありません。

次の型を実装して、与えられたテストが通るようにしてください。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// A node in the binary tree.
#[derive(Debug)]
struct Node<T: Ord> {
    value: T,
    left: Subtree<T>,
    right: Subtree<T>,
}

/// A possibly-empty subtree.
#[derive(Debug)]
struct Subtree<T: Ord>(Option<Box<Node<T>>>);

/// A container storing a set of values, using a binary tree.
///
/// If the same value is added multiple times, it is only stored once.
#[derive(Debug)]
pub struct BinaryTree<T: Ord> {
    root: Subtree<T>,
}

impl<T: Ord> BinaryTree<T> {
    fn new() -> Self {
        Self { root: Subtree::new() }
    }

    fn insert(&mut self, value: T) {
        self.root.insert(value);
    }

    fn has(&self, value: &T) -> bool {
        self.root.has(value)
    }

    fn len(&self) -> usize {
        self.root.len()
    }
}

// `Node` の `new` を実装してください。
// `Subtree` の `new`、`insert`、`len`、`has` を実装してください。

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn len() {
        let mut tree = BinaryTree::new();
        assert_eq!(tree.len(), 0);
        tree.insert(2);
        assert_eq!(tree.len(), 1);
        tree.insert(1);
        assert_eq!(tree.len(), 2);
        tree.insert(2); // not a unique item
        assert_eq!(tree.len(), 2);
        tree.insert(3);
        assert_eq!(tree.len(), 3);
    }

    #[test]
    fn has() {
        let mut tree = BinaryTree::new();
        fn check_has(tree: &BinaryTree<i32>, exp: &[bool]) {
            let got: Vec<bool> =
                (0..exp.len()).map(|i| tree.has(&(i as i32))).collect();
            assert_eq!(&got, exp);
        }

        check_has(&tree, &[false, false, false, false, false]);
        tree.insert(0);
        check_has(&tree, &[true, false, false, false, false]);
        tree.insert(4);
        check_has(&tree, &[true, false, false, false, true]);
        tree.insert(4);
        check_has(&tree, &[true, false, false, false, true]);
        tree.insert(3);
        check_has(&tree, &[true, false, false, true, true]);
    }

    #[test]
    fn unbalanced() {
        let mut tree = BinaryTree::new();
        for i in 0..100 {
            tree.insert(i);
        }
        assert_eq!(tree.len(), 100);
        assert!(tree.has(&50));
    }
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::cmp::Ordering;

/// A node in the binary tree.
#[derive(Debug)]
struct Node<T: Ord> {
    value: T,
    left: Subtree<T>,
    right: Subtree<T>,
}

/// A possibly-empty subtree.
#[derive(Debug)]
struct Subtree<T: Ord>(Option<Box<Node<T>>>);

/// A container storing a set of values, using a binary tree.
///
/// If the same value is added multiple times, it is only stored once.
#[derive(Debug)]
pub struct BinaryTree<T: Ord> {
    root: Subtree<T>,
}

impl<T: Ord> BinaryTree<T> {
    fn new() -> Self {
        Self { root: Subtree::new() }
    }

    fn insert(&mut self, value: T) {
        self.root.insert(value);
    }

    fn has(&self, value: &T) -> bool {
        self.root.has(value)
    }

    fn len(&self) -> usize {
        self.root.len()
    }
}

impl<T: Ord> Subtree<T> {
    fn new() -> Self {
        Self(None)
    }

    fn insert(&mut self, value: T) {
        match &mut self.0 {
            None => self.0 = Some(Box::new(Node::new(value))),
            Some(n) => match value.cmp(&n.value) {
                Ordering::Less => n.left.insert(value),
                Ordering::Equal => {}
                Ordering::Greater => n.right.insert(value),
            },
        }
    }

    fn has(&self, value: &T) -> bool {
        match &self.0 {
            None => false,
            Some(n) => match value.cmp(&n.value) {
                Ordering::Less => n.left.has(value),
                Ordering::Equal => true,
                Ordering::Greater => n.right.has(value),
            },
        }
    }

    fn len(&self) -> usize {
        match &self.0 {
            None => 0,
            Some(n) => 1 + n.left.len() + n.right.len(),
        }
    }
}

impl<T: Ord> Node<T> {
    fn new(value: T) -> Self {
        Self { value, left: Subtree::new(), right: Subtree::new() }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn len() {
        let mut tree = BinaryTree::new();
        assert_eq!(tree.len(), 0);
        tree.insert(2);
        assert_eq!(tree.len(), 1);
        tree.insert(1);
        assert_eq!(tree.len(), 2);
        tree.insert(2); // not a unique item
        assert_eq!(tree.len(), 2);
        tree.insert(3);
        assert_eq!(tree.len(), 3);
    }

    #[test]
    fn has() {
        let mut tree = BinaryTree::new();
        fn check_has(tree: &BinaryTree<i32>, exp: &[bool]) {
            let got: Vec<bool> =
                (0..exp.len()).map(|i| tree.has(&(i as i32))).collect();
            assert_eq!(&got, exp);
        }

        check_has(&tree, &[false, false, false, false, false]);
        tree.insert(0);
        check_has(&tree, &[true, false, false, false, false]);
        tree.insert(4);
        check_has(&tree, &[true, false, false, false, true]);
        tree.insert(4);
        check_has(&tree, &[true, false, false, false, true]);
        tree.insert(3);
        check_has(&tree, &[true, false, false, true, true]);
    }

    #[test]
    fn unbalanced() {
        let mut tree = BinaryTree::new();
        for i in 0..100 {
            tree.insert(i);
        }
        assert_eq!(tree.len(), 100);
        assert!(tree.has(&50));
    }
}

お帰りなさい

session outline

借用

segment outline

値の借用

前に見たように、関数を呼び出すときに所有権を移動する代わりに、 関数にその値を 借用 させることができます：

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
struct Point(i32, i32);

fn add(p1: &Point, p2: &Point) -> Point {
    Point(p1.0 + p2.0, p1.1 + p2.1)
}

fn main() {
    let p1 = Point(3, 4);
    let p2 = Point(10, 20);
    let p3 = add(&p1, &p2);
    println!("{p1:?} + {p2:?} = {p3:?}");
}

• add 関数は 2 つのポイントを 借用 し、新しいポイントを返します。
• 呼び出し元は入力の所有権を保持します。

借用チェック

Rust の 借用チェッカー は、値を借用する方法に制約を課します。 参照が、それが借用している値を 超えて生存する ことはできないことは、すでに見ました。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let x_ref = {
        let x = 10;
        &x
    };
    dbg!(x_ref);
}

借用チェッカーが強制する、もう 1 つの主要なルールもあります。エイリアシング ルールです。ある値については、どの時点でも次のいずれか一方のみが成り立ちます。

• その値への共有参照を 1 つ以上持つことができる、または
• その値への排他的参照をちょうど 1 つだけ持つことができます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut a = 10;
    let b = &a;

    {
        let c = &mut a;
        *c = 20;
    }

    dbg!(a);
    dbg!(b);
}

借用エラー

これらの借用ルールがどのようにメモリエラーを防ぐのかを示す具体例として、その要素への参照がある状態でコレクションを変更するケースを考えてみましょう:

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];
    let elem = &vec[2];
    vec.push(6);
    dbg!(elem);
}

同様に、イテレータの無効化のケースを考えてみましょう:

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut vec = vec![1, 2, 3, 4, 5];
    for elem in &vec {
        vec.push(elem * 2);
    }
}

内部可変性

状況によっては、共有（読み取り専用）参照の背後にあるデータを変更する必要があります。たとえば、共有データ構造が内部キャッシュを持っていて、読み取り専用メソッドからそのキャッシュを更新したい場合があります。

「interior mutability」パターンでは、共有参照の背後で排他的（可変）アクセスを可能にします。標準ライブラリにはこれを実現する方法がいくつか用意されており、いずれも通常は実行時チェックを行うことで安全性を確保しています。

Cell

Cell は値をラップし、Cell への共有参照だけを使ってその値を取得または設定できるようにします。ただし、内部の値への参照は一切許可しません。参照が存在しないため、借用規則が破られることはありません。

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::cell::Cell;

fn main() {
    // `cell` は可変として宣言されていないことに注意してください。
    let cell = Cell::new(5);

    cell.set(123);
    dbg!(cell.get());
}

RefCell

RefCell は、実際には Rust の参照ではない &T/&mut T をエミュレートする代替型 Ref と RefMut を提供することで、ラップされた値へのアクセスと変更を可能にします。

これらの型は、RefCell 内のカウンターを使って動的チェックを行い、別の Ref/RefMut と同時に RefMut が存在しないようにします。

Deref（RefMut については DerefMut も）を実装することで、これらの型は参照を外へ逃がすことなく、内部の値に対してメソッドを呼び出せます。

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::cell::RefCell;

fn main() {
    // `cell` は可変として宣言されていないことに注意してください。
    let cell = RefCell::new(5);

    {
        let mut cell_ref = cell.borrow_mut();
        *cell_ref = 123;

        // これは実行時エラーを引き起こします。
        // let other = cell.borrow();
        // println!("{}", other);
    }

    println!("{cell:?}");
}

演習: 魔法使いのインベントリ

この演習では、借用と所有権について学んだことを使って、魔法使いのインベントリを管理します。

• 魔法使いは呪文のコレクションを持っています。インベントリに呪文を追加する関数と、その中の呪文を唱える関数を実装する必要があります。

• 呪文には使用回数の上限があります。呪文の残り使用回数がなくなったら、それを魔法使いのインベントリから削除しなければなりません。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Spell {
    name: String,
    cost: u32,
    uses: u32,
}

struct Wizard {
    spells: Vec<Spell>,
    mana: u32,
}

impl Wizard {
    fn new(mana: u32) -> Self {
        Wizard { spells: vec![], mana }
    }

    // TODO: `add_spell` を実装して、呪文の所有権を受け取り、それを
    // 魔法使いのインベントリに追加する。
    fn add_spell(..., spell: ...) {
        todo!()
    }

    // TODO: インベントリから呪文を借用して唱えるように
    // `cast_spell` を実装する。魔法使いのマナは呪文のコスト分だけ減り、
    // 呪文の使用回数は 1 減少するべきです。
    //
    // 魔法使いのマナが足りない場合、呪文は失敗するべきです。
    // 呪文の残り使用回数がない場合は、インベントリから削除されます。
    fn cast_spell(..., name: ...) {
        todo!()
    }
}

fn main() {
    let mut merlin = Wizard::new(100);
    let fireball = Spell { name: String::from("Fireball"), cost: 10, uses: 2 };
    let ice_blast = Spell { name: String::from("Ice Blast"), cost: 15, uses: 1 };

    merlin.add_spell(fireball);
    merlin.add_spell(ice_blast);

    merlin.cast_spell("Fireball"); // Casts successfully
    merlin.cast_spell("Ice Blast"); // Casts successfully, then removed
    merlin.cast_spell("Ice Blast"); // Fails (not found)
    merlin.cast_spell("Fireball"); // Casts successfully, then removed
    merlin.cast_spell("Fireball"); // Fails (not found)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_spell() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 5, uses: 3 };
        wizard.add_spell(spell);
        assert_eq!(wizard.spells.len(), 1);
    }

    #[test]
    fn test_cast_spell() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 5, uses: 3 };
        wizard.add_spell(spell);

        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 5);
        assert_eq!(wizard.spells.len(), 1);
        assert_eq!(wizard.spells[0].uses, 2);
    }

    #[test]
    fn test_cast_spell_insufficient_mana() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 15, uses: 3 };
        wizard.add_spell(spell);

        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 10);
        assert_eq!(wizard.spells.len(), 1);
        assert_eq!(wizard.spells[0].uses, 3);
    }

    #[test]
    fn test_cast_spell_not_found() {
        let mut wizard = Wizard::new(10);
        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 10);
    }

    #[test]
    fn test_cast_spell_removal() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 5, uses: 1 };
        wizard.add_spell(spell);

        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 5);
        assert_eq!(wizard.spells.len(), 0);
    }
}

解答: 魔法使いの持ち物

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Spell {
    name: String,
    cost: u32,
    uses: u32,
}

struct Wizard {
    spells: Vec<Spell>,
    mana: u32,
}

impl Wizard {
    fn new(mana: u32) -> Self {
        Wizard { spells: vec![], mana }
    }

    fn add_spell(&mut self, spell: Spell) {
        self.spells.push(spell);
    }

    fn cast_spell(&mut self, name: &str) {
        let mut spell_idx = None;
        for idx in 0..self.spells.len() {
            if self.spells[idx].name == name {
                spell_idx = Some(idx);
                break;
            }
        }

        let Some(idx) = spell_idx else {
            println!("Spell {} not found!", name);
            return;
        };

        let spell = &mut self.spells[idx];
        if self.mana >= spell.cost {
            self.mana -= spell.cost;
            spell.uses -= 1;
            println!(
                "Casting {}! Mana left: {}. Uses left: {}",
                spell.name, self.mana, spell.uses
            );
            if spell.uses == 0 {
                self.spells.remove(idx);
            }
        } else {
            println!("Not enough mana to cast {}!", spell.name);
        }
    }
}

fn main() {
    let mut merlin = Wizard::new(100);
    let fireball = Spell { name: String::from("Fireball"), cost: 10, uses: 2 };
    let ice_blast = Spell { name: String::from("Ice Blast"), cost: 15, uses: 1 };

    merlin.add_spell(fireball);
    merlin.add_spell(ice_blast);

    merlin.cast_spell("Fireball"); // Casts successfully
    merlin.cast_spell("Ice Blast"); // Casts successfully, then removed
    merlin.cast_spell("Ice Blast"); // Fails (not found)
    merlin.cast_spell("Fireball"); // Casts successfully, then removed
    merlin.cast_spell("Fireball"); // Fails (not found)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_spell() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 5, uses: 3 };
        wizard.add_spell(spell);
        assert_eq!(wizard.spells.len(), 1);
    }

    #[test]
    fn test_cast_spell() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 5, uses: 3 };
        wizard.add_spell(spell);

        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 5);
        assert_eq!(wizard.spells.len(), 1);
        assert_eq!(wizard.spells[0].uses, 2);
    }

    #[test]
    fn test_cast_spell_insufficient_mana() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 15, uses: 3 };
        wizard.add_spell(spell);

        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 10);
        assert_eq!(wizard.spells.len(), 1);
        assert_eq!(wizard.spells[0].uses, 3);
    }

    #[test]
    fn test_cast_spell_not_found() {
        let mut wizard = Wizard::new(10);
        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 10);
    }

    #[test]
    fn test_cast_spell_removal() {
        let mut wizard = Wizard::new(10);
        let spell = Spell { name: String::from("Fireball"), cost: 5, uses: 1 };
        wizard.add_spell(spell);

        wizard.cast_spell("Fireball");
        assert_eq!(wizard.mana, 5);
        assert_eq!(wizard.spells.len(), 0);
    }
}

ライフタイム

segment outline

関数での借用

借用チェックの一環として、コンパイラは借用が関数にどのように流入し、 どのように流出するかを推論する必要があります。最も単純な場合、借用は 関数呼び出しの間だけ存続します:

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn borrows(x: &i32) {
    dbg!(x);
}

fn main() {
    let mut val = 123;

    // 関数呼び出しのために `val` を借用する。
    borrows(&val);

    // 借用は終了し、自由に変更できる。
    val += 5;
}

借用を返す

しかし、関数に参照を返させることもできます！これは、借用が関数から呼び出し元へ戻ってくることを意味します:

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn identity(x: &i32) -> &i32 {
    x
}

fn main() {
    let mut x = 123;

    let out = identity(&x);

    // x = 5; // 🛠️❌ `x` はまだ借用されています！

    dbg!(out);
}

複数の借用

では、複数の借用が関数に渡され、そのうち 1 つが返される場合はどうでしょうか？

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn multiple(a: &i32, b: &i32) -> &i32 {
    todo!("Return either `a` or `b`")
}

fn main() {
    let mut a = 5;
    let mut b = 10;

    let r = multiple(&a, &b);

    // どちらがまだ借用されているのでしょうか？
    // どちらの変更も許可されるべきでしょうか？
    a += 7;
    b += 7;

    dbg!(r);
}

両方を借用する

このケースでは、a または b のいずれかが返される可能性のある関数があります。この場合、ライフタイム注釈を使って、両方の借用が戻り値に流れ込む可能性があることをコンパイラに伝えます。

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn pick<'a>(c: bool, a: &'a i32, b: &'a i32) -> &'a i32 {
    if c { a } else { b }
}

fn main() {
    let mut a = 5;
    let mut b = 10;

    let r = pick(true, &a, &b);

    // どちらがまだ借用されているでしょうか？
    // どちらかの変更は許可されるべきでしょうか？
    // a += 7;
    // b += 7;

    dbg!(r);
}

1 つを借用する

この例では find_nearest は複数の借用を受け取りますが、そのうち 1 つだけを返します。ライフタイム注釈により、返される借用が対応する引数の借用に明示的に結び付けられています。

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
struct Point(i32, i32);

/// `points` から `query` に最も近い点を探します。
/// `points` には少なくとも 1 つの点があると仮定します。
fn find_nearest<'a>(points: &'a [Point], query: &Point) -> &'a Point {
    fn cab_distance(p1: &Point, p2: &Point) -> i32 {
        (p1.0 - p2.0).abs() + (p1.1 - p2.1).abs()
    }

    let mut nearest = None;
    for p in points {
        if let Some((_, nearest_dist)) = nearest {
            let dist = cab_distance(p, query);
            if dist < nearest_dist {
                nearest = Some((p, dist));
            }
        } else {
            nearest = Some((p, cab_distance(p, query)));
        };
    }

    nearest.map(|(p, _)| p).unwrap()
    // query // 代わりにこれを行うとどうなりますか？
}

fn main() {
    let points = &[Point(1, 0), Point(1, 0), Point(-1, 0), Point(0, -1)];
    let query = Point(0, 2);
    let nearest = find_nearest(points, &query);

    // この時点では、`query` は借用されていません。
    drop(query);

    dbg!(nearest);
}

ライフタイム省略

関数の引数と戻り値のライフタイムは完全に指定されている必要がありますが、Rust では多くの場合、 いくつかの単純なルール によってライフタイムを省略できます。 これは推論ではなく、単なる構文上の省略記法です。

• ライフタイム注釈を持たない各引数には、ライフタイムが 1 つ与えられます。
• 引数のライフタイムが 1 つしかない場合、そのライフタイムが注釈のないすべての戻り値に与えられます。
• 引数のライフタイムが複数ある場合でも、最初のものが self に対するものであれば、そのライフタイムが注釈のないすべての戻り値に与えられます。

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn only_args(a: &i32, b: &i32) {
    todo!();
}

fn identity(a: &i32) -> &i32 {
    a
}

struct Foo(i32);
impl Foo {
    fn get(&self, other: &i32) -> &i32 {
        &self.0
    }
}

データ構造におけるライフタイム

データ型が借用データを保持する場合は、ライフタイム注釈を付ける必要があります。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
enum HighlightColor {
    Pink,
    Yellow,
}

#[derive(Debug)]
struct Highlight<'document> {
    slice: &'document str,
    color: HighlightColor,
}

fn main() {
    let doc = String::from("The quick brown fox jumps over the lazy dog.");
    let noun = Highlight { slice: &doc[16..19], color: HighlightColor::Yellow };
    let verb = Highlight { slice: &doc[20..25], color: HighlightColor::Pink };
    // drop(doc);
    dbg!(noun);
    dbg!(verb);
}

演習: Protobuf のパース

この演習では、protobuf バイナリエンコーディングの パーサーを作成します。心配はいりません。見た目ほど複雑ではありません！これは、データのスライスを受け渡す一般的なパース パターンを示しています。基になるデータ自体がコピーされることはありません。

protobuf メッセージを完全にパースするには、フィールド番号で索引付けされた各フィールドの型を 知っている必要があります。これは通常 proto ファイルで提供されます。この 演習では、その情報を、各フィールドごとに呼び出される関数内の match 文に 埋め込みます。

次の proto を使います。

message PhoneNumber {
  optional string number = 1;
  optional string type = 2;
}

message Person {
  optional string name = 1;
  optional int32 id = 2;
  repeated PhoneNumber phones = 3;
}

メッセージ

proto メッセージは、フィールドが 1 つずつ順番に並んだものとしてエンコードされます。各フィールドは 「tag」とそれに続く値で実装されます。tag にはフィールド番号 （たとえば、Person メッセージの id フィールドなら 2）と、バイトストリームから ペイロードをどのように決定すべきかを定義するワイヤー型が含まれます。これらは 1 つの整数にまとめられ、以下の unpack_tag でデコードされます。

Varint

tag を含む整数は、VARINT と呼ばれる可変長エンコーディングで表現されます。 幸い、parse_varint は以下で定義済みです。

ワイヤー型

Proto ではいくつかのワイヤー型が定義されていますが、この演習で使うのはそのうち 2 つだけです。

Varint ワイヤー型には 1 つの varint が含まれ、Person.id のような int32 型の proto 値をエンコードするために使われます。

Len ワイヤー型には、varint で表現された長さと、それに続くそのバイト数の ペイロードが含まれます。これは、Person.name のような string 型の proto 値を エンコードするために使われます。また、Person.phones のようにサブメッセージを 含む proto 値のエンコードにも使われ、その場合ペイロードにはサブメッセージの エンコーディングが含まれます。

演習

与えられたコードでは、Person と PhoneNumber のフィールドを処理するコールバックと、 メッセージをパースしてそれらのコールバック呼び出し列に変換する処理も定義されています。

あなたに残されているのは、parse_field 関数と、Person および PhoneNumber に対する ProtoMessage トレイトを実装することです。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// A wire type as seen on the wire.
enum WireType {
    /// The Varint WireType indicates the value is a single VARINT.
    Varint,
    // The I64 WireType indicates that the value is precisely 8 bytes in
    // little-endian order containing a 64-bit signed integer or double type.
    //I64,  -- not needed for this exercise
    /// The Len WireType indicates that the value is a length represented as a
    /// VARINT followed by exactly that number of bytes.
    Len,
    // The I32 WireType indicates that the value is precisely 4 bytes in
    // little-endian order containing a 32-bit signed integer or float type.
    //I32,  -- not needed for this exercise
}

#[derive(Debug)]
/// A field's value, typed based on the wire type.
enum FieldValue<'a> {
    Varint(u64),
    //I64(i64),  -- not needed for this exercise
    Len(&'a [u8]),
    //I32(i32),  -- not needed for this exercise
}

#[derive(Debug)]
/// A field, containing the field number and its value.
struct Field<'a> {
    field_num: u64,
    value: FieldValue<'a>,
}

trait ProtoMessage<'a>: Default {
    fn add_field(&mut self, field: Field<'a>);
}

impl From<u64> for WireType {
    fn from(value: u64) -> Self {
        match value {
            0 => WireType::Varint,
            //1 => WireType::I64,  -- not needed for this exercise
            2 => WireType::Len,
            //5 => WireType::I32,  -- not needed for this exercise
            _ => panic!("Invalid wire type: {value}"),
        }
    }
}

impl<'a> FieldValue<'a> {
    fn as_str(&self) -> &'a str {
        let FieldValue::Len(data) = self else {
            panic!("Expected string to be a `Len` field");
        };
        std::str::from_utf8(data).expect("Invalid string")
    }

    fn as_bytes(&self) -> &'a [u8] {
        let FieldValue::Len(data) = self else {
            panic!("Expected bytes to be a `Len` field");
        };
        data
    }

    fn as_u64(&self) -> u64 {
        let FieldValue::Varint(value) = self else {
            panic!("Expected `u64` to be a `Varint` field");
        };
        *value
    }
}

/// Parse a VARINT, returning the parsed value and the remaining bytes.
fn parse_varint(data: &[u8]) -> (u64, &[u8]) {
    for i in 0..7 {
        let Some(b) = data.get(i) else {
            panic!("Not enough bytes for varint");
        };
        if b & 0x80 == 0 {
            // This is the last byte of the VARINT, so convert it to
            // a u64 and return it.
            let mut value = 0u64;
            for b in data[..=i].iter().rev() {
                value = (value << 7) | (b & 0x7f) as u64;
            }
            return (value, &data[i + 1..]);
        }
    }

    // More than 7 bytes is invalid.
    panic!("Too many bytes for varint");
}

/// Convert a tag into a field number and a WireType.
fn unpack_tag(tag: u64) -> (u64, WireType) {
    let field_num = tag >> 3;
    let wire_type = WireType::from(tag & 0x7);
    (field_num, wire_type)
}


/// Parse a field, returning the remaining bytes
fn parse_field(data: &[u8]) -> (Field<'_>, &[u8]) {
    let (tag, remainder) = parse_varint(data);
    let (field_num, wire_type) = unpack_tag(tag);
    let (fieldvalue, remainder) = match wire_type {
        _ => todo!("ワイヤータイプに応じて、フィールドを構築し、必要な量のバイトを消費します。")
    };
    todo!("フィールドと、未消費のバイトを返します。")
}

/// Parse a message in the given data, calling `T::add_field` for each field in
/// the message.
///
/// The entire input is consumed.
fn parse_message<'a, T: ProtoMessage<'a>>(mut data: &'a [u8]) -> T {
    let mut result = T::default();
    while !data.is_empty() {
        let parsed = parse_field(data);
        result.add_field(parsed.0);
        data = parsed.1;
    }
    result
}

#[derive(Debug, Default)]
struct PhoneNumber<'a> {
    number: &'a str,
    type_: &'a str,
}

#[derive(Debug, Default)]
struct Person<'a> {
    name: &'a str,
    id: u64,
    phone: Vec<PhoneNumber<'a>>,
}

// TODO: Person と PhoneNumber に対して ProtoMessage を実装する。

#[test]
fn test_id() {
    let person_id: Person = parse_message(&[0x10, 0x2a]);
    assert_eq!(person_id, Person { name: "", id: 42, phone: vec![] });
}

#[test]
fn test_name() {
    let person_name: Person = parse_message(&[
        0x0a, 0x0e, 0x62, 0x65, 0x61, 0x75, 0x74, 0x69, 0x66, 0x75, 0x6c, 0x20,
        0x6e, 0x61, 0x6d, 0x65,
    ]);
    assert_eq!(person_name, Person { name: "beautiful name", id: 0, phone: vec![] });
}

#[test]
fn test_just_person() {
    let person_name_id: Person =
        parse_message(&[0x0a, 0x04, 0x45, 0x76, 0x61, 0x6e, 0x10, 0x16]);
    assert_eq!(person_name_id, Person { name: "Evan", id: 22, phone: vec![] });
}

#[test]
fn test_phone() {
    let phone: Person = parse_message(&[
        0x0a, 0x00, 0x10, 0x00, 0x1a, 0x16, 0x0a, 0x0e, 0x2b, 0x31, 0x32, 0x33,
        0x34, 0x2d, 0x37, 0x37, 0x37, 0x2d, 0x39, 0x30, 0x39, 0x30, 0x12, 0x04,
        0x68, 0x6f, 0x6d, 0x65,
    ]);
    assert_eq!(
        phone,
        Person {
            name: "",
            id: 0,
            phone: vec![PhoneNumber { number: "+1234-777-9090", type_: "home" },],
        }
    );
}

// Put that all together into a single parse.
#[test]
fn test_full_person() {
    let person: Person = parse_message(&[
        0x0a, 0x07, 0x6d, 0x61, 0x78, 0x77, 0x65, 0x6c, 0x6c, 0x10, 0x2a, 0x1a,
        0x16, 0x0a, 0x0e, 0x2b, 0x31, 0x32, 0x30, 0x32, 0x2d, 0x35, 0x35, 0x35,
        0x2d, 0x31, 0x32, 0x31, 0x32, 0x12, 0x04, 0x68, 0x6f, 0x6d, 0x65, 0x1a,
        0x18, 0x0a, 0x0e, 0x2b, 0x31, 0x38, 0x30, 0x30, 0x2d, 0x38, 0x36, 0x37,
        0x2d, 0x35, 0x33, 0x30, 0x38, 0x12, 0x06, 0x6d, 0x6f, 0x62, 0x69, 0x6c,
        0x65,
    ]);
    assert_eq!(
        person,
        Person {
            name: "maxwell",
            id: 42,
            phone: vec![
                PhoneNumber { number: "+1202-555-1212", type_: "home" },
                PhoneNumber { number: "+1800-867-5308", type_: "mobile" },
            ]
        }
    );
}

解答

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// A wire type as seen on the wire.
enum WireType {
    /// The Varint WireType indicates the value is a single VARINT.
    Varint,
    // The I64 WireType indicates that the value is precisely 8 bytes in
    // little-endian order containing a 64-bit signed integer or double type.
    //I64,  -- not needed for this exercise
    /// The Len WireType indicates that the value is a length represented as a
    /// VARINT followed by exactly that number of bytes.
    Len,
    // The I32 WireType indicates that the value is precisely 4 bytes in
    // little-endian order containing a 32-bit signed integer or float type.
    //I32,  -- not needed for this exercise
}

#[derive(Debug)]
/// A field's value, typed based on the wire type.
enum FieldValue<'a> {
    Varint(u64),
    //I64(i64),  -- not needed for this exercise
    Len(&'a [u8]),
    //I32(i32),  -- not needed for this exercise
}

#[derive(Debug)]
/// A field, containing the field number and its value.
struct Field<'a> {
    field_num: u64,
    value: FieldValue<'a>,
}

trait ProtoMessage<'a>: Default {
    fn add_field(&mut self, field: Field<'a>);
}

impl From<u64> for WireType {
    fn from(value: u64) -> Self {
        match value {
            0 => WireType::Varint,
            //1 => WireType::I64,  -- not needed for this exercise
            2 => WireType::Len,
            //5 => WireType::I32,  -- not needed for this exercise
            _ => panic!("Invalid wire type: {value}"),
        }
    }
}

impl<'a> FieldValue<'a> {
    fn as_str(&self) -> &'a str {
        let FieldValue::Len(data) = self else {
            panic!("Expected string to be a `Len` field");
        };
        std::str::from_utf8(data).expect("Invalid string")
    }

    fn as_bytes(&self) -> &'a [u8] {
        let FieldValue::Len(data) = self else {
            panic!("Expected bytes to be a `Len` field");
        };
        data
    }

    fn as_u64(&self) -> u64 {
        let FieldValue::Varint(value) = self else {
            panic!("Expected `u64` to be a `Varint` field");
        };
        *value
    }
}

/// Parse a VARINT, returning the parsed value and the remaining bytes.
fn parse_varint(data: &[u8]) -> (u64, &[u8]) {
    for i in 0..7 {
        let Some(b) = data.get(i) else {
            panic!("Not enough bytes for varint");
        };
        if b & 0x80 == 0 {
            // This is the last byte of the VARINT, so convert it to
            // a u64 and return it.
            let mut value = 0u64;
            for b in data[..=i].iter().rev() {
                value = (value << 7) | (b & 0x7f) as u64;
            }
            return (value, &data[i + 1..]);
        }
    }

    // More than 7 bytes is invalid.
    panic!("Too many bytes for varint");
}

/// Convert a tag into a field number and a WireType.
fn unpack_tag(tag: u64) -> (u64, WireType) {
    let field_num = tag >> 3;
    let wire_type = WireType::from(tag & 0x7);
    (field_num, wire_type)
}

/// Parse a field, returning the remaining bytes
fn parse_field(data: &[u8]) -> (Field<'_>, &[u8]) {
    let (tag, remainder) = parse_varint(data);
    let (field_num, wire_type) = unpack_tag(tag);
    let (fieldvalue, remainder) = match wire_type {
        WireType::Varint => {
            let (value, remainder) = parse_varint(remainder);
            (FieldValue::Varint(value), remainder)
        }
        WireType::Len => {
            let (len, remainder) = parse_varint(remainder);
            let len = len as usize; // cast for simplicity
            let (value, remainder) = remainder.split_at(len);
            (FieldValue::Len(value), remainder)
        }
    };
    (Field { field_num, value: fieldvalue }, remainder)
}

/// Parse a message in the given data, calling `T::add_field` for each field in
/// the message.
///
/// The entire input is consumed.
fn parse_message<'a, T: ProtoMessage<'a>>(mut data: &'a [u8]) -> T {
    let mut result = T::default();
    while !data.is_empty() {
        let parsed = parse_field(data);
        result.add_field(parsed.0);
        data = parsed.1;
    }
    result
}

#[derive(PartialEq)]
#[derive(Debug, Default)]
struct PhoneNumber<'a> {
    number: &'a str,
    type_: &'a str,
}

#[derive(PartialEq)]
#[derive(Debug, Default)]
struct Person<'a> {
    name: &'a str,
    id: u64,
    phone: Vec<PhoneNumber<'a>>,
}

impl<'a> ProtoMessage<'a> for Person<'a> {
    fn add_field(&mut self, field: Field<'a>) {
        match field.field_num {
            1 => self.name = field.value.as_str(),
            2 => self.id = field.value.as_u64(),
            3 => self.phone.push(parse_message(field.value.as_bytes())),
            _ => {} // skip everything else
        }
    }
}

impl<'a> ProtoMessage<'a> for PhoneNumber<'a> {
    fn add_field(&mut self, field: Field<'a>) {
        match field.field_num {
            1 => self.number = field.value.as_str(),
            2 => self.type_ = field.value.as_str(),
            _ => {} // skip everything else
        }
    }
}

#[test]
fn test_id() {
    let person_id: Person = parse_message(&[0x10, 0x2a]);
    assert_eq!(person_id, Person { name: "", id: 42, phone: vec![] });
}

#[test]
fn test_name() {
    let person_name: Person = parse_message(&[
        0x0a, 0x0e, 0x62, 0x65, 0x61, 0x75, 0x74, 0x69, 0x66, 0x75, 0x6c, 0x20,
        0x6e, 0x61, 0x6d, 0x65,
    ]);
    assert_eq!(person_name, Person { name: "beautiful name", id: 0, phone: vec![] });
}

#[test]
fn test_just_person() {
    let person_name_id: Person =
        parse_message(&[0x0a, 0x04, 0x45, 0x76, 0x61, 0x6e, 0x10, 0x16]);
    assert_eq!(person_name_id, Person { name: "Evan", id: 22, phone: vec![] });
}

#[test]
fn test_phone() {
    let phone: Person = parse_message(&[
        0x0a, 0x00, 0x10, 0x00, 0x1a, 0x16, 0x0a, 0x0e, 0x2b, 0x31, 0x32, 0x33,
        0x34, 0x2d, 0x37, 0x37, 0x37, 0x2d, 0x39, 0x30, 0x39, 0x30, 0x12, 0x04,
        0x68, 0x6f, 0x6d, 0x65,
    ]);
    assert_eq!(
        phone,
        Person {
            name: "",
            id: 0,
            phone: vec![PhoneNumber { number: "+1234-777-9090", type_: "home" },],
        }
    );
}

// Put that all together into a single parse.
#[test]
fn test_full_person() {
    let person: Person = parse_message(&[
        0x0a, 0x07, 0x6d, 0x61, 0x78, 0x77, 0x65, 0x6c, 0x6c, 0x10, 0x2a, 0x1a,
        0x16, 0x0a, 0x0e, 0x2b, 0x31, 0x32, 0x30, 0x32, 0x2d, 0x35, 0x35, 0x35,
        0x2d, 0x31, 0x32, 0x31, 0x32, 0x12, 0x04, 0x68, 0x6f, 0x6d, 0x65, 0x1a,
        0x18, 0x0a, 0x0e, 0x2b, 0x31, 0x38, 0x30, 0x30, 0x2d, 0x38, 0x36, 0x37,
        0x2d, 0x35, 0x33, 0x30, 0x38, 0x12, 0x06, 0x6d, 0x6f, 0x62, 0x69, 0x6c,
        0x65,
    ]);
    assert_eq!(
        person,
        Person {
            name: "maxwell",
            id: 42,
            phone: vec![
                PhoneNumber { number: "+1202-555-1212", type_: "home" },
                PhoneNumber { number: "+1800-867-5308", type_: "mobile" },
            ]
        }
    );
}

Day 4 へようこそ

ここまでで、コア言語とその独自の安全性モデルを習得しました:

• 基礎と抽象化: トレイト、ジェネリクス、標準ライブラリ。
• 所有権: ムーブセマンティクスと Drop トレイト。
• メモリ管理: 借用規則（& と &mut）およびライフタイム。
• スマートポインタ: 複雑なデータ構造のための Box、Rc、RefCell。

これで、Rust がコンパイル時にどのようにメモリ安全性を保証するのかを理解できました！今日は、この知識を 適用して堅牢で大規模なアプリケーションを構築することに焦点を当てます。

スケジュール

session outline

イテレータ

segment outline

イテレータが必要な理由

配列の内容を反復処理したい場合は、次を定義する必要があります。

• 反復処理のどこまで進んでいるかを追跡するための状態。たとえば インデックス。
• 反復処理がいつ終了するかを判定する条件。
• ループごとに反復状態を更新するロジック。
• その反復状態を使って各要素を取得するロジック。

C スタイルの for ループでは、これらを直接宣言します。

for (int i = 0; i < array_len; i += 1) {
    int elem = array[i];
}

Rust では、この状態とロジックをまとめて「イテレータ」と呼ばれる オブジェクトにします。

for (int *ptr = array; ptr < array + len; ptr += 1) {
    int elem = *ptr;
}

Iterator トレイト

Iterator トレイトは、オブジェクトを値のシーケンスを生成するためにどのように使用できるかを定義します。たとえば、スライスの要素を生成できるイテレータを作成したい場合、次のようになります。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct SliceIter<'s> {
    slice: &'s [i32],
    i: usize,
}

impl<'s> Iterator for SliceIter<'s> {
    type Item = &'s i32;

    fn next(&mut self) -> Option<Self::Item> {
        if self.i == self.slice.len() {
            None
        } else {
            let next = &self.slice[self.i];
            self.i += 1;
            Some(next)
        }
    }
}

fn main() {
    let slice = &[2, 4, 6, 8];
    let iter = SliceIter { slice, i: 0 };
    for elem in iter {
        dbg!(elem);
    }
}

Iterator のヘルパーメソッド

イテレータがどのように振る舞うかを定義する next メソッドに加えて、 Iterator トレイトは、カスタマイズされたイテレータを構築するために使える 70 個以上のヘルパーメソッドを提供します。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let result: i32 = (1..=10) // 1 から 10 までの範囲を作成する
        .filter(|x| x % 2 == 0) // 偶数のみを保持する
        .map(|x| x * x) // 各数を二乗する
        .sum(); // 二乗したすべての数を合計する

    println!("The sum of squares of even numbers from 1 to 10 is: {}", result);
}

collect

collect メソッドを使うと、Iterator からコレクションを構築できます。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let primes = vec![2, 3, 5, 7];
    let prime_squares = primes.into_iter().map(|p| p * p).collect::<Vec<_>>();
    println!("prime_squares: {prime_squares:?}");
}

IntoIterator

Iterator トレイトは、イテレータを作成したあとでどのように イテレートするか を示します。関連するトレイト IntoIterator は、ある型に対するイテレータの作成方法を定義します。これは for ループで自動的に使われます。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

struct Grid {
    x_coords: Vec<u32>,
    y_coords: Vec<u32>,
}

impl IntoIterator for Grid {
    type Item = (u32, u32);
    type IntoIter = GridIter;
    fn into_iter(self) -> GridIter {
        GridIter { grid: self, i: 0, j: 0 }
    }
}

struct GridIter {
    grid: Grid,
    i: usize,
    j: usize,
}

impl Iterator for GridIter {
    type Item = (u32, u32);

    fn next(&mut self) -> Option<(u32, u32)> {
        if self.i >= self.grid.x_coords.len() {
            self.i = 0;
            self.j += 1;
            if self.j >= self.grid.y_coords.len() {
                return None;
            }
        }
        let res = Some((self.grid.x_coords[self.i], self.grid.y_coords[self.j]));
        self.i += 1;
        res
    }
}

fn main() {
    let grid = Grid { x_coords: vec![3, 5, 7, 9], y_coords: vec![10, 20, 30, 40] };
    for (x, y) in grid {
        println!("point = {x}, {y}");
    }
}

演習: Iterator メソッドのチェーン

この演習では、複雑な計算を実装するために、Iterator トレイトで提供されている メソッドのいくつかを見つけて使う必要があります。

次のコードを https://play.rust-lang.org/ にコピーして、テストが通るようにして ください。イテレータ式を使用し、その結果を collect して戻り値を構築してください。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// Calculate the differences between elements of `values` offset by `offset`,
/// wrapping around from the end of `values` to the beginning.
///
/// Element `n` of the result is `values[(n+offset)%len] - values[n]`.
fn offset_differences(offset: usize, values: Vec<i32>) -> Vec<i32> {
    todo!()
}

#[test]
fn test_offset_one() {
    assert_eq!(offset_differences(1, vec![1, 3, 5, 7]), vec![2, 2, 2, -6]);
    assert_eq!(offset_differences(1, vec![1, 3, 5]), vec![2, 2, -4]);
    assert_eq!(offset_differences(1, vec![1, 3]), vec![2, -2]);
}

#[test]
fn test_larger_offsets() {
    assert_eq!(offset_differences(2, vec![1, 3, 5, 7]), vec![4, 4, -4, -4]);
    assert_eq!(offset_differences(3, vec![1, 3, 5, 7]), vec![6, -2, -2, -2]);
    assert_eq!(offset_differences(4, vec![1, 3, 5, 7]), vec![0, 0, 0, 0]);
    assert_eq!(offset_differences(5, vec![1, 3, 5, 7]), vec![2, 2, 2, -6]);
}

#[test]
fn test_degenerate_cases() {
    assert_eq!(offset_differences(1, vec![0]), vec![0]);
    assert_eq!(offset_differences(1, vec![1]), vec![0]);
    let empty: Vec<i32> = vec![];
    assert_eq!(offset_differences(1, empty), vec![]);
}

解答

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// Calculate the differences between elements of `values` offset by `offset`,
/// wrapping around from the end of `values` to the beginning.
///
/// Element `n` of the result is `values[(n+offset)%len] - values[n]`.
fn offset_differences(offset: usize, values: Vec<i32>) -> Vec<i32> {
    let a = values.iter();
    let b = values.iter().cycle().skip(offset);
    a.zip(b).map(|(a, b)| *b - *a).collect()
}

#[test]
fn test_offset_one() {
    assert_eq!(offset_differences(1, vec![1, 3, 5, 7]), vec![2, 2, 2, -6]);
    assert_eq!(offset_differences(1, vec![1, 3, 5]), vec![2, 2, -4]);
    assert_eq!(offset_differences(1, vec![1, 3]), vec![2, -2]);
}

#[test]
fn test_larger_offsets() {
    assert_eq!(offset_differences(2, vec![1, 3, 5, 7]), vec![4, 4, -4, -4]);
    assert_eq!(offset_differences(3, vec![1, 3, 5, 7]), vec![6, -2, -2, -2]);
    assert_eq!(offset_differences(4, vec![1, 3, 5, 7]), vec![0, 0, 0, 0]);
    assert_eq!(offset_differences(5, vec![1, 3, 5, 7]), vec![2, 2, 2, -6]);
}

#[test]
fn test_degenerate_cases() {
    assert_eq!(offset_differences(1, vec![0]), vec![0]);
    assert_eq!(offset_differences(1, vec![1]), vec![0]);
    let empty: Vec<i32> = vec![];
    assert_eq!(offset_differences(1, empty), vec![]);
}

モジュール

segment outline

モジュール

impl ブロックを使うと、関数を型に紐づけて名前空間化できることを見てきました。

同様に、mod を使うと、型と関数を名前空間化できます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

mod foo {
    pub fn do_something() {
        println!("foo モジュール内");
    }
}

mod bar {
    pub fn do_something() {
        println!("bar モジュール内");
    }
}

fn main() {
    foo::do_something();
    bar::do_something();
}

ファイルシステム階層

モジュールの内容を省略すると、Rust はそれを別のファイル内で探します:

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

mod garden;

これにより、garden モジュールの内容が src/garden.rs にあることを Rust に伝えます。 同様に、garden::vegetables モジュールは src/garden/vegetables.rs にあります。

crate ルートは次の場所にあります:

• src/lib.rs（ライブラリ crate の場合）
• src/main.rs（バイナリ crate の場合）

ファイル内で定義されたモジュールも、「内部ドキュメントコメント」を使って文書化できます。 これらは、それを含むアイテムを文書化します。この場合はモジュールです。

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! このモジュールは garden を実装しており、高性能な発芽実装を含みます。

// このモジュールから型を再エクスポートします。
pub use garden::Garden;
pub use seeds::SeedPacket;

/// 指定された seed packet をまきます。
pub fn sow(seeds: Vec<SeedPacket>) {
    todo!()
}

/// 準備ができている garden 内の収穫物を収穫します。
pub fn harvest(garden: &mut Garden) {
    todo!()
}

可視性

モジュールはプライバシー境界です:

• モジュールのアイテムはデフォルトで非公開です（実装の詳細を隠します）。
• 親および兄弟のアイテムは常に可視です。
• 言い換えると、あるアイテムがモジュール foo で可視であれば、そのアイテムは foo のすべての子孫でも可視です。

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

mod outer {
    fn private() {
        println!("outer::private");
    }

    pub fn public() {
        println!("outer::public");
    }

    mod inner {
        fn private() {
            println!("outer::inner::private");
        }

        pub fn public() {
            println!("outer::inner::public");
            super::private();
        }
    }
}

fn main() {
    outer::public();
}

可視性とカプセル化

モジュール内のアイテムと同様に、struct のフィールドもデフォルトでは非公開です。非公開フィールドも同様に、そのモジュールの他の部分（子モジュールを含む）からは参照できます。これにより、struct の実装詳細をカプセル化し、外部から見えるデータや機能を制御できます。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

use outer::Foo;

mod outer {
    pub struct Foo {
        pub val: i32,
        is_big: bool,
    }

    impl Foo {
        pub fn new(val: i32) -> Self {
            Self { val, is_big: val > 100 }
        }
    }

    pub mod inner {
        use super::Foo;

        pub fn print_foo(foo: &Foo) {
            println!("Is {} big? {}", foo.val, foo.is_big);
        }
    }
}

fn main() {
    let foo = Foo::new(42);
    println!("foo.val = {}", foo.val);
    // let foo = Foo { val: 42, is_big: true };

    outer::inner::print_foo(&foo);
    // println!("Is {} big? {}", foo.val, foo.is_big);
}

use、super、self

モジュールは、use を使って別のモジュールのシンボルをスコープに取り込めます。通常、各モジュールの先頭には次のようなものがあります。

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::collections::HashSet;
use std::process::abort;

パス

パスは次のように解決されます。

1. 相対パスとして:

   • foo または self::foo は、現在のモジュール内の foo を参照します。
   • super::foo は、親モジュール内の foo を参照します。

2. 絶対パスとして:

   • crate::foo は、現在のクレートのルートにある foo を参照します。
   • bar::foo は、bar クレート内の foo を参照します。

演習: GUI ライブラリのモジュール

この演習では、小さな GUI ライブラリ実装を再編成します。この ライブラリは Widget トレイトと、そのトレイトのいくつかの実装、および main 関数を定義しています。

通常は、各型または密接に関連する型の集合ごとに専用の モジュールを用意するため、各ウィジェット型もそれぞれ専用のモジュールを 持つべきです。

Cargo のセットアップ

Rust playground は 1 つのファイルしかサポートしていないため、ローカルの ファイルシステム上に Cargo プロジェクトを作成する必要があります:

cargo init gui-modules
cd gui-modules
cargo run

生成された src/main.rs を編集して mod 文を追加し、src ディレクトリに追加のファイルを作成してください。

ソース

以下は、GUI ライブラリの単一モジュール実装です:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

pub trait Widget {
    /// Natural width of `self`.
    fn width(&self) -> usize;

    /// Draw the widget into a buffer.
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);

    /// Draw the widget on standard output.
    fn draw(&self) {
        let mut buffer = String::new();
        self.draw_into(&mut buffer);
        println!("{buffer}");
    }
}

pub struct Label {
    label: String,
}

impl Label {
    fn new(label: &str) -> Label {
        Label { label: label.to_owned() }
    }
}

pub struct Button {
    label: Label,
}

impl Button {
    fn new(label: &str) -> Button {
        Button { label: Label::new(label) }
    }
}

pub struct Window {
    title: String,
    widgets: Vec<Box<dyn Widget>>,
}

impl Window {
    fn new(title: &str) -> Window {
        Window { title: title.to_owned(), widgets: Vec::new() }
    }

    fn add_widget(&mut self, widget: Box<dyn Widget>) {
        self.widgets.push(widget);
    }

    fn inner_width(&self) -> usize {
        std::cmp::max(
            self.title.chars().count(),
            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),
        )
    }
}

impl Widget for Window {
    fn width(&self) -> usize {
        // Add 4 paddings for borders
        self.inner_width() + 4
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        let mut inner = String::new();
        for widget in &self.widgets {
            widget.draw_into(&mut inner);
        }

        let inner_width = self.inner_width();

        // TODO: Change draw_into to return Result<(), std::fmt::Error>. Then use the
        // ?-operator here instead of .unwrap().
        writeln!(buffer, "+-{:-<inner_width$}-+", "").unwrap();
        writeln!(buffer, "| {:^inner_width$} |", &self.title).unwrap();
        writeln!(buffer, "+={:=<inner_width$}=+", "").unwrap();
        for line in inner.lines() {
            writeln!(buffer, "| {:inner_width$} |", line).unwrap();
        }
        writeln!(buffer, "+-{:-<inner_width$}-+", "").unwrap();
    }
}

impl Widget for Button {
    fn width(&self) -> usize {
        self.label.width() + 8 // add a bit of padding
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        let width = self.width();
        let mut label = String::new();
        self.label.draw_into(&mut label);

        writeln!(buffer, "+{:-<width$}+", "").unwrap();
        for line in label.lines() {
            writeln!(buffer, "|{:^width$}|", &line).unwrap();
        }
        writeln!(buffer, "+{:-<width$}+", "").unwrap();
    }
}

impl Widget for Label {
    fn width(&self) -> usize {
        self.label.lines().map(|line| line.chars().count()).max().unwrap_or(0)
    }

    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        writeln!(buffer, "{}", &self.label).unwrap();
    }
}

fn main() {
    let mut window = Window::new("Rust GUI Demo 1.23");
    window.add_widget(Box::new(Label::new("This is a small text GUI demo.")));
    window.add_widget(Box::new(Button::new("Click me!")));
    window.draw();
}

解答

src
├── main.rs
├── widgets
│   ├── button.rs
│   ├── label.rs
│   └── window.rs
└── widgets.rs

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// ---- src/widgets.rs ----
pub use button::Button;
pub use label::Label;
pub use window::Window;

mod button;
mod label;
mod window;

pub trait Widget {
    /// `self` の自然幅。
    fn width(&self) -> usize;

    /// ウィジェットをバッファに描画します。
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);

    /// ウィジェットを標準出力に描画します。
    fn draw(&self) {
        let mut buffer = String::new();
        self.draw_into(&mut buffer);
        println!("{buffer}");
    }
}

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// ---- src/widgets/label.rs ----
use super::Widget;

pub struct Label {
    label: String,
}

impl Label {
    pub fn new(label: &str) -> Label {
        Label { label: label.to_owned() }
    }
}

impl Widget for Label {
    fn width(&self) -> usize {
        // ANCHOR_END: Label-width
        self.label.lines().map(|line| line.chars().count()).max().unwrap_or(0)
    }

    // ANCHOR: Label-draw_into
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        // ANCHOR_END: Label-draw_into
        writeln!(buffer, "{}", &self.label).unwrap();
    }
}

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// ---- src/widgets/button.rs ----
use super::{Label, Widget};

pub struct Button {
    label: Label,
}

impl Button {
    pub fn new(label: &str) -> Button {
        Button { label: Label::new(label) }
    }
}

impl Widget for Button {
    fn width(&self) -> usize {
        // ANCHOR_END: Button-width
        self.label.width() + 8 // 少しパディングを追加する
    }

    // ANCHOR: Button-draw_into
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        // ANCHOR_END: Button-draw_into
        let width = self.width();
        let mut label = String::new();
        self.label.draw_into(&mut label);

        writeln!(buffer, "+{:-<width$}+", "").unwrap();
        for line in label.lines() {
            writeln!(buffer, "|{:^width$}|", &line).unwrap();
        }
        writeln!(buffer, "+{:-<width$}+", "").unwrap();
    }
}

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// ---- src/widgets/window.rs ----
use super::Widget;

pub struct Window {
    title: String,
    widgets: Vec<Box<dyn Widget>>,
}

impl Window {
    pub fn new(title: &str) -> Window {
        Window { title: title.to_owned(), widgets: Vec::new() }
    }

    pub fn add_widget(&mut self, widget: Box<dyn Widget>) {
        self.widgets.push(widget);
    }

    fn inner_width(&self) -> usize {
        std::cmp::max(
            self.title.chars().count(),
            self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),
        )
    }
}

impl Widget for Window {
    fn width(&self) -> usize {
        // ANCHOR_END: Window-width
        // 枠線用に 4 文字分のパディングを追加する
        self.inner_width() + 4
    }

    // ANCHOR: Window-draw_into
    fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {
        // ANCHOR_END: Window-draw_into
        let mut inner = String::new();
        for widget in &self.widgets {
            widget.draw_into(&mut inner);
        }

        let inner_width = self.inner_width();

        // TODO: エラーハンドリングについて学んだ後で、
        // draw_into が Result<(), std::fmt::Error> を返すように変更できます。その後、
        // ここでは .unwrap() の代わりに ? 演算子を使えます。
        writeln!(buffer, "+-{:-<inner_width$}-+", "").unwrap();
        writeln!(buffer, "| {:^inner_width$} |", &self.title).unwrap();
        writeln!(buffer, "+={:=<inner_width$}=+", "").unwrap();
        for line in inner.lines() {
            writeln!(buffer, "| {:inner_width$} |", line).unwrap();
        }
        writeln!(buffer, "+-{:-<inner_width$}-+", "").unwrap();
    }
}

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// ---- src/main.rs ----
mod widgets;

use widgets::{Button, Label, Widget, Window};

fn main() {
    let mut window = Window::new("Rust GUI デモ 1.23");
    window.add_widget(Box::new(Label::new("これは小さなテキスト GUI デモです。")));
    window.add_widget(Box::new(Button::new("クリックして！")));
    window.draw();
}

テスト

segment outline

単体テスト

Rust と Cargo には、シンプルな単体テストフレームワークが付属しています。テストには #[test] を付けます。単体テストは、ネストされた tests モジュールに置かれることが多く、 #[cfg(test)] を使って、テストをビルドするときにだけ条件付きでコンパイルされるようにします。

// 著作権 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn first_word(text: &str) -> &str {
    match text.find(' ') {
        Some(idx) => &text[..idx],
        None => &text,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_empty() {
        assert_eq!(first_word(""), "");
    }

    #[test]
    fn test_single_word() {
        assert_eq!(first_word("Hello"), "Hello");
    }

    #[test]
    fn test_multiple_words() {
        assert_eq!(first_word("Hello World"), "Hello");
    }
}

• これにより、非公開のヘルパーを単体テストできます。
• #[cfg(test)] 属性は、cargo test を実行したときにのみ有効になります。

その他の種類のテスト

統合テスト

ライブラリをクライアントとしてテストしたい場合は、統合テストを使用します。

tests/ の下に .rs ファイルを作成します:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// tests/my_library.rs
use my_library::init;

#[test]
fn test_init() {
    assert!(init().is_ok());
}

これらのテストからアクセスできるのは、クレートの公開 API のみです。

ドキュメントテスト

Rust にはドキュメントテストのサポートが組み込まれています:

#![allow(unused)]
fn main() {
// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// 指定された長さに文字列を短縮します。
///
/// ```
/// # use playground::shorten_string;
/// assert_eq!(shorten_string("Hello World", 5), "Hello");
/// assert_eq!(shorten_string("Hello World", 20), "Hello World");
/// ```
pub fn shorten_string(s: &str, length: usize) -> &str {
    &s[..std::cmp::min(length, s.len())]
}
}

• /// コメント内のコードブロックは、自動的に Rust コードとして扱われます。
• そのコードは cargo test の一部としてコンパイルおよび実行されます。
• コード内に # を追加すると、ドキュメントでは非表示になりますが、 それでもコンパイルおよび実行されます。
• 上記のコードは Rust Playground で試してください。

コンパイラの lint と Clippy

Rust コンパイラは、優れたエラーメッセージに加えて、役立つ組み込み lint も生成します。Clippy はさらに多くの lint を提供し、 プロジェクトごとに有効化できるグループに整理されています。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[deny(clippy::cast_possible_truncation)]
fn main() {
    let mut x = 3;
    while (x < 70000) {
        x *= 2;
    }
    println!("X probably fits in a u16, right? {}", x as u16);
}

演習: Luhn アルゴリズム

Luhn algorithm は、クレジットカード番号を 検証するために使用されます。このアルゴリズムは文字列を入力として受け取り、クレジットカード番号を検証するために 次のことを行います。

• すべての空白を無視します。2 桁未満の数字は拒否します。文字や その他の数字以外の文字は拒否します。

• 右から左へ移動しながら、2 つおきの数字をすべて 2 倍します。数値 1234 では、3 と 1 を 2 倍します。数値 98765 では、6 と 8 を 2 倍します。

• 数字を 2 倍した後、結果が 9 より大きい場合はその桁を合計します。したがって、 7 を 2 倍すると 14 になり、これは 1 + 4 = 5 になります。

• 2 倍していない数字と 2 倍した数字をすべて合計します。

• 合計が 0 で終わる場合、そのクレジットカード番号は有効です。

提供されているコードには、Luhn アルゴリズムのバグのある実装と、 アルゴリズムの大部分が正しく実装されていることを確認する 2 つの基本的なユニットテストが 含まれています。

以下のコードを https://play.rust-lang.org/ にコピーし、追加のテストを作成して 提供されている実装のバグを明らかにし、見つけたバグを修正してください。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

pub fn luhn(cc_number: &str) -> bool {
    let mut sum = 0;
    let mut double = false;

    for c in cc_number.chars().rev() {
        if let Some(digit) = c.to_digit(10) {
            if double {
                let double_digit = digit * 2;
                sum +=
                    if double_digit > 9 { double_digit - 9 } else { double_digit };
            } else {
                sum += digit;
            }
            double = !double;
        } else {
            continue;
        }
    }

    sum % 10 == 0
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_valid_cc_number() {
        assert!(luhn("4263 9826 4026 9299"));
        assert!(luhn("4539 3195 0343 6467"));
        assert!(luhn("7992 7398 713"));
    }

    #[test]
    fn test_invalid_cc_number() {
        assert!(!luhn("4223 9826 4026 9299"));
        assert!(!luhn("4539 3195 0343 6476"));
        assert!(!luhn("8273 1232 7352 0569"));
    }
}

解答

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

pub fn luhn(cc_number: &str) -> bool {
    let mut sum = 0;
    let mut double = false;
    let mut digits = 0;

    for c in cc_number.chars().rev() {
        if let Some(digit) = c.to_digit(10) {
            digits += 1;
            if double {
                let double_digit = digit * 2;
                sum +=
                    if double_digit > 9 { double_digit - 9 } else { double_digit };
            } else {
                sum += digit;
            }
            double = !double;
        } else if c.is_whitespace() {
            // New: accept whitespace.
            continue;
        } else {
            // New: reject all other characters.
            return false;
        }
    }

    // New: check that we have at least two digits
    digits >= 2 && sum % 10 == 0
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_valid_cc_number() {
        assert!(luhn("4263 9826 4026 9299"));
        assert!(luhn("4539 3195 0343 6467"));
        assert!(luhn("7992 7398 713"));
    }

    #[test]
    fn test_invalid_cc_number() {
        assert!(!luhn("4223 9826 4026 9299"));
        assert!(!luhn("4539 3195 0343 6476"));
        assert!(!luhn("8273 1232 7352 0569"));
    }

    #[test]
    fn test_non_digit_cc_number() {
        assert!(!luhn("foo"));
        assert!(!luhn("foo 0 0"));
    }

    #[test]
    fn test_empty_cc_number() {
        assert!(!luhn(""));
        assert!(!luhn(" "));
        assert!(!luhn("  "));
        assert!(!luhn("    "));
    }

    #[test]
    fn test_single_digit_cc_number() {
        assert!(!luhn("0"));
    }

    #[test]
    fn test_two_digit_cc_number() {
        assert!(luhn(" 0 0 "));
    }
}

おかえりなさい

session outline

エラー処理

segment outline

パニック

致命的なランタイムエラーが発生すると、Rust は「パニック」を発生させます。

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let v = vec![10, 20, 30];
    dbg!(v[100]);
}

• パニックは、回復不能で予期しないエラーのためのものです。
  • パニックはプログラム内のバグの兆候です。
  • 境界チェックの失敗のようなランタイム障害は、パニックを引き起こすことがあります。
  • アサーション（assert! など）は、失敗するとパニックします。
  • 特定の目的でパニックさせるには、panic! マクロを使えます。
• パニックが発生するとスタックが「アンワインド」され、関数が 戻った場合と同じように値がドロップされます。
• クラッシュを許容できない場合は、パニックしない API（Vec::get など）を使用してください。

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::panic;

fn main() {
    let result = panic::catch_unwind(|| "No problem here!");
    dbg!(result);

    let result = panic::catch_unwind(|| {
        panic!("oh no!");
    });
    dbg!(result);
}

Result

Rust におけるエラーハンドリングの主要な仕組みは Result 列挙型であり、これは標準ライブラリの型について説明した際に少し見ました。

// 著作権 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::fs::File;
use std::io::Read;

fn main() {
    let file: Result<File, std::io::Error> = File::open("diary.txt");
    match file {
        Ok(mut file) => {
            let mut contents = String::new();
            if let Ok(bytes) = file.read_to_string(&mut contents) {
                println!("親愛なる日記へ: {contents} ({bytes} バイト)");
            } else {
                println!("ファイルの内容を読み取れませんでした");
            }
        }
        Err(err) => {
            println!("日記を開けませんでした: {err}");
        }
    }
}

try演算子

接続拒否やファイルが見つからないといった実行時エラーは Result 型で扱われます が、呼び出しのたびにこの型に対してパターンマッチを書くのは煩雑です。 エラーを呼び出し元に返すには、try演算子 ? を使います。これにより、 よくある次のようなコードを

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

match some_expression {
    Ok(value) => value,
    Err(err) => return Err(err),
}

はるかに単純な次の形にできます

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

some_expression?

これを使うと、エラー処理コードを簡潔にできます:

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::io::Read;
use std::{fs, io};

fn read_username(path: &str) -> Result<String, io::Error> {
    let username_file_result = fs::File::open(path);
    let mut username_file = match username_file_result {
        Ok(file) => file,
        Err(err) => return Err(err),
    };

    let mut username = String::new();
    match username_file.read_to_string(&mut username) {
        Ok(_) => Ok(username),
        Err(err) => Err(err),
    }
}

fn main() {
    //fs::write("config.dat", "alice").unwrap();
    let username = read_username("config.dat");
    println!("username or error: {username:?}");
}

Try 変換

? の実際の展開は、これまでに示したものよりも少し複雑です。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

expression?

これは次と同じように動作します。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

match expression {
    Ok(value) => value,
    Err(err)  => return Err(From::from(err)),
}

ここでの From::from 呼び出しは、エラー型を関数が返す型に変換しようとすることを意味します。これにより、エラーをより上位レベルのエラーに簡単にカプセル化できます。

例

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::error::Error;
use std::io::Read;
use std::{fmt, fs, io};

#[derive(Debug)]
enum ReadUsernameError {
    IoError(io::Error),
    EmptyUsername(String),
}

impl Error for ReadUsernameError {}

impl fmt::Display for ReadUsernameError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Self::IoError(e) => write!(f, "I/O error: {e}"),
            Self::EmptyUsername(path) => write!(f, "Found no username in {path}"),
        }
    }
}

impl From<io::Error> for ReadUsernameError {
    fn from(err: io::Error) -> Self {
        Self::IoError(err)
    }
}

fn read_username(path: &str) -> Result<String, ReadUsernameError> {
    let mut username = String::with_capacity(100);
    fs::File::open(path)?.read_to_string(&mut username)?;
    if username.is_empty() {
        return Err(ReadUsernameError::EmptyUsername(String::from(path)));
    }
    Ok(username)
}

fn main() {
    //std::fs::write("config.dat", "").unwrap();
    let username = read_username("config.dat");
    println!("username or error: {username:?}");
}

動的なエラー型

すべての異なる可能性を網羅する独自の enum を書かなくても、任意の型のエラーを返せるようにしたい場合があります。std::error::Error トレイトを使うと、任意のエラーを保持できるトレイトオブジェクトを簡単に作成できます。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::error::Error;
use std::fs;
use std::io::Read;

fn read_count(path: &str) -> Result<i32, Box<dyn Error>> {
    let mut count_str = String::new();
    fs::File::open(path)?.read_to_string(&mut count_str)?;
    let count: i32 = count_str.parse()?;
    Ok(count)
}

fn main() {
    fs::write("count.dat", "1i3").unwrap();
    match read_count("count.dat") {
        Ok(count) => println!("Count: {count}"),
        Err(err) => println!("Error: {err}"),
    }
}

thiserror

thiserror クレートは、エラー型を定義する際の定型的なコードを避けるのに役立つマクロを提供します。From<T>、Display、および Error トレイトの実装を支援する derive マクロを提供します。

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::io::Read;
use std::{fs, io};
use thiserror::Error;

#[derive(Debug, Error)]
enum ReadUsernameError {
    #[error("I/O error: {0}")]
    IoError(#[from] io::Error),
    #[error("Found no username in {0}")]
    EmptyUsername(String),
}

fn read_username(path: &str) -> Result<String, ReadUsernameError> {
    let mut username = String::with_capacity(100);
    fs::File::open(path)?.read_to_string(&mut username)?;
    if username.is_empty() {
        return Err(ReadUsernameError::EmptyUsername(String::from(path)));
    }
    Ok(username)
}

fn main() {
    //fs::write("config.dat", "").unwrap();
    match read_username("config.dat") {
        Ok(username) => println!("Username: {username}"),
        Err(err) => println!("Error: {err}"),
    }
}

anyhow

anyhow クレートは、追加のコンテキスト情報を保持できるリッチなエラー型を提供します。これは、エラーに至るまでプログラムが何をしていたかの意味的なトレースを提供するために使用できます。

これを thiserror の便利なマクロと組み合わせることで、カスタムエラー型に対するトレイト実装を明示的に書く必要を避けられます。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

use anyhow::{Context, Result, bail};
use std::fs;
use std::io::Read;
use thiserror::Error;

#[derive(Clone, Debug, Eq, Error, PartialEq)]
#[error("Found no username in {0}")]
struct EmptyUsernameError(String);

fn read_username(path: &str) -> Result<String> {
    let mut username = String::with_capacity(100);
    fs::File::open(path)
        .with_context(|| format!("Failed to open {path}"))?
        .read_to_string(&mut username)
        .context("Failed to read")?;
    if username.is_empty() {
        bail!(EmptyUsernameError(path.to_string()));
    }
    Ok(username)
}

fn main() {
    //fs::write("config.dat", "").unwrap();
    match read_username("config.dat") {
        Ok(username) => println!("Username: {username}"),
        Err(err) => println!("Error: {err:?}"),
    }
}

演習: Result を使った書き換え

この演習では、2日目に行った式評価器の演習を再訪します。最初の解法では、 起こりうるエラーケース、つまり 0 による除算を無視しています。このエラーケースを 扱い、発生したときにエラーを返すよう、eval を慣用的なエラーハンドリングを 用いる形に書き換えてください。eval のエラー型として使用するためのシンプルな DivideByZeroError 型を用意しています。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// An operation to perform on two subexpressions.
#[derive(Debug)]
enum Operation {
    Add,
    Sub,
    Mul,
    Div,
}

/// An expression, in tree form.
#[derive(Debug)]
enum Expression {
    /// An operation on two subexpressions.
    Op { op: Operation, left: Box<Expression>, right: Box<Expression> },

    /// A literal value
    Value(i64),
}

#[derive(PartialEq, Eq, Debug)]
struct DivideByZeroError;

// The original implementation of the expression evaluator. Update this to
// return a `Result` and produce an error when dividing by 0.
fn eval(e: Expression) -> i64 {
    match e {
        Expression::Op { op, left, right } => {
            let left = eval(*left);
            let right = eval(*right);
            match op {
                Operation::Add => left + right,
                Operation::Sub => left - right,
                Operation::Mul => left * right,
                Operation::Div => if right != 0 {
                    left / right
                } else {
                    panic!("Cannot divide by zero!");
                },
            }
        }
        Expression::Value(v) => v,
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_error() {
        assert_eq!(
            eval(Expression::Op {
                op: Operation::Div,
                left: Box::new(Expression::Value(99)),
                right: Box::new(Expression::Value(0)),
            }),
            Err(DivideByZeroError)
        );
    }

    #[test]
    fn test_ok() {
        let expr = Expression::Op {
            op: Operation::Sub,
            left: Box::new(Expression::Value(20)),
            right: Box::new(Expression::Value(10)),
        };
        assert_eq!(eval(expr), Ok(10));
    }
}

解答

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// An operation to perform on two subexpressions.
#[derive(Debug)]
enum Operation {
    Add,
    Sub,
    Mul,
    Div,
}

/// An expression, in tree form.
#[derive(Debug)]
enum Expression {
    /// An operation on two subexpressions.
    Op { op: Operation, left: Box<Expression>, right: Box<Expression> },

    /// A literal value
    Value(i64),
}

#[derive(PartialEq, Eq, Debug)]
struct DivideByZeroError;

fn eval(e: Expression) -> Result<i64, DivideByZeroError> {
    match e {
        Expression::Op { op, left, right } => {
            let left = eval(*left)?;
            let right = eval(*right)?;
            Ok(match op {
                Operation::Add => left + right,
                Operation::Sub => left - right,
                Operation::Mul => left * right,
                Operation::Div => {
                    if right == 0 {
                        return Err(DivideByZeroError);
                    } else {
                        left / right
                    }
                }
            })
        }
        Expression::Value(v) => Ok(v),
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_error() {
        assert_eq!(
            eval(Expression::Op {
                op: Operation::Div,
                left: Box::new(Expression::Value(99)),
                right: Box::new(Expression::Value(0)),
            }),
            Err(DivideByZeroError)
        );
    }

    #[test]
    fn test_ok() {
        let expr = Expression::Op {
            op: Operation::Sub,
            left: Box::new(Expression::Value(20)),
            right: Box::new(Expression::Value(10)),
        };
        assert_eq!(eval(expr), Ok(10));
    }
}

• Result の戻り値型: 関数シグネチャは Result<i64, DivideByZeroError> を返すように変更されます。この明示的な 型シグネチャにより、呼び出し側は失敗の可能性を処理することを強制されます。
• ? 演算子: 再帰呼び出しに対して ? を使用します: eval(*left)?。これにより、 エラーがすっきりと伝播されます。eval が Err を返した場合、関数は即座に その Err を返します。Ok(v) を返した場合は、v が left（または right）に代入されます。
• Ok でのラップ: 成功した結果は Ok(...) でラップする必要があります。
• ゼロ除算の処理: right == 0 を明示的にチェックし、 Err(DivideByZeroError) を返します。これにより、元のコードでの panic が置き換えられます。

Unsafe Rust

segment outline

Unsafe Rust

Rust 言語は 2 つの部分から成ります。

• Safe Rust: メモリ安全で、未定義動作は発生しません。
• Unsafe Rust: 事前条件に違反すると、未定義動作を引き起こす可能性があります。

このコースでは主に safe Rust を見てきましたが、Unsafe Rust が何であるかを知っておくことは重要です。

unsafe コードは小さく分離されているべきであり、その正しさは 注意深く文書化されていなければなりません。また、安全な抽象化レイヤーで ラップするべきです。

Unsafe Rust では、次の 5 つの新しい機能にアクセスできます。

• 生ポインタをデリファレンスする。
• 可変な静的変数にアクセスまたは変更する。
• union フィールドにアクセスする。
• extern 関数を含む unsafe 関数を呼び出す。
• unsafe トレイトを実装する。

次に、unsafe の機能を簡単に見ていきます。詳しくは、 Rust Book の 19.1 章 および Rustonomicon を参照してください。

生ポインタのデリファレンス

ポインタを作成すること自体は安全ですが、それらをデリファレンスするには unsafe が必要です:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    let mut x = 10;

    let p1: *mut i32 = &raw mut x;
    let p2 = p1 as *const i32;

    // SAFETY: p1 と p2 はローカル変数への生ポインタを取得して作成されたため、
    // null ではなく、アラインされており、単一の（スタックに）確保された
    // オブジェクトを指すことが保証されています。
    //
    // 生ポインタが参照しているオブジェクトは関数全体のあいだ生存するため、
    // 生ポインタが存在しているあいだに解放されることはありません。また、
    // 生ポインタが存在しているあいだは参照経由でアクセスされず、
    // 他のスレッドから同時にアクセスされることもありません。
    unsafe {
        dbg!(*p1);
        *p1 = 6;
        // C と同様に、変更は生ポインタを通して適切に観測できます。
        dbg!(*p2);
    }

    // UNSOUND. こうしてはいけません。
    /*
    let r: &i32 = unsafe { &*p1 };
    dbg!(r);
    x = 50;
    dbg!(r); // 参照が指す基底オブジェクトは変更されています。これは UB です。
    */
}

可変な静的変数

不変の静的変数を読み取るのは安全です:

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

static HELLO_WORLD: &str = "Hello, world!";

fn main() {
    println!("HELLO_WORLD: {HELLO_WORLD}");
}

しかし、可変な静的変数の読み書きは unsafe です。複数のスレッドが同期なしに同時にアクセスでき、その結果データ競合が発生しうるためです。

可変な静的変数を健全に使用するには、コンパイラの助けなしに並行性について考察する必要があります:

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

static mut COUNTER: u32 = 0;

fn add_to_counter(inc: u32) {
    // SAFETY: `COUNTER` にアクセスしうる他のスレッドは存在しません。
    unsafe {
        COUNTER += inc;
    }
}

fn main() {
    add_to_counter(42);

    // SAFETY: `COUNTER` にアクセスしうる他のスレッドは存在しません。
    unsafe {
        dbg!(COUNTER);
    }
}

共用体

共用体は enum に似ていますが、どのフィールドが有効かは自分で追跡する必要があります。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[repr(C)]
union MyUnion {
    i: u8,
    b: bool,
}

fn main() {
    let u = MyUnion { i: 42 };
    println!("int: {}", unsafe { u.i });
    println!("bool: {}", unsafe { u.b }); // 未定義動作！
}

unsafe 関数

未定義動作を避けるために守らなければならない追加の事前条件がある場合、関数またはメソッドは unsafe としてマークできます。

unsafe 関数は、次の 2 つの場所に由来することがあります。

• unsafe として宣言された Rust 関数。
• extern "C" ブロック内の unsafe な外部関数。

Unsafe Rustの関数

未定義動作を避けるために特定の事前条件が必要な場合は、自分の関数を unsafe としてマークできます。

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// 与えられたポインタが指す値を入れ替えます。
///
/// # Safety
///
/// ポインタは有効で、適切にアラインされており、関数呼び出しの間は
/// それ以外の方法でアクセスされていてはなりません。
unsafe fn swap(a: *mut u8, b: *mut u8) {
    // SAFETY: 呼び出し元は、ポインタが有効で適切にアラインされており、
    // ほかにアクセスがないことを保証しています。
    unsafe {
        let temp = *a;
        *a = *b;
        *b = temp;
    }
}

fn main() {
    let mut a = 42;
    let mut b = 66;

    // SAFETY: これらのポインタは参照から得られたものなので、有効で、
    // アラインされており、排他的でなければなりません。
    unsafe {
        swap(&mut a, &mut b);
    }

    println!("a = {}, b = {}", a, b);
}

unsafe な外部関数

unsafe extern を使うと、Rust からアクセスするための外部関数を宣言できます。 これは、それらの振る舞いについてコンパイラが推論する手段を持たないため、unsafe です。 extern ブロック内で宣言される関数には、安全に使用するための事前条件があるかどうかに 応じて、safe または unsafe を付ける必要があります:

// 著作権 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::ffi::c_char;

unsafe extern "C" {
    // `abs` はポインタを扱わず、安全性に関する要件もありません。
    safe fn abs(input: i32) -> i32;

    /// # Safety
    ///
    /// `s` は、有効な NUL 終端 C 文字列へのポインタでなければならず、この関数呼び出しの
    /// 間は変更されてはなりません。
    unsafe fn strlen(s: *const c_char) -> usize;
}

fn main() {
    println!("C による -3 の絶対値: {}", abs(-3));

    unsafe {
        // SAFETY: プログラムの実行中ずっと有効な C 文字列リテラルへのポインタを
        // 渡しています。
        println!("文字列の長さ: {}", strlen(c"String".as_ptr()));
    }
}

unsafe 関数の呼び出し

安全性要件を守らないと、メモリ安全性が損なわれます！

// Copyright 2025 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[derive(Debug)]
#[repr(C)]
struct KeyPair {
    pk: [u16; 4], // 8 バイト
    sk: [u16; 4], // 8 バイト
}

const PK_BYTE_LEN: usize = 8;

fn log_public_key(pk_ptr: *const u16) {
    let pk: &[u16] = unsafe { std::slice::from_raw_parts(pk_ptr, PK_BYTE_LEN) };
    println!("{pk:?}");
}

fn main() {
    let key_pair = KeyPair { pk: [1, 2, 3, 4], sk: [0, 0, 42, 0] };
    log_public_key(key_pair.pk.as_ptr());
}

各 unsafe ブロックには、必ず安全性コメントを付けてください。そのコメントでは、 コードが実際に安全である理由を説明しなければなりません。この例には安全性コメントがなく、健全ではありません。

unsafe トレイトの実装

関数と同様に、未定義動作を避けるために実装が特定の条件を保証しなければならない場合、 トレイトを unsafe としてマークできます。

たとえば、zerocopy クレートには、 次のような unsafe トレイトがあります。

// 著作権 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::{mem, slice};

/// ...
/// # Safety
/// この型は、表現が定義されており、パディングを含んではなりません。
pub unsafe trait IntoBytes {
    fn as_bytes(&self) -> &[u8] {
        let len = mem::size_of_val(self);
        let slf: *const Self = self;
        unsafe { slice::from_raw_parts(slf.cast::<u8>(), len) }
    }
}

// SAFETY: `u32` は表現が定義されており、パディングがありません。
unsafe impl IntoBytes for u32 {}

安全なFFIラッパ

Rust は、foreign function interface（FFI）を介して関数を呼び出すための優れたサポートを備えています。これを使って、C からディレクトリ内のファイル名を読み取るときに使用する libc 関数の安全なラッパーを構築します。

以下のマニュアルページを参照するとよいでしょう。

• opendir(3)
• readdir(3)
• closedir(3)

また、std::ffi モジュールにも目を通してください。そこには、この演習で必要になるいくつかの文字列型があります。

これらすべての型の間で変換を行います。

• &str から CString: 末尾の \0 文字のための領域を確保する必要があります。
• CString から *const c_char: C 関数を呼び出すにはポインタが必要です。
• *const c_char から &CStr: 末尾の \0 文字を見つけられるものが必要です。
• &CStr から &[u8]: バイトスライスは「何らかの未知のデータ」に対する汎用的なインターフェースです。
• &[u8] から &OsStr: &OsStr は OsString への途中段階です。これを作成するには OsStrExt を使ってください。
• &OsStr から OsString: &OsStr 内のデータを複製して、これを返せるようにし、さらに readdir を再度呼び出せるようにする必要があります。

Nomicon にも、FFI に関する非常に有用な章があります。

以下のコードを https://play.rust-lang.org/ にコピーし、不足している関数とメソッドを埋めてください。

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

// TODO: 実装が完了したらこれを削除してください。
#![allow(unused_imports, unused_variables, dead_code)]

mod ffi {
    use std::os::raw::{c_char, c_int};
    #[cfg(not(target_os = "macos"))]
    use std::os::raw::{c_long, c_uchar, c_ulong, c_ushort};

    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.
    #[repr(C)]
    pub struct DIR {
        _data: [u8; 0],
        _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
    }

    // Layout according to the Linux man page for readdir(3), where ino_t and
    // off_t are resolved according to the definitions in
    // /usr/include/x86_64-linux-gnu/{sys/types.h, bits/typesizes.h}.
    #[cfg(not(target_os = "macos"))]
    #[repr(C)]
    pub struct dirent {
        pub d_ino: c_ulong,
        pub d_off: c_long,
        pub d_reclen: c_ushort,
        pub d_type: c_uchar,
        pub d_name: [c_char; 256],
    }

    // Layout according to the macOS man page for dir(5).
    #[cfg(target_os = "macos")]
    #[repr(C)]
    pub struct dirent {
        pub d_fileno: u64,
        pub d_seekoff: u64,
        pub d_reclen: u16,
        pub d_namlen: u16,
        pub d_type: u8,
        pub d_name: [c_char; 1024],
    }

    unsafe extern "C" {
        pub unsafe fn opendir(s: *const c_char) -> *mut DIR;

        #[cfg(not(all(target_os = "macos", target_arch = "x86_64")))]
        pub unsafe fn readdir(s: *mut DIR) -> *const dirent;

        // See https://github.com/rust-lang/libc/issues/414 and the section on
        // _DARWIN_FEATURE_64_BIT_INODE in the macOS man page for stat(2).
        //
        // "Platforms that existed before these updates were available" refers
        // to macOS (as opposed to iOS / wearOS / etc.) on Intel and PowerPC.
        #[cfg(all(target_os = "macos", target_arch = "x86_64"))]
        #[link_name = "readdir$INODE64"]
        pub unsafe fn readdir(s: *mut DIR) -> *const dirent;

        pub unsafe fn closedir(s: *mut DIR) -> c_int;
    }
}

use std::ffi::{CStr, CString, OsStr, OsString};
use std::os::unix::ffi::OsStrExt;

#[derive(Debug)]
struct DirectoryIterator {
    path: CString,
    dir: *mut ffi::DIR,
}

impl DirectoryIterator {
    fn new(path: &str) -> Result<DirectoryIterator, String> {
        // Call opendir and return a Ok value if that worked,
        // otherwise return Err with a message.
        todo!()
    }
}

impl Iterator for DirectoryIterator {
    type Item = OsString;
    fn next(&mut self) -> Option<OsString> {
        // Keep calling readdir until we get a NULL pointer back.
        todo!()
    }
}

impl Drop for DirectoryIterator {
    fn drop(&mut self) {
        // Call closedir as needed.
        todo!()
    }
}

fn main() -> Result<(), String> {
    let iter = DirectoryIterator::new(".")?;
    println!("files: {:#?}", iter.collect::<Vec<_>>());
    Ok(())
}

解答

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

mod ffi {
    use std::os::raw::{c_char, c_int};
    #[cfg(not(target_os = "macos"))]
    use std::os::raw::{c_long, c_uchar, c_ulong, c_ushort};

    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.
    #[repr(C)]
    pub struct DIR {
        _data: [u8; 0],
        _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
    }

    // Layout according to the Linux man page for readdir(3), where ino_t and
    // off_t are resolved according to the definitions in
    // /usr/include/x86_64-linux-gnu/{sys/types.h, bits/typesizes.h}.
    #[cfg(not(target_os = "macos"))]
    #[repr(C)]
    pub struct dirent {
        pub d_ino: c_ulong,
        pub d_off: c_long,
        pub d_reclen: c_ushort,
        pub d_type: c_uchar,
        pub d_name: [c_char; 256],
    }

    // Layout according to the macOS man page for dir(5).
    #[cfg(target_os = "macos")]
    #[repr(C)]
    pub struct dirent {
        pub d_fileno: u64,
        pub d_seekoff: u64,
        pub d_reclen: u16,
        pub d_namlen: u16,
        pub d_type: u8,
        pub d_name: [c_char; 1024],
    }

    unsafe extern "C" {
        pub unsafe fn opendir(s: *const c_char) -> *mut DIR;

        #[cfg(not(all(target_os = "macos", target_arch = "x86_64")))]
        pub unsafe fn readdir(s: *mut DIR) -> *const dirent;

        // See https://github.com/rust-lang/libc/issues/414 and the section on
        // _DARWIN_FEATURE_64_BIT_INODE in the macOS man page for stat(2).
        //
        // "Platforms that existed before these updates were available" refers
        // to macOS (as opposed to iOS / wearOS / etc.) on Intel and PowerPC.
        #[cfg(all(target_os = "macos", target_arch = "x86_64"))]
        #[link_name = "readdir$INODE64"]
        pub unsafe fn readdir(s: *mut DIR) -> *const dirent;

        pub unsafe fn closedir(s: *mut DIR) -> c_int;
    }
}

use std::ffi::{CStr, CString, OsStr, OsString};
use std::os::unix::ffi::OsStrExt;

#[derive(Debug)]
struct DirectoryIterator {
    path: CString,
    dir: *mut ffi::DIR,
}

impl DirectoryIterator {
    fn new(path: &str) -> Result<DirectoryIterator, String> {
        // Call opendir and return a Ok value if that worked,
        // otherwise return Err with a message.
        let path =
            CString::new(path).map_err(|err| format!("Invalid path: {err}"))?;
        // SAFETY: path.as_ptr() cannot be NULL.
        let dir = unsafe { ffi::opendir(path.as_ptr()) };
        if dir.is_null() {
            Err(format!("Could not open {path:?}"))
        } else {
            Ok(DirectoryIterator { path, dir })
        }
    }
}

impl Iterator for DirectoryIterator {
    type Item = OsString;
    fn next(&mut self) -> Option<OsString> {
        // Keep calling readdir until we get a NULL pointer back.
        // SAFETY: self.dir is never NULL.
        let dirent = unsafe { ffi::readdir(self.dir) };
        if dirent.is_null() {
            // We have reached the end of the directory.
            return None;
        }
        // SAFETY: dirent is not NULL and dirent.d_name is NUL
        // terminated.
        let d_name = unsafe { CStr::from_ptr((*dirent).d_name.as_ptr()) };
        let os_str = OsStr::from_bytes(d_name.to_bytes());
        Some(os_str.to_owned())
    }
}

impl Drop for DirectoryIterator {
    fn drop(&mut self) {
        // Call closedir as needed.
        // SAFETY: self.dir is never NULL.
        if unsafe { ffi::closedir(self.dir) } != 0 {
            panic!("Could not close {:?}", self.path);
        }
    }
}

fn main() -> Result<(), String> {
    let iter = DirectoryIterator::new(".")?;
    println!("files: {:#?}", iter.collect::<Vec<_>>());
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::error::Error;

    #[test]
    fn test_nonexisting_directory() {
        let iter = DirectoryIterator::new("no-such-directory");
        assert!(iter.is_err());
    }

    #[test]
    fn test_empty_directory() -> Result<(), Box<dyn Error>> {
        let tmp = tempfile::TempDir::new()?;
        let iter = DirectoryIterator::new(
            tmp.path().to_str().ok_or("Non UTF-8 character in path")?,
        )?;
        let mut entries = iter.collect::<Vec<_>>();
        entries.sort();
        assert_eq!(entries, &[".", ".."]);
        Ok(())
    }

    #[test]
    fn test_nonempty_directory() -> Result<(), Box<dyn Error>> {
        let tmp = tempfile::TempDir::new()?;
        std::fs::write(tmp.path().join("foo.txt"), "The Foo Diaries\n")?;
        std::fs::write(tmp.path().join("bar.png"), "<PNG>\n")?;
        std::fs::write(tmp.path().join("crab.rs"), "//! Crab\n")?;
        let iter = DirectoryIterator::new(
            tmp.path().to_str().ok_or("Non UTF-8 character in path")?,
        )?;
        let mut entries = iter.collect::<Vec<_>>();
        entries.sort();
        assert_eq!(entries, &[".", "..", "bar.png", "crab.rs", "foo.txt"]);
        Ok(())
    }
}

• 安全性コメント: 各 unsafe ブロックの前には、その操作がなぜ安全なのかを説明する // SAFETY: コメントが置かれています。これは監査を容易にするための、Rust における標準的な慣行です。
• 文字列変換: このコードは、FFI に必要な変換を示しています:
  • &str -> CString: C 用のヌル終端文字列を作成するため。
  • CString -> *const c_char: ポインタを C に渡すため。
  • *const c_char -> &CStr: 返された C 文字列をラップするため。
  • &CStr -> &[u8] -> &OsStr -> OsString: バイト列を Rust の OS 文字列に戻すため。
• RAII (Drop): イテレータがスコープを外れるときに closedir を自動的に呼び出すように Drop を実装しています。これにより、ファイルディスクリプタのリークを防げます。
• イテレータインターフェース: C API を Rust の Iterator でラップし、基盤となる unsafe な C 関数に対して、安全で Rust らしいインターフェース（next は Option<OsString> を返す）を提供します。

Android における Rust へようこそ

Rust は Android のシステムソフトウェアでサポートされています。これは、 新しいサービス、ライブラリ、ドライバー、さらにはファームウェアまでを Rust で記述したり、 必要に応じて既存のコードを改善したりできることを意味します。

セットアップ

コードをテストするために、Cuttlefish Android Virtual Device を使用します。アクセスできるものがあることを確認するか、次のコマンドで新しく作成してください。

source build/envsetup.sh
lunch aosp_cf_x86_64_phone-trunk_staging-userdebug
acloud create

詳細については、 Android Developer Codelab を 参照してください。

以降のページにあるコードは、コース教材の src/android/ ディレクトリ にあります。内容に沿って進めるには、リポジトリを git clone してください。

ビルドルール

Android ビルドシステム（Soong）は、いくつかのモジュールを通じて Rust をサポートしています。

次に、rust_binary と rust_library を見ていきます。

Rust バイナリ

シンプルなアプリケーションから始めましょう。AOSP チェックアウトのルートで、次のファイルを作成します:

hello_rust/Android.bp:

rust_binary {
    name: "hello_rust",
    crate_name: "hello_rust",
    srcs: ["src/main.rs"],
}

hello_rust/src/main.rs:

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! Rust demo.

/// Prints a greeting to standard output.
fn main() {
    println!("Hello from Rust!");
}

これでバイナリをビルドし、プッシュして、実行できます:

m hello_rust
adb push "$ANDROID_PRODUCT_OUT/system/bin/hello_rust" /data/local/tmp
adb shell /data/local/tmp/hello_rust

Hello from Rust!

Rust ライブラリ

Android 向けの新しい Rust ライブラリを作成するには、rust_library を使用します。

ここでは、2 つのライブラリへの依存関係を宣言します。

• libgreeting。これは以下で定義します。
• libtextwrap。これは、すでに external/rust/android-crates-io/crates/ に vendored 済みの crate です。

hello_rust/Android.bp:

rust_binary {
    name: "hello_rust_with_dep",
    crate_name: "hello_rust_with_dep",
    srcs: ["src/main.rs"],
    rustlibs: [
        "libgreetings",
        "libtextwrap",
    ],
    prefer_rlib: true, // Need this to avoid dynamic link error.
}

rust_library {
    name: "libgreetings",
    crate_name: "greetings",
    srcs: ["src/lib.rs"],
}

hello_rust/src/main.rs:

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! Rust demo.

use greetings::greeting;
use textwrap::fill;

/// Prints a greeting to standard output.
fn main() {
    println!("{}", fill(&greeting("Bob"), 24));
}

hello_rust/src/lib.rs:

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! Greeting library.

/// Greet `name`.
pub fn greeting(name: &str) -> String {
    format!("Hello {name}, it is very nice to meet you!")
}

先ほどと同じように、バイナリをビルド、プッシュして実行します。

m hello_rust_with_dep
adb push "$ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep" /data/local/tmp
adb shell /data/local/tmp/hello_rust_with_dep

Hello Bob, it is very
nice to meet you!

AIDL（Androidインターフェイス定義言語）

Rust は、Android Interface Definition Language（AIDL） をサポートしています。

• Rust コードから既存の AIDL サーバーを呼び出すことができます。
• Rust で新しい AIDL サーバーを作成できます。

Birthday Service チュートリアル

Binder で Rust を使用する方法を説明するために、Binder インターフェースを作成します。次に、サービスを実装し、それと通信するクライアントを作成します。

AIDL インターフェース

AIDL インターフェースを使用して、サービスの API を宣言します。

birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl:

package com.example.birthdayservice;

/** Birthday service interface. */
interface IBirthdayService {
    /** Generate a Happy Birthday message. */
    String wishHappyBirthday(String name, int years);
}

birthday_service/aidl/Android.bp:

aidl_interface {
    name: "com.example.birthdayservice",
    srcs: ["com/example/birthdayservice/*.aidl"],
    unstable: true,
    backend: {
        rust: { // Rust is not enabled by default
            enabled: true,
        },
    },
}

生成されたサービス API

Binder は、各インターフェース定義に対してトレイトを生成します。

birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl:

/** Birthday service interface. */
interface IBirthdayService {
    /** Generate a Happy Birthday message. */
    String wishHappyBirthday(String name, int years);
}

out/soong/.intermediates/…/com_example_birthdayservice.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

trait IBirthdayService {
    fn wishHappyBirthday(&self, name: &str, years: i32) -> binder::Result<String>;
}

サービスはこのトレイトを実装する必要があり、クライアントはこの トレイトを使用してサービスとやり取りします。

サービスの実装

これで AIDL サービスを実装できます。

birthday_service/src/lib.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! `IBirthdayService` AIDL インターフェースの実装。
use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;
use com_example_birthdayservice::binder;

/// The `IBirthdayService` implementation.
pub struct BirthdayService;

impl binder::Interface for BirthdayService {}

impl IBirthdayService for BirthdayService {
    fn wishHappyBirthday(&self, name: &str, years: i32) -> binder::Result<String> {
        Ok(format!("Happy Birthday {name}, congratulations with the {years} years!"))
    }
}

birthday_service/Android.bp:

rust_library {
    name: "libbirthdayservice",
    crate_name: "birthdayservice",
    srcs: ["src/lib.rs"],
    rustlibs: [
        "com.example.birthdayservice-rust",
    ],
}

AIDL サーバー

最後に、サービスを公開するサーバーを作成できます。

birthday_service/src/server.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! Birthday service.
use birthdayservice::BirthdayService;
use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::BnBirthdayService;
use com_example_birthdayservice::binder;

const SERVICE_IDENTIFIER: &str = "birthdayservice";

/// Entry point for birthday service.
fn main() {
    let birthday_service = BirthdayService;
    let birthday_service_binder = BnBirthdayService::new_binder(
        birthday_service,
        binder::BinderFeatures::default(),
    );
    binder::add_service(SERVICE_IDENTIFIER, birthday_service_binder.as_binder())
        .expect("Failed to register service");
    binder::ProcessState::join_thread_pool();
}

birthday_service/Android.bp:

rust_binary {
    name: "birthday_server",
    crate_name: "birthday_server",
    srcs: ["src/server.rs"],
    rustlibs: [
        "com.example.birthdayservice-rust",
        "libbirthdayservice",
    ],
    prefer_rlib: true, // To avoid dynamic link error.
}

デプロイ

これで、サービスをビルドし、プッシュして起動できます:

m birthday_server
adb push "$ANDROID_PRODUCT_OUT/system/bin/birthday_server" /data/local/tmp
adb root
adb shell /data/local/tmp/birthday_server

別のターミナルで、サービスが実行されていることを確認します:

adb shell service check birthdayservice

Service birthdayservice: found

service call を使ってサービスを呼び出すこともできます:

adb shell service call birthdayservice 1 s16 Bob i32 24

Result: Parcel(
  0x00000000: 00000000 00000036 00610048 00700070 '....6...H.a.p.p.'
  0x00000010: 00200079 00690042 00740072 00640068 'y. .B.i.r.t.h.d.'
  0x00000020: 00790061 00420020 0062006f 0020002c 'a.y. .B.o.b.,. .'
  0x00000030: 006f0063 0067006e 00610072 00750074 'c.o.n.g.r.a.t.u.'
  0x00000040: 0061006c 00690074 006e006f 00200073 'l.a.t.i.o.n.s. .'
  0x00000050: 00690077 00680074 00740020 00650068 'w.i.t.h. .t.h.e.'
  0x00000060: 00320020 00200034 00650079 00720061 ' .2.4. .y.e.a.r.'
  0x00000070: 00210073 00000000                   's.!.....        ')

AIDL クライアント

最後に、新しいサービス用の Rust クライアントを作成できます。

birthday_service/src/client.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;
use com_example_birthdayservice::binder;

const SERVICE_IDENTIFIER: &str = "birthdayservice";

/// Call the birthday service.
fn main() -> Result<(), Box<dyn Error>> {
    let name = std::env::args().nth(1).unwrap_or_else(|| String::from("Bob"));
    let years = std::env::args()
        .nth(2)
        .and_then(|arg| arg.parse::<i32>().ok())
        .unwrap_or(42);

    binder::ProcessState::start_thread_pool();
    let service = binder::get_interface::<dyn IBirthdayService>(SERVICE_IDENTIFIER)
        .map_err(|_| "Failed to connect to BirthdayService")?;

    // Call the service.
    let msg = service.wishHappyBirthday(&name, years)?;
    println!("{msg}");
}

birthday_service/Android.bp:

rust_binary {
    name: "birthday_client",
    crate_name: "birthday_client",
    srcs: ["src/client.rs"],
    rustlibs: [
        "com.example.birthdayservice-rust",
    ],
    prefer_rlib: true, // To avoid dynamic link error.
}

クライアントは libbirthdayservice に依存しないことに注意してください。

クライアントをビルドし、デバイスにプッシュして実行します。

m birthday_client
adb push "$ANDROID_PRODUCT_OUT/system/bin/birthday_client" /data/local/tmp
adb shell /data/local/tmp/birthday_client Charlie 60

Happy Birthday Charlie, congratulations with the 60 years!

API の変更

API を拡張しましょう。クライアントがバースデーカードの行のリストを 指定できるようにします:

package com.example.birthdayservice;

/** バースデーサービスのインターフェース。 */
interface IBirthdayService {
    /** Happy Birthday メッセージを生成します。 */
    String wishHappyBirthday(String name, int years, in String[] text);
}

これにより、IBirthdayService のトレイト定義は次のように更新されます:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

trait IBirthdayService {
    fn wishHappyBirthday(
        &self,
        name: &str,
        years: i32,
        text: &[String],
    ) -> binder::Result<String>;
}

クライアントとサービスの更新

新しい API に対応するように、クライアントとサーバーのコードを更新します。

birthday_service/src/lib.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

impl IBirthdayService for BirthdayService {
    fn wishHappyBirthday(
        &self,
        name: &str,
        years: i32,
        text: &[String],
    ) -> binder::Result<String> {
        let mut msg = format!(
            "Happy Birthday {name}, congratulations with the {years} years!",
        );

        for line in text {
            msg.push('\n');
            msg.push_str(line);
        }

        Ok(msg)
    }
}

birthday_service/src/client.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

let msg = service.wishHappyBirthday(
    &name,
    years,
    &[
        String::from("Habby birfday to yuuuuu"),
        String::from("And also: many more"),
    ],
)?;

AIDL 型の操作

AIDL の型は、適切で Rust らしい型に変換されます。

• プリミティブ型は、（ほとんどの場合）Rust らしい型に対応付けられます。
• スライス、Vec、文字列型などのコレクション型がサポートされています。
• AIDL オブジェクトおよびファイルハンドルへの参照は、クライアントとサービスの間で送信できます。
• ファイルハンドルと Parcelable は完全にサポートされています。

プリミティブ型

プリミティブ型は（ほとんどの場合）慣用的に次のように対応付けられます。

配列型

配列型（T[]、byte[]、List<T>）は、関数シグネチャでの使用方法に応じて、適切な Rust の配列型に変換されます。

オブジェクトの送信

AIDL オブジェクトは、具体的な AIDL 型として送信することも、型消去された IBinder インターフェースとして送信することもできます。

birthday_service/aidl/com/example/birthdayservice/IBirthdayInfoProvider.aidl:

package com.example.birthdayservice;

interface IBirthdayInfoProvider {
    String name();
    int years();
}

birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl:

import com.example.birthdayservice.IBirthdayInfoProvider;

interface IBirthdayService {
    /** The same thing, but using a binder object. */
    String wishWithProvider(IBirthdayInfoProvider provider);

    /** The same thing, but using `IBinder`. */
    String wishWithErasedProvider(IBinder provider);
}

birthday_service/src/client.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

/// Rust struct implementing the `IBirthdayInfoProvider` interface.
struct InfoProvider {
    name: String,
    age: u8,
}

impl binder::Interface for InfoProvider {}

impl IBirthdayInfoProvider for InfoProvider {
    fn name(&self) -> binder::Result<String> {
        Ok(self.name.clone())
    }

    fn years(&self) -> binder::Result<i32> {
        Ok(self.age as i32)
    }
}

fn main() {
    binder::ProcessState::start_thread_pool();
    let service = connect().expect("Failed to connect to BirthdayService");

    // Create a binder object for the `IBirthdayInfoProvider` interface.
    let provider = BnBirthdayInfoProvider::new_binder(
        InfoProvider { name: name.clone(), age: years as u8 },
        BinderFeatures::default(),
    );

    // Send the binder object to the service.
    service.wishWithProvider(&provider)?;

    // Perform the same operation but passing the provider as an `SpIBinder`.
    service.wishWithErasedProvider(&provider.as_binder())?;
}

Parcelable

Rust 向け Binder は、Parcelable を直接送信することをサポートしています:

birthday_service/aidl/com/example/birthdayservice/BirthdayInfo.aidl:

package com.example.birthdayservice;

parcelable BirthdayInfo {
    String name;
    int years;
}

birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl:

import com.example.birthdayservice.BirthdayInfo;

interface IBirthdayService {
    /** The same thing, but with a parcelable. */
    String wishWithInfo(in BirthdayInfo info);
}

birthday_service/src/client.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    binder::ProcessState::start_thread_pool();
    let service = connect().expect("Failed to connect to BirthdayService");

    let info = BirthdayInfo { name: "Alice".into(), years: 123 };
    service.wishWithInfo(&info)?;
}

ファイルの送信

ファイルは、ParcelFileDescriptor 型を使用して Binder クライアント/サーバー間で送信できます:

birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl:

interface IBirthdayService {
    /** The same thing, but loads info from a file. */
    String wishFromFile(in ParcelFileDescriptor infoFile);
}

birthday_service/src/client.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

fn main() {
    binder::ProcessState::start_thread_pool();
    let service = connect().expect("Failed to connect to BirthdayService");

    // Open a file and put the birthday info in it.
    let mut file = File::create("/data/local/tmp/birthday.info").unwrap();
    writeln!(file, "{name}")?;
    writeln!(file, "{years}")?;

    // Create a `ParcelFileDescriptor` from the file and send it.
    let file = ParcelFileDescriptor::new(file);
    service.wishFromFile(&file)?;
}

birthday_service/src/lib.rs:

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

impl IBirthdayService for BirthdayService {
    fn wishFromFile(
        &self,
        info_file: &ParcelFileDescriptor,
    ) -> binder::Result<String> {
        // Convert the file descriptor to a `File`. `ParcelFileDescriptor` wraps
        // an `OwnedFd`, which can be cloned and then used to create a `File`
        // object.
        let mut info_file = info_file
            .as_ref()
            .try_clone()
            .map(File::from)
            .expect("Invalid file handle");

        let mut contents = String::new();
        info_file.read_to_string(&mut contents).unwrap();

        let mut lines = contents.lines();
        let name = lines.next().unwrap();
        let years: i32 = lines.next().unwrap().parse().unwrap();

        Ok(format!("Happy Birthday {name}, congratulations with the {years} years!"))
    }
}

Android でのテスト

テスト を踏まえて、ここでは AOSP でユニットテストがどのように 動作するかを見ていきます。ユニットテストには rust_test モジュールを使用します:

testing/Android.bp:

rust_library {
    name: "libleftpad",
    crate_name: "leftpad",
    srcs: ["src/lib.rs"],
}

rust_test {
    name: "libleftpad_test",
    crate_name: "leftpad_test",
    srcs: ["src/lib.rs"],
    host_supported: true,
    test_suites: ["general-tests"],
}

rust_test {
    name: "libgoogletest_example",
    crate_name: "googletest_example",
    srcs: ["googletest.rs"],
    rustlibs: ["libgoogletest_rust"],
    host_supported: true,
}

rust_test {
    name: "libmockall_example",
    crate_name: "mockall_example",
    srcs: ["mockall.rs"],
    rustlibs: ["libmockall"],
    host_supported: true,
}

testing/src/lib.rs:

#![allow(unused)]
fn main() {
// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! Left-padding library.

/// Left-pad `s` to `width`.
pub fn leftpad(s: &str, width: usize) -> String {
    format!("{s:>width$}")
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn short_string() {
        assert_eq!(leftpad("foo", 5), "  foo");
    }

    #[test]
    fn long_string() {
        assert_eq!(leftpad("foobar", 6), "foobar");
    }
}
}

これで、次のようにテストを実行できます

atest --host libleftpad_test

出力は次のようになります:

INFO: Elapsed time: 2.666s, Critical Path: 2.40s
INFO: 3 processes: 2 internal, 1 linux-sandbox.
INFO: Build completed successfully, 3 total actions
//comprehensive-rust-android/testing:libleftpad_test_host            PASSED in 2.3s
    PASSED  libleftpad_test.tests::long_string (0.0s)
    PASSED  libleftpad_test.tests::short_string (0.0s)
Test cases: finished with 2 passing and 0 failing out of 2 test cases

ライブラリクレートのルートだけを指定していることに注目してください。テストは ネストされたモジュール内で再帰的に検出されます。

GoogleTest

GoogleTest クレートを使うと、マッチャー を用いた柔軟な テストアサーションを記述できます。

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

use googletest::prelude::*;

#[googletest::test]
fn test_elements_are() {
    let value = vec!["foo", "bar", "baz"];
    expect_that!(value, elements_are!(eq(&"foo"), lt(&"xyz"), starts_with("b")));
}

最後の要素を "!" に変更すると、テストはエラー箇所を的確に示す構造化されたエラー メッセージとともに失敗します。

---- test_elements_are stdout ----
Value of: value
Expected: has elements:
  0. is equal to "foo"
  1. is less than "xyz"
  2. starts with prefix "!"
Actual: ["foo", "bar", "baz"],
  where element #2 is "baz", which does not start with "!"
  at src/testing/googletest.rs:6:5
Error: See failure output above

// Copyright 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[test]
fn test_multiline_string_diff() {
    let haiku = "Memory safety found,\n\
                 Rust's strong typing guides the way,\n\
                 Secure code you'll write.";
    assert_that!(
        haiku,
        eq("Memory safety found,\n\
            Rust's silly humor guides the way,\n\
            Secure code you'll write.")
    );
}

    Value of: haiku
Expected: is equal to "Memory safety found,\nRust's silly humor guides the way,\nSecure code you'll write."
Actual: "Memory safety found,\nRust's strong typing guides the way,\nSecure code you'll write.",
  which isn't equal to "Memory safety found,\nRust's silly humor guides the way,\nSecure code you'll write."
Difference(-actual / +expected):
 Memory safety found,
-Rust's strong typing guides the way,
+Rust's silly humor guides the way,
 Secure code you'll write.
  at src/testing/googletest.rs:17:5

モック

モックには、Mockall という広く使われているライブラリがあります。コードを トレイトを使うようにリファクタリングする必要があります。そうすれば、それらを すばやくモック化できます。

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

use std::time::Duration;

#[mockall::automock]
pub trait Pet {
    fn is_hungry(&self, since_last_meal: Duration) -> bool;
}

#[test]
fn test_robot_dog() {
    let mut mock_dog = MockPet::new();
    mock_dog.expect_is_hungry().return_const(true);
    assert!(mock_dog.is_hungry(Duration::from_secs(10)));
}

// 著作権 2024 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[test]
fn test_robot_cat() {
    let mut mock_cat = MockPet::new();
    mock_cat
        .expect_is_hungry()
        .with(mockall::predicate::gt(Duration::from_secs(3 * 3600)))
        .return_const(true);
    mock_cat.expect_is_hungry().return_const(false);
    assert!(mock_cat.is_hungry(Duration::from_secs(5 * 3600)));
    assert!(!mock_cat.is_hungry(Duration::from_secs(5)));
}

ロギング

log クレートを使用して、logcat（デバイス上）または stdout（ホスト上）に自動的にログを出力してください。

hello_rust_logs/Android.bp:

rust_binary {
    name: "hello_rust_logs",
    crate_name: "hello_rust_logs",
    srcs: ["src/main.rs"],
    rustlibs: [
        "liblog_rust",
        "liblogger",
    ],
    host_supported: true,
}

hello_rust_logs/src/main.rs:

// Copyright 2022 Google LLC
// SPDX-License-Identifier: Apache-2.0

//! Rust logging demo.

use log::{debug, error, info};

/// Logs a greeting.
fn main() {
    logger::init(
        logger::Config::default()
            .with_tag_on_device("rust")
            .with_max_level(log::LevelFilter::Trace),
    );
    debug!("Starting program.");
    info!("Things are going fine.");
    error!("Something went wrong!");
}

バイナリをビルドし、デバイスにプッシュして実行します:

m hello_rust_logs
adb push "$ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs" /data/local/tmp
adb shell /data/local/tmp/hello_rust_logs

ログは adb logcat に表示されます:

adb logcat -s rust

09-08 08:38:32.454  2420  2420 D rust: hello_rust_logs: Starting program.
09-08 08:38:32.454  2420  2420 I rust: hello_rust_logs: Things are going fine.
09-08 08:38:32.454  2420  2420 E rust: hello_rust_logs: Something went wrong!

相互運用性

Rust は他の言語との相互運用性を優れた形でサポートしています。これは、 次のことができることを意味します。

• 他の言語から Rust の関数を呼び出す。
• Rust から他の言語で書かれた関数を呼び出す。

他言語の関数を呼び出すときは、外部関数インターフェース（FFI とも呼ばれます）を使用しています。