Rustの借用チェッカー：適用ケースと適用外の実例で完全理解

Rust言語は、システムプログラミングの分野で近年注目を集めているプログラミング言語です。その中でも特に革新的な特徴として挙げられるのが「借用チェッカー」です。借用チェッカーは、コンパイル時にメモリの安全性を保証するメカニズムであり、データ競合や未定義動作といった問題を未然に防ぐ役割を果たします。しかし、この仕組みが適用されるケースとされないケースを理解することは、Rustプログラマーにとって重要な課題です。本記事では、借用チェッカーの仕組みを基礎から解説し、適用の有無に応じたコード設計のポイントを具体例とともに紹介します。Rustをより深く理解し、安全なプログラミングを実現するための第一歩として、ぜひご覧ください。

借用チェッカーの基本概念

Rustの借用チェッカーは、メモリ安全性を保証するためのコンパイラ機能です。この仕組みは、コードのコンパイル時に「データの所有権」と「借用」のルールをチェックし、不正なメモリアクセスを防ぎます。

所有権と借用の基本

Rustでは、すべての値に所有者があります。この所有者は一度に一つだけ存在し、所有権がスコープを外れると値が自動的に解放されます。借用は、この所有権を手放すことなく一時的に他の場所でデータを利用する仕組みで、以下の2種類があります。

• 不変借用（&）: 値を変更しない読み取り専用の借用。複数の不変借用が可能です。
• 可変借用（&mut）: 値を変更可能な借用。一度に一つだけ許可されます。

借用チェッカーの役割

借用チェッカーは、以下のルールを守ることでメモリ安全性を確保します。

1. 不変借用と可変借用は同時に存在できない。これにより、データ競合を防ぎます。
2. 借用はスコープ内で有効。スコープ外でのデータ使用を禁止し、解放済みメモリへのアクセスを防ぎます。
3. 可変借用は一度に一つだけ許可。これにより、データの一貫性を確保します。

借用チェッカーの意義

この仕組みにより、Rustはプログラマーに明示的なメモリ管理を求めることなく、安全かつ効率的なプログラムを提供します。また、実行時のオーバーヘッドが発生しないため、CやC++と同等のパフォーマンスを維持できます。借用チェッカーはRustの安全性の要であり、その仕組みを理解することが効率的なプログラム設計への鍵となります。

借用チェッカーが適用される典型的な場面

借用チェッカーが適用される場面は、主にメモリ安全性やデータ競合が問題となる操作に集中しています。これにより、プログラムの実行時に発生する可能性のある不具合をコンパイル時に防ぐことが可能です。以下に、その代表的なシナリオを解説します。

可変データの操作

可変データを扱う際、Rustでは同時に複数の可変参照を許可しません。これは、データ競合を未然に防ぐためです。

let mut value = 10;
let ref1 = &mut value;  // 可変借用
// let ref2 = &mut value; // コンパイルエラー: 二重の可変借用は不許可
*ref1 += 1;

このコードでは、ref1が存在する間に新たな可変借用を作成することはできません。これにより、データの一貫性が保たれます。

ライフタイムの不一致

スコープ外のデータへの参照も借用チェッカーによって禁止されます。たとえば、以下のような場合です。

fn get_reference<'a>() -> &'a i32 {
    let value = 10;
    &value // コンパイルエラー: スコープ外のデータ参照
}

借用チェッカーは、valueが関数終了時に解放されるため、その参照を関数の外で使用することを禁止します。

不変借用と可変借用の混在

Rustでは、不変借用と可変借用が同時に存在することは許可されていません。

let mut value = 10;
let immut_ref = &value; // 不変借用
// let mut_ref = &mut value; // コンパイルエラー: 不変借用中の可変借用は不許可
println!("{}", immut_ref);

この制約により、他の参照が値を使用している間にデータが変更されることを防ぎます。

マルチスレッド環境での安全性

マルチスレッド環境では、借用チェッカーがデータ競合を防ぐため、ArcやMutexのような同期メカニズムと連携します。

use std::sync::Mutex;
let data = Mutex::new(5);
{
    let mut num = data.lock().unwrap();
    *num += 1; // ロック中の安全な操作
}
// ロック解除後のデータにアクセス

借用チェッカーはこれらの機能と協調し、安全な並行処理を実現します。

まとめ

借用チェッカーは、メモリのライフタイムや所有権を厳密に管理することで、安全性を確保します。典型的な適用ケースを理解することは、Rustプログラムの設計において重要なステップです。

借用チェッカーが適用されない場面とその理由

借用チェッカーはRustの特徴的な安全性機能ですが、すべての場面で適用されるわけではありません。特定のケースでは、借用チェッカーのチェックが適用されないか、開発者がその制約を明示的に回避できるよう設計されています。これには、パフォーマンスや柔軟性を重視する理由があります。以下に具体例を挙げて解説します。

生ポインタの使用

借用チェッカーが管理するのは「安全な」参照であり、生ポインタ（*const Tや*mut T）には適用されません。生ポインタは借用チェッカーの管理外でメモリアクセスが可能ですが、開発者自身が安全性を確保する必要があります。

let value = 42;
let ptr = &value as *const i32; // 生ポインタ
unsafe {
    println!("{}", *ptr); // 安全性は保証されない
}

このコードではunsafeブロックを使用することで借用チェッカーを回避していますが、不正なメモリアクセスのリスクがあります。

外部ライブラリとのインターフェース

FFI（Foreign Function Interface）を用いてCやC++などの外部ライブラリを利用する場合、借用チェッカーはこれらのコードに適用されません。これは、Rustが管理する範囲外のメモリ操作が行われるためです。

extern "C" {
    fn external_function();
}

unsafe {
    external_function(); // 借用チェッカーはこの呼び出しをチェックしない
}

FFIを利用する際は、メモリの安全性を開発者が担保する必要があります。

マルチスレッドの競合条件を明示的に許可する場合

借用チェッカーは通常、並行処理でのデータ競合を防ぎますが、unsafeブロックや低レベルな同期メカニズムを使用する場合、この制約を回避できます。

use std::thread;

let mut data = 0;

unsafe {
    let handle = thread::spawn(move || {
        data += 1; // 並行アクセスの危険性
    });

    handle.join().unwrap();
}

このコードでは、unsafeを使うことで借用チェッカーの制約を解除していますが、データ競合のリスクを伴います。

ライフタイムの不整合を明示的に許容する場合

ライフタイム注釈を削除するか、コンパイラに明示的なヒントを与えることで、借用チェッカーの制約を回避することが可能です。たとえば、staticライフタイムを使用して任意のスコープ外でのデータ参照を許可できます。

fn create_static_ref() -> &'static str {
    "static reference"
}

この方法は利便性を提供しますが、不適切な使い方はプログラムの安全性を損なう可能性があります。

まとめ

借用チェッカーが適用されない場面では、Rustの安全性メカニズムが一部制限されます。これらのケースでは、開発者が安全性を意識し、リスクを管理する必要があります。借用チェッカーの適用範囲と制約回避の方法を理解することで、柔軟性と安全性を両立したプログラム設計が可能になります。

借用チェッカーを回避する方法と注意点

Rustの借用チェッカーは、安全性を提供する一方で、特定の状況では制約となる場合があります。このような場合に制約を回避する方法も用意されていますが、これらの手法を使用する際には慎重である必要があります。ここでは、代表的な回避方法と、それに伴う注意点を解説します。

1. unsafeブロックの使用

unsafeブロックを利用することで、借用チェッカーの管理外で操作を行うことが可能になります。これにより、生ポインタやFFI、メモリ操作を自由に扱えます。

let value = 42;
let ptr = &value as *const i32;
unsafe {
    println!("Unsafe dereference: {}", *ptr);
}

注意点:

• unsafeは安全性を保証しません。未定義動作やメモリ破壊が発生する可能性があります。
• 必要最小限のスコープで利用し、適切にレビューすることが重要です。

2. RcとRefCellの使用

Rc（参照カウント）やRefCell（実行時可変性）は、借用チェッカーを回避しながら複数箇所からのデータ共有を可能にします。

use std::cell::RefCell;
use std::rc::Rc;

let data = Rc::new(RefCell::new(42));
{
    let mut_ref = data.borrow_mut(); // 実行時に可変性をチェック
    *mut_ref += 1;
}
println!("Updated value: {}", data.borrow());

注意点:

• RefCellは実行時に可変性をチェックしますが、借用チェッカーの静的保証を失います。
• 実行時エラーが発生する可能性があるため、十分なテストが必要です。

3. メモリ操作を直接制御

低レベルなメモリ操作が必要な場合、BoxやManuallyDropを用いることで、借用チェッカーの管理を回避できます。

use std::mem::ManuallyDrop;

let mut value = ManuallyDrop::new(Box::new(42));
unsafe {
    let raw_ptr = &mut **value as *mut i32;
    *raw_ptr += 1;
    println!("Updated via raw pointer: {}", *raw_ptr);
}

注意点:

• メモリリークや二重解放のリスクを伴います。
• 使用箇所の正確な管理が必要です。

4. FFI（Foreign Function Interface）の活用

外部ライブラリやシステムコールを利用する場合、FFIを使用してRustの借用チェッカーを回避します。

extern "C" {
    fn external_function(ptr: *mut i32);
}
unsafe {
    let mut value = 42;
    external_function(&mut value as *mut i32);
}

注意点:

• Rust外のコードに依存するため、安全性が完全に保証されません。
• 外部コードの動作を十分に理解し、安全性を検証する必要があります。

まとめ

借用チェッカーの回避は、柔軟性を高める一方で、安全性を開発者自身が管理しなければなりません。unsafeやRefCellなどの手法を正しく使用し、リスクを最小限に抑えながらプログラムのニーズに応じた設計を行いましょう。安全性を重視した設計が、長期的なプロジェクトの成功につながります。

ライフタイム注釈と借用チェッカーの関係

Rustの借用チェッカーは、プログラム中のデータの有効期間を「ライフタイム」によって管理します。ライフタイム注釈は、借用チェッカーがメモリ安全性を保証するために欠かせない要素です。このセクションでは、ライフタイム注釈の基本から借用チェッカーとの密接な関係について解説します。

ライフタイムの基本概念

ライフタイムとは、参照が有効である期間を示すもので、Rustコンパイラはライフタイムを追跡してメモリの安全性を確保します。

{
    let x = 10;
    let r = &x; // rはxを参照
    println!("{}", r); // rのライフタイムはxと一致
} // ここでxとrはスコープを抜ける

コンパイラはrのライフタイムがxを超えないことを保証し、不正なメモリアクセスを防ぎます。

ライフタイム注釈の必要性

単純なケースでは、コンパイラがライフタイムを推論します。しかし、複数の参照が絡む複雑な状況では、明示的にライフタイムを指定する必要があります。

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() > b.len() {
        a
    } else {
        b
    }
}

この例では、関数longestの入力参照aとbが同じライフタイム'aを持つことを注釈しています。これにより、借用チェッカーは返される参照がどちらかの入力のライフタイムを超えないことを保証します。

ライフタイムと借用チェッカーの相互作用

借用チェッカーはライフタイム情報をもとに、以下のような不正な操作を防ぎます。

1. ライフタイムの不整合: スコープ外のデータ参照を禁止。

   let r;
   {
       let x = 10;
       r = &x; // コンパイルエラー: xはスコープ外
   }

2. 参照の衝突: 同時に複数の可変借用が存在しないよう制約。

   let mut x = 10;
   let r1 = &mut x;
   let r2 = &mut x; // コンパイルエラー: 二重の可変借用

3. 借用の無効化: 借用されたデータが有効期間中に破棄されないことを保証。

構造体でのライフタイム注釈

構造体で参照を保持する場合、ライフタイム注釈が必要です。

struct RefHolder<'a> {
    reference: &'a i32,
}

let x = 10;
let holder = RefHolder { reference: &x };
println!("{}", holder.reference); // xのライフタイムが保証されている

ライフタイム省略規則

Rustにはライフタイム注釈を省略できる規則がありますが、それは特定の状況に限られます。例えば、次のような単一の参照引数を取る関数ではライフタイム注釈が省略されます。

fn print_reference(x: &str) {
    println!("{}", x);
}

まとめ

ライフタイム注釈は、借用チェッカーが参照の有効期間を管理し、メモリ安全性を保証するために必要不可欠な要素です。これらを理解し、適切に活用することで、Rustの強力なメモリ管理機能を最大限に引き出すことができます。ライフタイムと借用チェッカーの仕組みを深く理解することが、効率的で安全なプログラム設計の基盤となります。

借用チェッカーを活用した安全なコードの設計

借用チェッカーは、Rustが提供するメモリ安全性の要であり、これを正しく活用することで、安全で効率的なコード設計が可能になります。本セクションでは、借用チェッカーを活用した設計のベストプラクティスを紹介します。

1. 不変借用と可変借用の適切な使い分け

不変借用（&）と可変借用（&mut）を正しく使い分けることで、データ競合や予期せぬ動作を防ぐことができます。

fn calculate_sum(values: &[i32]) -> i32 {
    values.iter().sum()
}

fn increment_first(values: &mut [i32]) {
    if let Some(first) = values.first_mut() {
        *first += 1;
    }
}

let mut data = vec![1, 2, 3];
let sum = calculate_sum(&data); // 不変借用
increment_first(&mut data);    // 可変借用

ポイント: 不変借用と可変借用を同じスコープで混在させないようにします。

2. スコープを意識した参照の管理

参照のスコープを明確にすることで、借用チェッカーの制約をスムーズに満たせます。

let mut data = vec![1, 2, 3];
{
    let first = &data[0]; // 不変借用はこのスコープ内のみ
    println!("First element: {}", first);
}
data.push(4); // 借用が解放されているので可変操作が可能

ポイント: 借用が長く続くと他の操作を制限するため、スコープを短く保つことが重要です。

3. イミュータビリティを活用したスレッドセーフな設計

借用チェッカーはイミュータビリティを活用し、スレッド間の安全なデータ共有を実現します。

use std::sync::Arc;
use std::thread;

let data = Arc::new(vec![1, 2, 3]);
let data_clone = Arc::clone(&data);

let handle = thread::spawn(move || {
    println!("{:?}", data_clone);
});

handle.join().unwrap();
println!("{:?}", data);

ポイント: ArcやMutexを活用することで、借用チェッカーと並行プログラミングを両立できます。

4. ライフタイムを明示して長期的な参照を安全に管理

ライフタイム注釈を適切に使うことで、長期間のデータ参照を安全に行えます。

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

let string1 = String::from("long string");
let string2 = "short";
let result = longest(string1.as_str(), string2);
println!("Longest string: {}", result);

ポイント: ライフタイムを適切に設定することで、借用チェッカーのエラーを防ぎます。

5. パフォーマンスと安全性の両立

借用チェッカーを活用してパフォーマンスを損なうことなく安全性を確保する設計が可能です。たとえば、イテレータを活用して余計なコピーを防ぎます。

let values = vec![1, 2, 3];
for value in values.iter() {
    println!("{}", value); // 借用でコピーを避ける
}

ポイント: 借用を活用して、データコピーを最小限に抑える設計を目指します。

まとめ

借用チェッカーは、適切に活用すれば安全性を確保しながら効率的なコードを設計する手助けをします。不変性の徹底、スコープの管理、ライフタイムの適切な設定など、基本的なルールを守ることで、Rustの強力な安全性機能を活用した設計が実現できます。

借用チェッカーが強みを発揮する実例

Rustの借用チェッカーは、特定の状況でその強みを最大限に発揮し、実行時の問題を未然に防ぎます。以下では、借用チェッカーが効率的かつ安全なコード設計に貢献する具体的なシナリオを紹介します。

1. データ競合の防止

借用チェッカーは、マルチスレッド環境でのデータ競合を防ぐ役割を果たします。たとえば、複数のスレッドで同じデータにアクセスする状況を考えます。

use std::sync::{Arc, Mutex};
use std::thread;

let data = Arc::new(Mutex::new(0));
let mut handles = vec![];

for _ in 0..10 {
    let data = Arc::clone(&data);
    let handle = thread::spawn(move || {
        let mut num = data.lock().unwrap();
        *num += 1; // 借用チェッカーが保証する安全な操作
    });
    handles.push(handle);
}

for handle in handles {
    handle.join().unwrap();
}

println!("Final value: {}", *data.lock().unwrap());

効果: 借用チェッカーはArcとMutexを活用してスレッド間の安全なアクセスを保証します。

2. メモリ安全性の確保

借用チェッカーは、ライフタイムを追跡して、スコープ外のデータ参照によるセグメンテーションフォルトを防ぎます。

fn create_ref() -> &'static str {
    "Hello, Rust!" // スタティックなライフタイムを持つ文字列リテラル
}

let r = create_ref();
println!("{}", r); // 安全に使用可能

効果: 借用チェッカーがデータのライフタイムを追跡し、スコープ外参照を防ぎます。

3. 安全なデータ共有

借用チェッカーは、可変性の制限を通じてデータの一貫性を保ちます。たとえば、次のコードでは同時に複数の可変参照が許可されないため、データの整合性が保たれます。

let mut data = vec![1, 2, 3];

{
    let first = &data[0]; // 不変借用
    println!("First element: {}", first);
} // firstのスコープ終了

data.push(4); // 可変操作が安全に実行可能
println!("{:?}", data);

効果: 借用チェッカーにより、不変借用と可変借用の衝突が防がれます。

4. 低オーバーヘッドでの安全性

Rustの借用チェッカーはコンパイル時に問題を検出するため、実行時オーバーヘッドなしで高い安全性を提供します。

let values = vec![1, 2, 3, 4];
let sum: i32 = values.iter().sum(); // 借用を活用した効率的な演算
println!("Sum: {}", sum);

効果: 借用を使用することで、不必要なデータコピーを回避しながら安全性を確保します。

5. 複雑なライフタイム管理を自動化

Rustでは、借用チェッカーが複雑なライフタイムの管理を自動化し、プログラマーの負担を軽減します。

struct Holder<'a> {
    reference: &'a i32,
}

fn main() {
    let value = 42;
    let holder = Holder { reference: &value };
    println!("Held value: {}", holder.reference); // 借用チェッカーがライフタイムを保証
}

効果: 借用チェッカーが構造体内部の参照も安全に管理します。

まとめ

借用チェッカーの強みは、コンパイル時に問題を検出し、安全性を確保することにあります。これにより、データ競合の防止やメモリ安全性、低オーバーヘッドでの効率的な操作が可能になります。借用チェッカーを活用することで、安全かつ高品質なコード設計が実現します。

借用チェッカーが課題となる場合の解決策

Rustの借用チェッカーは安全性を確保するために非常に強力ですが、その制約が課題となる場合もあります。これらの課題を理解し、適切な解決策を取ることで、柔軟性を損なわずにRustのメリットを享受できます。

1. 可変性と不変性の同時利用の制約

借用チェッカーは、不変借用と可変借用を同時に許可しません。この制約がデータ操作を複雑にする場合があります。

問題例:

let mut data = vec![1, 2, 3];
let r = &data[0];  // 不変借用
data.push(4);      // コンパイルエラー: 可変借用との衝突

解決策: スコープを明確に分離するか、借用チェッカーが許可する操作順序に変更します。

let mut data = vec![1, 2, 3];
{
    let r = &data[0];
    println!("First element: {}", r); // 不変借用のスコープ内
}
data.push(4); // 不変借用が終了した後に操作可能

2. 長いライフタイムの参照

ライフタイム注釈が複雑になると、借用チェッカーの制約が問題になる場合があります。

問題例:

fn longest<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

使用するすべての参照に適切なライフタイムを指定する必要があるため、コードが冗長になります。

解決策: 必要に応じてライフタイムを短縮するか、データ所有を移動して所有権を明確にします。

fn longest_owned(s1: String, s2: String) -> String {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

3. 複雑なデータ構造の操作

借用チェッカーは、複雑なデータ構造を部分的に借用する場合に制約を課すことがあります。

問題例:

let mut nested = vec![vec![1, 2], vec![3, 4]];
let inner = &nested[0]; // 不変借用
nested.push(vec![5, 6]); // コンパイルエラー

解決策: RefCellやRcを活用して、借用を実行時にチェックするように変更します。

use std::cell::RefCell;

let nested = RefCell::new(vec![vec![1, 2], vec![3, 4]]);
{
    let inner = nested.borrow(); // 不変借用
    println!("{:?}", inner[0]);
}
nested.borrow_mut().push(vec![5, 6]); // 可変借用が可能

4. 動的なデータ操作

動的に生成されるデータやライフタイムが不明瞭な場合、借用チェッカーは制約となります。

解決策: BoxやArcなどのヒープデータ構造を活用し、ライフタイムを明確にします。

use std::sync::Arc;

let shared_data = Arc::new(vec![1, 2, 3]);
let shared_clone = Arc::clone(&shared_data);
println!("{:?}", shared_clone);

5. 複数のスレッド間でのデータ共有

スレッド間でデータを共有する場合、借用チェッカーの制約が強く働きます。

解決策: スレッドセーフな型（MutexやRwLock）を使用します。

use std::sync::{Arc, Mutex};

let data = Arc::new(Mutex::new(0));
let data_clone = Arc::clone(&data);

std::thread::spawn(move || {
    let mut value = data_clone.lock().unwrap();
    *value += 1;
}).join().unwrap();

まとめ

借用チェッカーの制約は、安全性の確保のために設計されていますが、課題となる場合には適切な回避策を用いることが可能です。スコープの調整や所有権の明確化、unsafeの慎重な利用を通じて、柔軟性を確保しながらRustの特性を活かしたコード設計を行いましょう。

借用チェッカーの実践的な演習問題

借用チェッカーの仕組みを実際に理解し、応用できるようにするための演習問題を用意しました。これらの問題に取り組むことで、借用チェッカーの特性と制約をより深く理解できます。

演習1: 不変借用と可変借用

以下のコードはコンパイルエラーを引き起こします。エラーの原因を特定し、修正してください。

fn main() {
    let mut data = vec![1, 2, 3];
    let first = &data[0]; // 不変借用
    data.push(4);         // 可変操作
    println!("{}", first);
}

ヒント: 借用のスコープに注意して修正してください。

演習2: ライフタイムの注釈

次の関数はコンパイルエラーになります。ライフタイム注釈を追加して修正してください。

fn longest(a: &str, b: &str) -> &str {
    if a.len() > b.len() {
        a
    } else {
        b
    }
}

ヒント: ライフタイム注釈を関数の定義に追加してください。

演習3: 可変性とスコープ

以下のコードで、countの値を安全にインクリメントするように変更してください。

fn main() {
    let mut count = 0;
    let ref1 = &mut count;
    let ref2 = &mut count; // コンパイルエラー
    *ref1 += 1;
    *ref2 += 1;
}

ヒント: 借用の範囲を調整してください。

演習4: 並行処理と借用

以下のコードを修正して、ArcとMutexを用いてスレッド間でデータを安全に共有できるようにしてください。

use std::thread;

fn main() {
    let data = vec![1, 2, 3];
    let handle = thread::spawn(move || {
        println!("{:?}", data);
    });
    handle.join().unwrap();
}

ヒント: スレッド間で安全にデータを共有するには、ArcやMutexを使用します。

演習5: Rustでの所有権の移動

以下のコードを修正して、所有権の移動と借用のバランスを保つ形で動作させてください。

fn main() {
    let data = vec![1, 2, 3];
    let ref_data = &data;
    consume_data(data); // コンパイルエラー
    println!("{:?}", ref_data);
}

fn consume_data(data: Vec<i32>) {
    println!("{:?}", data);
}

ヒント: 借用と所有権移動のタイミングを調整してください。

まとめ

これらの演習問題に取り組むことで、借用チェッカーのルールとそれを利用した安全なコード設計についての理解を深めることができます。解答を試行錯誤しながら、安全性と柔軟性を両立したプログラムを書く力を養いましょう。

まとめ

本記事では、Rustの借用チェッカーについて、適用ケースと適用外のケースを具体例を交えて詳しく解説しました。借用チェッカーは、メモリ安全性とデータ競合の防止を実現するための強力な仕組みであり、Rustの核となる特徴です。

借用チェッカーを理解し、適切に活用することで、より安全で効率的なプログラム設計が可能になります。一方で、課題となる場面では、スコープ管理やライフタイム注釈の適切な使用、さらにはunsafeや同期メカニズムを活用することで柔軟性を確保できます。

演習問題にも挑戦することで、理論だけでなく実践的なスキルを磨き、Rustのプログラミングでの生産性をさらに向上させてください。Rustの持つ安全性とパフォーマンスを最大限に活かしたコードを目指していきましょう。