rust-by-example

Rust by Example — コンパイル可能なスニペットで学ぶパターン

権威ある情報源：Rust by Example — 公式の例を中心としたチュートリアルです。このスキルは、24 の章をトピック別のリファレンスファイルに案内するルーティングレイヤーに集約しています。

このスキルが扱うのは、具体的なコードを用いた 「X をどう書くか」 のパターンです。アーキテクチャ上の判断（rust-api-design、rust-workspace）、言語の意味論（rust-stable）、標準ライブラリ API の選択（rust-stdlib）は扱いません。

対応範囲

✅ 得意分野

1. 型変換 — From／Into／TryFrom／as／Deref／transmute
2. フロー制御の慣用句 — if let、while let、match、ラベル付きの loop、?
3. 関数、メソッド、クロージャ（Fn／FnMut／FnOnce）、キャプチャモード
4. モジュール、use、pub、super／self／crate、ファイルベースのモジュール解決
5. ジェネリクス — 関数、構造体、メソッド、impl ブロック、where 句
6. トレイト — 定義、デフォルトメソッド、関連型、トレイトオブジェクト、オブジェクト安全性
7. エラー処理 — ?、Result、Option、thiserror と anyhow によるカスタムエラー
8. 属性 — #[derive]、#[cfg]、#[inline]、#[allow]、#[non_exhaustive]
9. unsafe — 生ポインター、デリファレンス、unsafe fn／unsafe impl、ユニオン、ABI
10. 手続き型マクロ — derive、属性、関数風（概要レベルで rust-macros に案内）
11. インラインアセンブリ — core::arch::asm!（まれですが対応しています）

⚠️ 前提条件

1. Rust の基本構文 — rust-stable を参照
2. プロジェクト構成 — rust-workspace、rust-module-layout を参照

❌ 対象外

1. API 設計上の判断 → rust-api-design
2. ワークスペース／モジュールのレイアウト → rust-workspace、rust-module-layout
3. 標準ライブラリ API の選択（どのコレクション、どのポインターを使うか） → rust-stdlib
4. 非同期ランタイム → rust-concurrency
5. 深いレベルの unsafe／FFI → rust-unsafe-ffi
6. 複雑な手続き型マクロの作成 → rust-macros

データプライバシー

このスキルはユーザーデータを収集、保存、送信しません。

---

トピックマップ（パターンカテゴリごとに 1 セクション）

各セクションには短い例がインラインで記載されています。より詳しいパターンは、リンク先のリファレンスファイルにあります。

1. 型変換

// From / Into (lossless)
impl From<i32> for Wrapped { fn from(v: i32) -> Self { Self(v) } }
let w: Wrapped = 42.into();   // Into comes for free

// TryFrom (fallible)
impl TryFrom<&str> for Email {
    type Error = EmailError;
    fn try_from(s: &str) -> Result<Self, Self::Error> { /* */ }
}

// as (numeric widening/narrowing — can lose data)
let big: i64 = 1_000_000;
let small: i32 = big as i32;       // ❌ silent truncation possible

// Deref (smart-pointer coercion, NOT polymorphism)
let s: String = "hi".to_string();
let s_ref: &str = &s;              // Deref<Target=str> kicks in

as、From、TryFrom の違いと、それぞれを使うべき状況については、references/conversions.md を参照してください。

2. フロー制御

// if let — single-pattern destructure
if let Some(x) = opt { /* */ }

// while let — loop until None
while let Some(line) = reader.lines().next() { /* */ }

// match with @-binding
match point {
    Point { x: 0, y } => println!("on y-axis at {y}"),
    Point { x, y: 0 } => println!("on x-axis at {x}"),
    p @ Point { x: 10..=20, .. } => println!("in x-band: {p:?}"),
    _ => {}
}

// loop with label
'outer: loop {
    loop { break 'outer; }
}

match の使いやすさ、ガード、範囲、if let を優先すべき状況については、references/flow-control.md を参照してください。

3. 関数とクロージャ

// Closure captures by ref/move based on use
let v = vec![1, 2, 3];
let print = || println!("{:?}", v);       // borrows
let consume = move || { v.into_iter().sum() };  // moves

// Fn / FnMut / FnOnce — how a closure borrows its environment
fn apply(f: impl Fn()) { f() }            // can be called multiple times, immutable capture
fn apply_mut(mut f: impl FnMut()) { f() } // mutable capture
fn apply_once(f: impl FnOnce() -> i32) -> i32 { f() }  // consumes captured

move キーワード、戻り値の型推論、Fn／FnMut／FnOnce のトレイト境界については、references/closures.md を参照してください。

4. モジュール

// src/lib.rs
pub mod network;                  // src/network.rs OR src/network/mod.rs
pub use network::Client;          // re-export

// src/network.rs
pub struct Client { /* */ }
pub fn connect() { /* */ }

// Using items
use std::collections::HashMap;
use std::io::{self, Read};        // io module + Read trait
use crate::network::Client;       // absolute
use super::helper;                 // parent
use self::inner::Item;            // current

pub／pub(crate)／pub(super)、ファイルベースと mod.rs の違い、クレートルートでの再エクスポートについては、references/modules.md を参照してください。レイアウトの詳しい作業については、rust-module-layout に案内してください。

5. ジェネリクス

// Generic function with bound
fn first<T>(xs: &[T]) -> Option<&T> { xs.first() }

// Generic with where clause
fn sum<T>(xs: &[T]) -> T where T: Default + std::ops::AddAssign + Copy {
    let mut acc = T::default();
    for x in xs { acc += *x; }
    acc
}

// Generic struct
struct Pair<A, B> { a: A, b: B }

impl<A: Clone, B: Clone> Pair<A, B> {
    fn swapped(&self) -> Pair<B, A> { Pair { a: self.b.clone(), b: self.a.clone() } }
}

単相化のコスト、ジェネリクスとトレイトオブジェクトの使い分け、関連型とジェネリクスの違いについては、references/generics-traits.md を参照してください。

6. トレイト

// Definition with default method
pub trait Summary {
    fn summarize(&self) -> String;
    fn default_summary(&self) -> String { format!("(no summary)") }
}

// Trait object (dynamic dispatch)
fn print_summary(item: &dyn Summary) { println!("{}", item.summarize()); }

// Generic (static dispatch)
fn print_summary_generic<T: Summary>(item: &T) { println!("{}", item.summarize()); }

// Associated type
trait Container { type Item; fn first(&self) -> Option<&Self::Item>; }

オブジェクト安全性のルール：メソッドシグネチャで Self を使わない、ジェネリックメソッドを使わない、サイズ指定されたレシーバーを使う。references/generics-traits.md を参照してください。

7. エラー処理

use std::fs;
use std::io;
use std::num::ParseIntError;

// ? propagates with From conversion
fn read_count() -> Result<i32, io::Error> {
    let s: String = fs::read_to_string("count.txt")?;
    Ok(s.trim().parse().unwrap_or(0))   // or proper error mapping
}

// Custom error with thiserror
#[derive(thiserror::Error, Debug)]
enum Error {
    #[error("io: {0}")] Io(#[from] io::Error),
    #[error("parse: {0}")] Parse(#[from] ParseIntError),
    #[error("not found: {key}")] NotFound { key: String },
}

// Application-layer catch-all with anyhow
fn main() -> anyhow::Result<()> {
    let x: i32 = "5".parse()?;
    Ok(())
}

From と組み合わせた ?、thiserror と anyhow の違い、カスタムエラーの設計については、references/error-handling.md を参照してください。

8. 属性

#[derive(Debug, Clone, PartialEq)]   // generate traits
struct User { id: u32 }

#[cfg(target_os = "linux")]          // conditional compilation
fn setup() { /* */ }

#[inline]                            // hint to inline (rarely matters)
fn fast() {}

#[allow(dead_code)]                  // suppress warning
struct Unused;

#[non_exhaustive]                    // allow adding variants
enum Event { Login }

属性の完全な一覧、cfg 式、#[inline] が実際に役立つ状況については、references/attributes.md を参照してください。

9. Unsafe

// Raw pointer dereference
let x = 42;
let ptr: *const i32 = &x;
let val = unsafe { *ptr };

// Splitting a slice (needs unsafe for non-overlapping aliasing)
let mut v = vec![1, 2, 3, 4];
let (left, right) = v.split_at_mut(2);   // safe wrapper

// Calling C ABI
extern "C" { fn abs(input: i32) -> i32; }
let a = unsafe { abs(-5) };

// Union (unsafe to read)
#[repr(C)]
union Value { i: i32, f: f32 }

安全性の契約、4 つの unsafe の超能力、unsafe を使うべき状況については、references/unsafe.md を参照してください。FFI の詳しい内容については、rust-unsafe-ffi に案内してください。

10. 手続き型マクロ（概要のみ）

// Derive (most common)
#[derive(Debug, Clone, serde::Serialize)]
struct Config { /* */ }

// Attribute macro
#[tokio::main]
async fn main() { /* */ }

// Function-like macro
let html = html! { <div>Hello</div> };

これらの作成は複雑なため、rust-macros に案内してください。このスキルでは使い方のみを扱います。

3 種類の形式とそれぞれを使う状況については、references/procedural-macros-overview.md を参照してください。

11. インラインアセンブリ

#[cfg(target_arch = "x86_64")]
fn halt() {
    unsafe { std::arch::asm!("hlt", options(nostack)); }
}

asm! の構文、破壊されるレジスターなど、使用すべき状況（カーネル／組み込み用途のみ）については、references/inline-asm.md を参照してください。

---

ワークフロー

1. 質問を特定する — 「X の書き方」ならこのスキル、「どの型か」なら rust-stdlib、「設計方法」なら rust-api-design を参照します。
2. 該当するリファレンスを探す — 上記のセクション 1～11、または references/ 内のファイルを参照します。
3. 最小限の例を読む — パターンをコピーし、自分のコードに合わせて調整します。
4. 検証する — cargo check、cargo clippy を実行します。
5. 引き継ぐ — より踏み込んだ質問は、専門スキルに振り分けます。

判断の早見表

質問	参照先
型を変換するには？	references/conversions.md
if let／match を書くには？	references/flow-control.md
クロージャはどのように変数をキャプチャする？	references/closures.md
mod／use／pub はどのように機能する？	references/modules.md
ジェネリック関数／構造体／impl とは？	references/generics-traits.md
トレイトオブジェクトとジェネリクスの違いは？	references/generics-traits.md
エラーを伝播するには？	references/error-handling.md
#[derive]／#[cfg] には何がある？	references/attributes.md
unsafe はどのような場合に使ってよい？	references/unsafe.md
手続き型マクロを書くには？	rust-macros スキル
asm! はどのような形式？	references/inline-asm.md

他の言語から移行する場合

...でのパターン	Rust では...
Java のインターフェイス＋実装	Rust のトレイト＋impl ブロック
Java のジェネリクス <T extends Foo>	Rust の <T: Foo> または where T: Foo
Java の Optional<T>	Rust の Option<T>
Java の try/catch	Rust の ? ＋ Result
Python の with	Rust の Drop（RAII）
Python のデコレーター	Rust の属性マクロ
Go の goroutine	Rust の thread::spawn または非同期タスク
Go の interface{}	Rust の dyn Trait またはジェネリクス
C++ の RAII デストラクター	Rust の Drop トレイト
C++ の reinterpret_cast	Rust の unsafe { transmute }（避けてください）

より詳しい対応関係については、references/migrating-from-other-languages.md を参照してください。

リソース

• 型変換
• フロー制御
• クロージャ
• モジュール
• ジェネリクスとトレイト
• エラー処理
• 属性
• unsafe
• 手続き型マクロの概要
• インラインアセンブリ
• 他の言語からの移行
• examples/golden-by-example/：各パターンを試すクレート

上流の情報源

• Rust by Example
• The Rust Book
• Rust Reference
• Rust Standard Library
• The Rustonomicon（unsafe）
• thiserror および anyhow