この本は、プログラミング言語Rustについての初心者向けの完全な入門書です。Rustは、速度と安全性の両方を兼ね備えたシステムプログラミング言語であり、コンパイラによるメモリ管理によってセグメンテーションフォールトやダングリングポインタなどの危険なエラーを防止します。この本では、Rustの基礎から始めて、データ型、関数、所有権、トレイト、マクロなどの重要なトピックをカバーしています。また、Rustの機能を実際のコード例を交えて説明し、読者が自分自身でコードを書き始めるための準備を整えます。本書を読み進めることで、Rustで安全で高速なシステムプログラミングを行うための基礎を身につけることができます。
__TOC__
Rust（ラスト）は、高性能かつ安全な並行処理を実現するために設計されたマルチパラダイム汎用プログラミング言語です{{cite web
|url=https://graydon2.dreamwidth.org/247406.html
|title=Rust is mostly safety
|last=Hoare
|first=Graydon
|date=2016-12-28
|website=Graydon2
|publisher=Dreamwidth Studios
|access-date=2021-12-03
|archive-date=2019-05-02
|archive-url=https://web.archive.org/web/20190502181357/https://graydon2.dreamwidth.org/247406.html
。
Rustの構文はC++に似ていますが、ボローチェッカーを使用して参照を検証し、メモリ安全性を保証することができます。Rustのボローチェッカーは、Rustコンパイラによって提供される静的解析ツールであり、所有権システムに基づいて、コード内の不正なボロー（借用）を検出するために使用されます。
Rustは、ガベージコレクターを使用せずにメモリ安全性を実現し、オプションでリファレンスカウントによる管理も可能です。
Rustは、システムプログラミング言語と呼ばれ、関数型プログラミングの要素を取り入れつつ、低レベルのメモリ管理メカニズムも提供しています。
そのため、高度な制御を必要とするアプリケーションの開発に最適です。Rustを使うことで、実行時にエラーを発生させることなく、安全で信頼性の高いコードを作成することができます。
{{コラム|セルフホスティング|2=セルフホスティングとは、あるソフトウェアが自分自身をコンパイルできることを指します。つまり、そのソフトウェアをコンパイルするために、あらかじめ別のコンパイラーが必要ではなく、そのソフトウェア自体が自分自身をコンパイルできることです。
コンパイラーにおいてセルフホスティングは、最初にコンパイルされたコンパイラーを使用して、同じ言語で書かれたソースコードをコンパイルすることで実現されます。そして、その新しいコンパイラーを使用して、さらに新しいソースコードをコンパイルし、それを繰り返すことで、より新しいバージョンのコンパイラーを作成することができます。
Rustはメモリ安全性、並行性、パフォーマンスの向上に焦点を当てたモダンなプログラミング言語です。
以下のRustのクイックツアーで、基本的な概念とコード例を紹介します。
Rustプログラムはmain関数から始まります。println! マクロを使って標準出力に文字列を出力できます。
fn main() {
    println!("Hello, world!");
}
Hello, world!
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=65f8e3b00b49ca5c691cd61bfc32d1b7 hello.rs]は、[https://play.rust-lang.org/ Playground]に作った、このプログラムへのリンクになっています。
Rustには整数、浮動小数点数、真偽値などの基本データ型があります。
let age: i32 = 25;
let salary: f64 = 50000.50;
let is_rust_fun: bool = true;
let message: &str = "Hello, Rust!";
if、else if、else 文で条件分岐ができます。
while ループや for ループで繰り返し処理ができます。
let num = 10;
if num > 0 {
    println!("Positive");
} else if num < 0 {
    println!("Negative");
} else {
    println!("Zero");
}
for i in 0..5 {
    println!("Iteration {}", i);
}
関数は fn キーワードを使って宣言します。
fn add(a: i32, b: i32) -> i32 {
    a + b
}
fn main() {
    let result = add(5, 3);
    println!("Sum: {}", result);
}
Rustは所有権ベースのメモリ管理を採用しており、値の所有権が明確に定義されています。
fn main() {
    let s1 = String::from("Hello");
    let s2 = s1; // s1の所有権がs2に移動する（所有権の転送）
    // println!("{}", s1); // エラー！s1はもう有効ではない
    println!("{}", s2); // 正常に動作
}
構造体はデータをまとめるためのカスタム型で、メソッドを持つことができます。
struct Car {
    model: String,
    year: u32,
}
impl Car {
    fn display_info(&self) {
        println!("Model: {}, Year: {}", self.model, self.year);
    }
}
fn main() {
    let my_car = Car {
        model: String::from("Toyota"),
        year: 2022,
    };
    my_car.display_info();
}
ここでは、Rustの基本的な構文とコンセプトを簡単に紹介しました。
やや力技ですが、Rustのコンパイラ rustc のバージョンをコードから確認できます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=db39d32bceac679dd79591501075d7f6 version.rs]:
fn main() {
    let version = std::process::Command::new("rustc")
        .arg("--version")
        .output()
        .expect("Failed to get Rust version");
    if version.status.success() {
        let stdout = String::from_utf8_lossy(&version.stdout);
        println!("Rust version: {}", stdout);
    } else {
        eprintln!("Failed to retrieve Rust version information");
    }
}
実行結果:
Rust version: rustc 1.76.0-nightly (21cce21d8 2023-12-11)
このコードは、Rustのプログラム内でrustc --versionコマンドを実行し、その結果（Rustコンパイラのバージョン情報）を取得しています。
std::process::Command::new("rustc"): Command構造体を使って新しいコマンドを作成しています。ここではrustcというコマンドを実行するよう指定しています。
.arg("--version"): rustcコマンドに--version引数を渡しています。これにより、Rustコンパイラのバージョン情報を取得するよう指示しています。
.output(): Commandを実行して、その結果を取得します。ここでは--versionを指定したrustcコマンドを実行し、その出力を取得しています。
.expect("Failed to get Rust version"): コマンドの実行が失敗した場合にエラーメッセージを表示します。
if version.status.success() { ... } else { ... }: 実行結果のstatusをチェックして、コマンドが正常に終了したかどうかを確認します。もし成功していた場合は、コマンドの出力結果（Rustコンパイラのバージョン情報）を取得し、それを標準出力に表示します。もし失敗していた場合は、エラーメッセージを標準エラー出力に表示します。
このコードは、Rustのプログラム内で外部コマンドを実行してその出力を取得する方法を示しています。具体的には、Rustコンパイラのバージョン情報を取得してそれを表示する例です。
Rustのコメントには、C言語/C++と同じく一行コメントと範囲コメントがあります。
一行コメント: //から行末までがコメントと見なされます。
範囲コメント
/*から*/までがコメントと見なされます。
ネストは許されません。
コメントの例:
/*
 * プログラムのエントリーポイントは、main 関数です。
 * 関数定義は fn から始まります。
 */
fn main() {
    println!("Hello, world!"); // println! は関数ではなくマクロで、マクロは識別子の末尾に ! が付きます。
}
Rustでは、変数を宣言する際にはデフォルトでimmutable（不変）です。変更可能な変数を宣言するには、mut キーワードを使用します。変数の型はコンパイラによって推論されることが一般的ですが、型を明示的に指定することもできます。
例えば、変数の宣言と型指定は以下のようになります：
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=8cddaf15c8b53acb5e0a2013a5cb8cc2 decl.rs]:
fn main() {
    // 型推論による変数の宣言
    let x = 5; // 整数型 i32 として推論される
    let y = 3.14; // 浮動小数点型 f64 として推論される
    println!("x = {x}, y = {y}");
    // 型を明示的に指定する
    let z: i64 = 100; // 64ビット整数型 i64
    println!("z = {z}");
}
Rustの基本的なデータ型には以下があります：
Rustは静的型付け言語であり、変数の型はコンパイル時に確定されます。型の安全性に対する厳格なチェックを行うため、コンパイル時に型の整合性が確認されます。これにより、メモリの安全性やスレッドセーフなコードを書く際の支援が期待できます。
Rustでは、変数を宣言するにはキーワード letを使います。
ディフォルトではイミュータブル（''Immutable''；宣言後には代入不能）な変数が宣言されます。
ミュータブル（''Mutable''；宣言後に代入可能）な変数を宣言するには、追加のキーワード mut を使います。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9032ae8999c6cb3bf5412988320e50d7 hello-variables.rs]:
fn main() {
    let hello : &str = "Hello, world!";
    println!("{}", hello);
}
実行結果:
Hello, world!
２行目のlet hello : &str = "Hello, world!";が変数宣言です文字リテラルであることを強調するならlet hello : &'static str = "Hello, world!";とすべきだったかもしれません。。
&str（文字列のスライスのリファレンス）を型とする変数 hello を宣言し、"Hello, world!"で初期化しています。
Rustには強力な型推論があり多くの場合不要ですが、let 変数名 : 型名の書式で型を伴い変数宣言することも出来ます。
mut をつけない場合には変数に「代入不能」と聞くと、C言語などを知っている人は「定数」を思い浮かべるかもしれませが、
Rustにおいて「定数」は, const 宣言された定数や, static 宣言されかつ mut で修飾されていない変数が相当します。
Rust では、変数宣言が初期値を伴っていた場合、変数の型を省略することができ、初期値の型が変数の型になります。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=ac2b2d100ee8ea175178ebe9b1e26c61 hello-type-inference.rs]:
fn main() {
    let hello = "Hello, world!";
    println!("{hello}");
}
実行結果:上に同じ
Rust では、値が一度変数に let で束縛されると変更できません。これをイミュータブルと言います。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=d13ccba2d1b5efef4ca929012eece549  hello-immutable.rs]:
fn main() {
    let hello : &str = "Hello, world!";
    println!("{hello}");
    hello = "Hello, rust!";
    println!("{hello}");
}
コンパイル結果:
error[E0384]: cannot assign twice to immutable variable `hello`
 --> src/main.rs:4:5
  |
2 |     let hello : &str = "Hello, world!";
  |         -----
  |         |
  |         first assignment to `hello`
  |         help: consider making this binding mutable: `mut hello`
3 |     println!("{hello}");
4 |     hello = "Hello, rust!";
  |     ^^^^^^^^^^^^^^^^^^^^^^ cannot assign twice to immutable variable
For more information about this error, try `rustc --explain E0384`.
error: could not compile `playground` (bin "playground") due to 1 previous error
イミュータブルな変数には、代入できないというコンパイルエラーです。
代入可能、すなわちミュータブルにするためには、変数宣言にあたり let に続けて mut をつけます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=6bbb520249ebc44f7e341988dfad92a3  hello-mutable.rs]:
fn main() {
    let mut hello : &str = "Hello, world!";
    println!("{hello}");
    hello = "Hello, rust!";
    println!("{hello}");
}
実行結果:
Hello, world!
Hello, rust!
同一スコープで同じ変数名での宣言は可能です。
同じ型である必要はありません。ミュータブルであるかイミュータブルであるかも問いません。
同じ変数名での宣言によって、それまで変数に束縛されていた値への参照がなくなります。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=0604ce8c08449bba14b64f80c405815d 同じ変数名での宣言]:
fn main() {
    let hello : &str = "Hello, world!";
    println!("{}", hello);
    let hello = 154649;
    println!("{}", hello);
}
実行結果:
Hello, world!
154649
Rustには2種類の定数があり、どちらもグローバルスコープを含む任意のスコープで宣言することができます。また、どちらも明示的な型を持っている必要があります。
static: 静的寿命を持つミュータブルな値 静的寿命は推論されるので、指定する必要はありません。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=901ef30e5d150a91c9fed78d63a4971d ２種類の定数]:
const HELLO : &str = "Hello, world!";
static LANGUAGE: &str = "Rust";
fn main() {
    println!("{HELLO}");
    println!("{LANGUAGE}");
}
実行結果:
Hello, world!
Rust
コードを書き換えてconst宣言や（ミュータブルな）static宣言された変数に代入をしようとすると、エラーになります。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9e938e1309c6ba12f760a6c6f0c9d210  pattern.rs]:
fn main() {
    let (mut x, mut y) = (5, 29);
    println!("x={x} y={y}");
    (x, y) = (y, x);
    println!("x={x} y={y}");
}
実行結果:
x=5 y=29
x=29 y=5
このコードは、x と y の値を交換するRustの機能を示しています。
最初の行では、x に 5 を、y に 29 を代入しています。
次の行では、println! マクロでは、交換後の x と y の値を表示しています。
次の行では、(x, y) = (y, x); という操作を行っています。これは、タプルを使って複数の変数に同時に値を代入しています。この場合、(y, x) というタプルの中身を (x, y) に順番に代入しています。これにより、x の値に y の値が入り、y の値に x の値が入ります。これによって x と y の値が交換されます。
最後の println! マクロでは、交換後の x と y の値を表示しています。
このコードは、Rustのタプルを使った多値代入の機能を示しています。
Restには豊富なデータ型(''Data Types'')があり、それらを組み合わせて新しい型を作ることができます{{Cite web
|url=https://doc.rust-lang.org/book/ch03-02-data-types.html
|title=Data Types - The Rust Programming Language
|accessdate=2021/12/08
。
スカラー型は単一の値を表します。Rustには、整数、浮動小数点数、論理値、文字という4つの主要なスカラ型があります。
Rustの整数型は、符号の有無とビット幅から12種類のバリエーションがあります。
isizeとusizeのビット幅はプロセッサーのアーキテクチャーによって定義され、32ビットプロセッサーならば32、64ビットプロセッサーならば64です。
リテラル(''Literals'')とは、プログラミングのソースコードで使用される、数値や文字列などのデータを直接表現したものです。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9c41862df3833ee7bd16169631d74de7 例]:
fn main() {
    println!("{:?}", 19_800);
    println!("{:x}", 0xbadbeef);
    println!("{:o}", 0o777);
    println!("{:b}", 0b101_111_011);
    println!("{}", b'Q');
}
実行結果:
19800
badbeef
777
101111011
81
数値リテラルには、123u8 の様に型名をタイプサーフィックス(''type suffix'')として補うことで、ビット幅を明記できます（オプショナル）。
指定されない場合は（バイト以外は）i32が仮定されます（isizeではありません）。
数値リテラルには、読みやすさのため 9_281_636 のように、アンダースコア _ を補うことができます（オプショナル）。
なお、{:x}の{x}部分はプレースホルダーのファーマッティング・トレイツです。「x」なら16進数、oなら8進数、bなら2進数で出力します。
Rustには、浮動小数点数を表現するための2つの主要な型があります。それぞれの型は、IEEE-754規格に従っています。
f32: 32ビットの単精度浮動小数点数型です。精度は約6桁です。
f64: 64ビットの倍精度浮動小数点数型です。精度は約15桁です。
Rustでは、浮動小数点数リテラルを書く場合、デフォルトで f64 型になります。例えば、3.14 という浮動小数点数リテラルは、f64 型の数値になります。
以下は、f32 型と f64 型の浮動小数点数の使用例です。
fn main() {
    // デフォルトでは f64 型になる浮動小数点数
    let my_float1 = 3.14; // f64 型
    // サイズを明示して f32 型にする
    let my_float2: f32 = 2.718; // f32 型
    // 浮動小数点数同士の計算
    let sum = my_float1 + f64::from(my_float2); // f64 型にキャストして計算
    println!("Sum: {}", sum); // f64 型の結果が出力される
}
実行結果:
Sum: 5.857999935150147
 
浮動小数点数は、数値計算や科学的な計算など、精度が求められる場面で使用されます。しかし、浮動小数点数の性質や精度による注意が必要な場面もありますので、注意深く扱う必要があります。
Rustにおける論理値型の型名は bool で、真の値は true、偽の値は false です。この型は非常に基本的で、条件分岐やブール演算などで使用されます。
以下は bool 型の使用例です。
fn main() {
    let is_rust_cool = true; // 真の値を持つ変数
    let is_java_cool = false; // 偽の値を持つ変数
    if is_rust_cool {
        println!("Rust is cool!"); // 条件が true の場合に実行される
    } else {
        println!("Rust is not cool."); // 条件が false の場合に実行される
    }
    // 論理演算
    let result = is_rust_cool && is_java_cool; // 論理積 (AND) の例
    println!("Result of logical AND: {}", result); // false が出力される
}
実行結果:
Rust is cool!
Result of logical AND: false
bool 型は条件式の評価や論理演算に広く使用され、プログラムの流れを制御するための基本的な手段として重要な役割を果たします。
Rustの文字型 char はUnicodeの単一の文字を表し、32ビットで符号化されます。Unicodeのサロゲートペアを含む広範な範囲の文字を表現できます。
以下のコードは、char型を使用してUnicode文字やサロゲートペアを扱う例です。
fn main() {
    // 単一のUnicode文字の表現
    let unicode_char = '😊'; // 笑顔の絵文字 (U+1F60A)
    println!("Unicode char: {}", unicode_char);
    // サロゲートペアの表現
    let surrogate_pair = '\u{1F601}'; // 涙の絵文字 (U+1F601)
    println!("Surrogate pair: {}", surrogate_pair);
    // char型のサイズを取得
    println!("Size of char: {} bytes", std::mem::size_of::());
}
実行結果:
Unicode char: 😊
Surrogate pair: 😁 
Size of char: 4 bytes
 
ここでは、'😊' という絵文字や \u{1F601} というサロゲートペアを char型として表現しています。絵文字やサロゲートペアも正しく表示されることを確認できます。また、std::mem::size_of::() を使って char型のサイズを表示しています。
Rustには2つの主要な文字列型があります。
メモリ内のデータへの不変の参照を表します。
UTF-8でエンコードされた文字列を参照します。
文字列リテラルや他のデータ構造の一部として使用されます。
let string_slice: &str = "Hello, Rust!"; // 文字列リテラルから作成された文字列スライス
   
ヒープ上に確保された可変の文字列データを持ちます。
let mut string_object = String::from("Hello"); // String型のインスタンスを生成
string_object.push_str(", Rust!"); // 文字列を追加
   
これらの型は互いに相互変換できます。例えば、&strからStringへの変換はto_string()メソッドを使用できます。
 
let my_string: String = "Hello".to_string(); // &strからStringへの変換
   
また、Stringから&strへの変換は、&演算子を使用して参照を取得します。
 
let my_string: String = String::from("Hello");
let string_ref: &str = &my_string; // Stringから&strへの変換
   
文字列操作に関しては、String型が動的に変更可能で柔軟性があり、&str型は主に静的な文字列の参照として使用されます。
様々な文字列リテラル
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9c41862df3833ee7bd16169631d74de7 string.rs]:
fn main() {
    println!("{:?}", "hello");     // エスケープされた文字列
    println!("{:?}", r#"hello"#);  // エスケープされないraw文字列
    println!("{:?}", b"hello");    // エスケープされたバイト文字列
    println!("{:?}", br#"hello"#); // エスケープされないrawバイト文字列
}
実行結果:
"hello"
"hello"
[104, 101, 108, 108, 111]
[104, 101, 108, 108, 111]
"{:?}" はデバッグ用のフォーマット指定子で、デバッグ表示用の形式で出力します。
r#"..."# はエスケープされない raw 文字列リテラルで、内部のエスケープが無視されます。
b"..." はバイト文字列リテラルで、ASCII文字のバイト値の配列を示します。
br#"..."# はエスケープされない raw バイト文字列リテラルです。
これらのリテラルは、異なる用途で利用されることがあり、それぞれの特性や振る舞いが異なります。
Rustにおけるユニット型は()で表されます。ユニット型は特別な型であり、単一の値 () だけから成り立ちます。主に2つの用途があります：
fn do_something() {
    // 何らかの処理
}
fn main() {
    let result = do_something(); // 戻り値は () になる
    println!("result = {:?}", result);
}
struct MarkerUnit;
fn main() {
    let marker = MarkerUnit; // ユニット型を持つ構造体のインスタンス化
    println!("marker = {:?}", marker);
}
ユニット型は一見すると何も持たない型ですが、プログラムの構造を表現するために重要な役割を果たしています。特に関数の戻り値として使用されることが多いです。
複合型(''Compound Types'')は、複数の値を1つの型にまとめることができます。
Rustにはタプルとアレイという2つのプリミティブな複合型があります。
タプル(''The Tuple'')は、さまざまな型の値を1つの複合型にまとめる一般的な方法です。
タプルの長さは固定されており、一度宣言すると大きくしたり小さくしたりすることはできません。
複数の値の集まりを持つもう一つの方法として、配列(''The Array'')があります。
タプルとは異なり、配列の各要素は同じ型でなければなりません。
Rustの配列は、タプルと同じく長さが固定されています。
println! マクロなどの文字表示マクロでは、文字列中の { } の位置に指定された書式で展開します[https://doc.rust-lang.org/std/fmt/ Module std::fmt]。
C言語の標準関数 printf() と機能は似ていますが書式は大きく異なり、Pythonのf文字列との共通点が多いです。
のプレースホルダー{}を指定すればその型の自然なフォーマット（[https://doc.rust-lang.org/std/fmt/trait.Display.html fmt::Display]; 100 ならば "100"）で文字列化されます。
しかし、基数を変えた16進数や8進数や2進数などでフォーマットをしたいときはフォーマッティング・トレイツ(Formatting traits)を使います[https://doc.rust-lang.org/std/fmt/#formatting-traits Formatting traits]。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=81cb5a55fcae676c094f2b74929f09b3 Formatting traits]:
fn main() {
    println!("{:?}", 100);
    println!("{:x}", 100);
    println!("{:o}", 100);
    println!("{:b}", 100);
    println!("{}", 100);
}
実行結果:
100
64
144
1100100
100
フォーマッティング・トレイツは、Rustプログラミング言語におけるデータのフォーマット（整形）方法を定義するためのトレイト（trait）です。これらのトレイトは、std::fmtモジュールに定義されており、std::fmt::Displayやstd::fmt::Debugなど、様々なフォーマット方法を提供します。
一般的なフォーマッティング・トレイツは以下のようになります：
Display: std::fmt::Displayトレイトは、{}（中括弧）を使ったシンプルな人間が読みやすい形式での表示を提供します。これは、println!マクロやformat!マクロで使われます。
Debug: std::fmt::Debugトレイトは、{:?}を使ったデバッグ目的の表示を提供します。これは、デバッグ情報を表示する際に便利で、println!("{:?}", variable)のように使用されます。
Binary: std::fmt::Binaryトレイトは、{:#b}を使ってバイナリ表現での表示を提供します。
Octal: std::fmt::Octalトレイトは、{:#o}を使って8進数表現での表示を提供します。
LowerHex / UpperHex: std::fmt::LowerHexおよびstd::fmt::UpperHexトレイトは、それぞれ{:#x}および{:#X}を使って16進数表現での表示を提供します。
これらのトレイトは、カスタム型をフォーマットする方法を指定するために、対応するメソッドを実装することで利用されます。
例えば、Displayトレイトを実装することで、自分で定義した型を{}を使って表示することができます。
以下は、簡単な構造体PersonにDisplayトレイトを実装して、{}を使ってカスタム型を表示する例です。
 
use std::fmt;
// 構造体を定義
struct Person {
    name: String,
    age: u32,
}
// Displayトレイトの実装
impl fmt::Display for Person {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        // カスタムフォーマットを定義する
        write!(f, "Name: {}, Age: {}", self.name, self.age)
    }
}
fn main() {
    let person = Person {
        name: String::from("Alice"),
        age: 30,
    };
    // {}を使ってPerson型を表示
    println!("Person Details: {}", person);
}
実行結果:
Person Details: Name: Alice, Age: 30
この例では、Personという構造体を定義し、fmt::Displayトレイトを実装しています。fmtモジュール内のFormatter型を利用して、write!マクロを呼び出しています。main関数内でprintln!マクロを使ってPerson型を表示しています。これにより、Person型を{}を使って表示する方法が示されています。
Rustの所有概念や借用、参照などは、安全性と並行性を重視したユニークな特徴を持っています。それぞれの概念をコードとともに解説してみましょう。
Rustの所有概念は、言語の中核的な概念であり、メモリ管理とリソースの安全な取り扱いを実現するための重要な要素です。所有概念は、変数がリソースの所有権を持ち、そのリソースはスコープを抜ける際に自動的に解放されるという原則に基づいています。
Rustのコピーとムーブの動作は、変数がスタック上のデータかヒープ上のデータを参照しているかによって異なります。プリミティブ型のようなスタック上のデータはコピーされますが、ヒープ上のデータは所有権がムーブされます。
コピー可能なデータ
fn main() {
    let x = 5;
    let y = x; // xの値がコピーされる（コピー）
    println!("x: {}, y: {}", x, y); // 正常に出力される
}
 
この例では、xは整数型（i32）などのプリミティブ型で、スタック上に格納されます。xの値は単純なコピーが作成され、yにも同じ値が代入されます。そのため、両方の変数を利用できます。
ムーブされるデータ
fn main() {
    let s1 = String::from("Hello");
    let s2 = s1; // s1の所有権がs2に移動（ムーブ）
    // println!("{}", s1); // コンパイルエラー！所有権が移動したためs1は利用できない
    println!("{}", s2); // 正常に出力される
}
 
この例では、String::from("Hello")で作成した文字列はヒープ上にあり、s1の所有権はs2にムーブされます。そのため、s1を参照しようとするとコンパイルエラーが発生しますが、s2は正常に出力できます。
この違いは、スタック上のデータの単純なコピーと、ヒープ上のデータの所有権のムーブの挙動に起因しています。スタック上のデータは安価にコピーできますが、ヒープ上のデータは所有権が移動されます。
理解を助けるために、コピーとムーブの違いを表にまとめてみましょう。
コピー（Copy）: スタック上に配置されるデータや、Copyトレイトを実装した型のデータは、単純な代入などでコピーされます。元の変数が保持する値が複製され、両方の変数が別々の値を持ちます。
ムーブ（Move）: ヒープ上に配置されるデータや、Copyトレイトを実装していない型のデータは、所有権がムーブされます。変数間での代入などで、所有権が移動された後は、元の変数はその値を参照できなくなります。
これらの違いは、Rustの所有概念において重要です。特に、ムーブによってデータの所有権が移動することで、メモリ安全性と競合を回避することが可能になります。
所有権を移動させずにデータを利用するために、借用と参照が利用されます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=91624181f640bfff93914d318547bfae 借用と参照の例]:
fn main() {
    let s1 = String::from("Hello");
    // s1を借用する（イミュータブルな参照）
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}.", s1, len); // 正常に出力される
}
fn calculate_length(s: &String) -> usize {
    s.len() // sを参照して長さを返す
}
calculate_length関数では、&String型の引数を受け取り、Stringへの参照（イミュータブルな参照）を使用しています。そのため、s1の所有権を関数に渡すことなく、値を参照しています。
また、ミュータブルな参照を使って可変の値を変更できます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=1ef888bfe58461858b4cefe84d3b6fa6 ミュータブルな参照の例]:
fn main() {
    let mut s = String::from("Hello");
    change_string(&mut s);
    println!("{}", s); // "Hello, goodbye"が出力される
}
fn change_string(s: &mut String) {
    s.push_str(", goodbye");
}
&mut String型のミュータブルな参照を使って、change_string関数で文字列を変更しています。
これらのコード例は、Rustの所有概念や借用、参照についての基本的な概念を示しています。これらの機能は、安全性と並行性を強調したプログラミングを実現するための強力なツールです。
関数のパラメータに渡された変数は、所有権（Ownership）がその関数にムーブ（Move）されることがRustの所有権システムにおいて基本的な挙動です。このことを以下のコードを用いて詳しく説明しましょう。
fn main() {
    let original = String::from("Hello, Rust!"); // String型の変数originalを作成
    let moved = move_ownership(original); // originalがmove_ownership関数にムーブ
    // コンパイルエラー! originalはもう有効でない
    println!("original: {}", original);
    // 正常に動作! movedはmove_ownership関数から返された値
    println!("moved: {}", moved);
}
fn move_ownership(input: String) -> String {
    // inputの処理を行う（ここでは何もしない）
    input
}
このコードで示されているポイントは以下です：
main 関数内で、 String 型の変数 original を生成し、その所有権を保持しています。
move_ownership 関数を呼び出す際、変数 original が関数の引数として渡されます。このとき、original の所有権は move_ownership 関数にムーブされ、もはや main 関数内で original を使用することはできません。
move_ownership 関数内で、input パラメータ（ここでは String 型）の処理が行われ、その値が input を含むスコープからムーブされずに、move_ownership 関数から返されます。
main 関数内で、original を使用しようとすると、コンパイルエラーが発生します。それに対して、moved 変数は move_ownership 関数から返された値であり、その所有権はムーブされていないため、正常に使用できます。
この挙動は、Rustの所有権システムの一部であり、変数を関数に渡すと、所有権がムーブされることで、データ競合や予測不能な挙動を防ぐのに役立ちます。つまり、Rustはコピーが高コストなデータ（例: String やファイルハンドル）の二重所有権を防ぎ、メモリ安全性を確保するために所有権のムーブを使用します。
所有権を共有するために、cloneメソッドを使用してデータの複製を作成できます。
この複製は新しい所有者を持ち、元のデータを変更しても影響を受けません。
fn main() {
    let data1 = vec![1, 2, 3];
    let data2 = data1.clone();  // データの複製
    println!("{:?}", data1);  // data1は所有権を保持
    println!("{:?}", data2);  // data2も所有権を持つ
}
{{コラム|Rustの所有権システムについてのまとめ|2=Rustの所有権システムは、言語の最も特徴的な概念の一つで、メモリ管理とプログラムの安全性を向上させる役割を果たします。
各値は所有者（Owner）を持ちます。
各値はいつかは所有者からスコープを抜けて消去されます。
各値の所有権は、1つの所有者にしか属しません。
所有権は値の転送として理解され、変数の代入時に所有権が移動します。これにより、元の変数は無効になり、新しい変数が所有権を持つことになります。
cloneメソッドを使用してデータのコピーを作成し、所有権を共有できます。これにより、複数の変数が同じデータを持つことが可能となります。
所有権を譲渡せずにデータにアクセスするための仕組みで、不変な借用（immutable borrowing）と可変な借用（mutable borrowing）があります。借用は所有権を一時的に保持し、データへのアクセスを提供します。
関数に値を渡すと、所有権が関数にムーブされます。関数が所有権を持つと、元の変数は無効になり、関数内で変数を使用できます。これにより、データの複製やコピーを回避できます。
所有権システムはメモリ安全性と競合の防止に役立ち、コンパイル時のエラーを通じてプログラムの安全性を確保します。データ競合やメモリリークを防ぎ、プログラマに信頼性の高いコードを書かせます。
所有権システムと関連するライフタイムの概念は、借用や参照のスコープを制御し、メモリリークを防止します。ライフタイム注釈（lifetime annotations）を使用して、データの有効な範囲を指定します。
Rustの所有権システムは、高度なメモリ管理とプログラムの安全性を提供し、プログラマに信頼性の高いシステムソフトウェアを開発する手助けをします。一度理解するのに時間がかかるかもしれませんが、その代償として、高いレベルのセキュリティとパフォーマンスを得ることができます。
Rustの変数の識別子（Identifier）について説明します。識別子は変数、関数、モジュール、および他のRustプログラムの要素に名前を付けるために使用される名前です。
Rustの識別子にはいくつかの規則があります：
識別子はアルファベット、数字、アンダースコア（_）の組み合わせからなります。
識別子はアルファベット（大文字または小文字）またはアンダースコアで始まる必要があります。数字で始まることはできません。
識別子はキーワード（予約語）として定義されている単語を使用できません。たとえば、let、fn、match などのキーワードは識別子として使用できません。
識別子は大文字と小文字を区別します。つまり、my_variable と My_Variable は異なる識別子です。
一般的な識別子の例:
Rustの識別子はわかりやすく、意味のある名前を使うことが推奨されます。また、Rustのコーディング規約に従うことも重要です。識別子はプログラムの可読性と保守性に影響を与えるため、適切な名前を選択することが重要です。
Rustにおいて、スコープ（Scope）は変数やリソースの有効な範囲を指します。スコープ内で定義された変数は、そのスコープ内でのみアクセス可能であり、スコープを抜けると変数は自動的に解放されます。スコープの概念は、メモリリークや予期しない副作用を防ぐために非常に重要です。
Rustには主にブロックスコープと関数スコープの2つのタイプのスコープがあります。
ブロックスコープは、一連のコードが中括弧 {} で囲まれた場合に発生します。中括弧内の変数は、そのブロックスコープ内でのみ有効です。
以下はブロックスコープの例です：
fn main() {
    let outer_variable = 42;
    {
        let inner_variable = 10;
        println!("inner_variable: {}", inner_variable);
    } // inner_variableのスコープはここで終了
    // inner_variableにはアクセスできない
    // println!("inner_variable: {}", inner_variable);
    println!("outer_variable: {}", outer_variable);
}
この例では、inner_variable は中括弧内でのみ有効であり、外部からアクセスできません。しかし、outer_variable は中括弧の外部でもアクセス可能です。
関数スコープは、関数内で定義された変数がその関数内でのみ有効であることを示します。
以下は関数スコープの例です：
fn main() {
    let outer_variable = 42;
    fn inner_function() {
        let function_variable = 5;
        println!("function_variable: {}", function_variable);
    }
    inner_function(); // inner_function内での変数にアクセスできる
    // function_variableにはアクセスできない
    // println!("function_variable: {}", function_variable);
    println!("outer_variable: {}", outer_variable);
}
function_variable は inner_function 内でのみ有効で、inner_functionを呼び出すことでアクセスできます。
Rustの所有権システムは、スコープと密接に関連しています。変数が特定のスコープ内で有効である場合、そのスコープを抜けると変数の所有権は無効になります。これにより、リソースの安全な解放が保証され、メモリリークやダングリングポインタの問題が回避されます。
スコープと所有権の組み合わせは、Rustのプログラムの安全性と信頼性を高める重要な要素です。スコープをうまく活用し、不要な変数の寿命を短くしてリソースを効率的に管理できるようにしましょう。
Rustのライフタイムは、Dangling Reference（無効な参照）を防ぐための重要な概念です。これは、参照が有効なデータを参照している間、そのデータが存在していることを保証するために導入されています。
Rustのライフタイムは、参照が指すデータが存在するスコープを表現し、コンパイラによって所有権やライフタイムのルールに違反しないように検証されます。これにより、コンパイラがコードを解析し、参照が有効な間のみデータにアクセスできることを保証します。
Dangling Referenceは、プログラムが無効なメモリ領域を参照しようとすることで発生する問題です。例えば、参照が指すデータがスコープを抜けた後に破棄されてしまった場合、その参照は無効なものとなります。Rustのライフタイムは、このような問題を静的に（コンパイル時に）検出し、Dangling Referenceを防ぐための仕組みとして機能します。
ライフタイムの概念により、コンパイラは参照の寿命をトラッキングし、参照が有効なデータを参照していることを保証します。これにより、実行時にDangling Referenceが発生する可能性を排除し、メモリの安全性を確保します。
ライフタイムを使用してDangling Referenceを回避する例を示します。以下の例では、ライフタイムを使用して参照が有効な間のみデータにアクセスできるように制御しています。
struct MyStruct<'a> {
    data: &'a str,
}
fn main() {
    let string_data = String::from("Hello, Rust!");
    {
        let my_struct;  // my_structのスコープを新たに定義
        {
            // `string_data`の参照を`MyStruct`に渡す
            my_struct = MyStruct { data: &string_data };
            // `my_struct`が有効なスコープ内でデータを表示
            println!("{}", my_struct.data);
        } // ここで`my_struct`のスコープが終了する
        // この時点で`my_struct`の参照はスコープ外になるため、
        // `string_data`が無効になる前に`my_struct`が使用されることはない
    } // `string_data`のスコープが終了する
    // ここで`string_data`はスコープ外になる
    // したがって、`my_struct`の参照も同時に無効になる
}
 
この例では、MyStructにstring_dataへの参照を渡し、my_structが有効なスコープ内でデータを使用しています。その後、my_structが有効なスコープを抜ける前にstring_dataのスコープが終了するため、Dangling Referenceが発生することはありません。
Rustのライフタイムシステムは、このようにスコープと参照の寿命をトラッキングし、参照が有効な間のみデータへのアクセスを許可します。これにより、Dangling Referenceをコンパイル時に防ぐことができます。
有効性の保証: ライフタイムは、参照が有効である期間を定義します。これにより、コンパイラは参照が無効化されたり、有効でないメモリを参照しようとする問題を検知できます。
参照のスコープ: ライフタイムは、参照が使用可能なスコープを定義します。参照はそのスコープ内でのみ有効であり、スコープ外では無効になります。
引数や返り値: 関数の引数や返り値にライフタイム注釈を追加することで、参照の有効期間を示します。
構造体とメソッド: 構造体やメソッドの定義でライフタイムを使うことがあります。特に、参照を持つ構造体の定義においてライフタイムは重要です。
struct MyStruct<'a> {
    data: &'a str,
}
impl<'a> MyStruct<'a> {
    fn get_data(&self) -> &'a str {
        self.data
    }
}
Rustでは、ライフタイムの一部は省略されることがあります。コンパイラが推論可能な場合は、ライフタイムの注釈を省略できます。ただし、省略ルールには厳密な規則があります。
'staticはプログラム全体のライフタイムを示します。プログラムの実行中に常に存在し続けるデータやリソースに使用されます。
static GLOBAL_VALUE: i32 = 100;
fn main() {
    let local_value: &'static i32 = &GLOBAL_VALUE;
}
ライフタイムはRustの主要な安全性の一部であり、メモリ安全性を保証するための強力なツールです。適切に理解して利用することで、メモリリークや無効な参照による問題を防ぐことができます。
スコープは、Rustにおけるライフタイム概念に密接に関連しています。ライフタイムは基本的には参照の有効期間を表し、その有効期間はスコープによって定義されます。
スコープ: コード内の特定の部分で変数が有効である期間を示します。変数がスコープに入ると有効になり、スコープを抜けると無効になります。スコープは波括弧 {} で囲まれたブロックや、関数の本体などで定義されます。
{
    let variable = 10; // 変数のスコープ開始
    // ... ここで variable が有効 ...
} // 変数のスコープ終了
ライフタイム: 参照が有効な期間を示します。変数への参照を作成する際にそのライフタイムが重要になります。参照はそのライフタイム内でのみ有効であり、スコープを抜けると無効になります。
fn print_string(s: &str) {
    println!("{}", s);
}
fn main() {
    let string = String::from("Hello");
    print_string(&string); // string の参照が関数のスコープ内で有効
} // string のスコープ終了、参照も無効になる
 
ライフタイムとスコープは互いに関連しており、変数が有効な期間がスコープによって定義されると、その変数への参照の有効期間も同様にスコープによって制限されます。このようにして、Rustのコンパイラは参照の有効性を追跡し、安全性を確保します。
所有権とライフタイムは、Rustのメモリ管理における重要な概念ですが、やや異なる側面を持っています。
所有権:
Rustの所有権システムは、変数に対するデータの所有権を定義します。変数が特定のデータを所有している場合、その変数がスコープを抜けるとデータも解放されます。
所有権ルールにより、特定のデータは同時に複数の所有者を持つことができません。一つのデータに対する所有権は一つの変数にしか与えられません。
fn main() {
    let s1 = String::from("Hello");
    let s2 = s1; // s1の所有権がs2にムーブ（転送）される
    // s1は所有権を失い、スコープを抜けることができる
    println!("{}", s2); // s2は有効
} // s2のスコープ終了、s2の所有権が終了しデータが解放される
ライフタイム:
ライフタイムは、参照が有効である期間を示します。参照はそのライフタイム内でのみ有効であり、スコープ外では無効になります。
所有権とライフタイムは密接に関連しており、所有権が終了した後は、そのデータへの参照も無効になります。
fn print_string(s: &str) {
    println!("{}", s);
}
fn main() {
    let string = String::from("Hello");
    print_string(&string); // stringの参照が関数のスコープ内で有効
} // stringのスコープ終了、参照も無効になる
所有権とライフタイムは共に、Rustがメモリの安全性を確保するための要素です。所有権システムはメモリの解放を自動的に行い、ライフタイムは参照の有効性を管理し、無効な参照が存在しないようにします。両者が組み合わさることで、Rustはメモリリークやダングリングポインタ（無効な参照）を防止し、安全で信頼性の高いコードを作成することができます。
などの制御構造も式です。
Rust は、if と match の2つの分岐構文を持ちます。
ifは、条件式に基づき分岐し、分岐先の式を評価します。
ifの値は、分岐先の式の値です。
elseを省略し条件式が偽であった場合のifの値は () です。
構文:
if-expr := if 条件式 '{' 式1 '}' [ else '{' 式2 ] '}'
fn main() {
    let i = 0;
    if i {
        println!("zero");
    }
}
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if i {
  |        ^ expected `bool`, found integer
For more information about this error, try `rustc --explain E0308`.
Rustでは、ifに限らず、条件式は、bool 型でなければいけません。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=2c8960df447a87aaeaecced963d20cde if.rs]:
fn main() {
    let i = 0;
    if i == 0 {
        println!("零");
    } else {
        println!("非零");
    }
    let s = if i == 0 {
        "ゼロ"
    } else {
        "非ゼロ"
    };
    println!("{}", s);
}
実行結果:
零
ゼロ
気をつけたいのは、式の値が参照されるifでは、それぞれの式（ここでは "ゼロ" と "非ゼロ"）にセミコロン ; を付けてはいけない点です。
もし セミコロン ;  をつけると、ブロックの値は、Unit 型 () になります。
ifの、分岐先の2つの式の型は同じでなければいけません。
else節が省略された場合は、Unit 型を返さなければいけません。
式の最後に、セミコロン}; が必要ということですC言語系では、式を文にする為いに}; が必要です。Rustもそう説明されている場合がありますが、Rustでは式の型の一致が目的です。。
また、let s = if i == 0 {の文末の}; のセミコロンも忘れがちです。
Rust では if に限らず、コードブロックは式の一種で値を返しますコードブロックが値を持つプログラミング言語としては、BCPL, Ruby, ScalaやKotlinがあります。。その場合、コードブロックの最後の式がコードブロックの値となりセミコロン ; は不要で、もし、 ; をつけると ; の次の式（＝空文）の値 () がコードブロックの値になります。
この特徴は、関数型プログラミングを意識したものですが、同時に後に説明する所有権の移譲で重要な役割を果たします。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=e3c9a903bc6baab687f697a83bde8928 if-else.rs]:
fn main() {
    let n = 0.0 / 0.0;
    if n < 0.0 {
        println!("負の数");
    } else if n > 0.0 {
        println!("正の数");
    } else if n == 0.0 {
        println!("零");
    } else {
        println!("{n}");
    }
}
実行結果:
NaN
このコードの中で、次のことが行われています：
n に NaN（Not a Number）を代入しています。0.0 / 0.0 は浮動小数点数のゼロで割り算を表し、NaN を返します。
if 文で n の値に応じて条件分岐しています。
n が負の数より小さい場合は、"負の数" と出力します。
n が正の数より大きい場合は、"正の数" と出力します。
n がゼロと等しい場合は、"零" と出力します。
それ以外の場合は、n の値を {n} という形式で出力します。
しかし、Rustの浮動小数点数型では、NaN は < や > 、== などの比較演算子によって、他の数値との大小や等価性を比較することはできません。なぜなら NaN は "not a number" であり、数値としての大小関係が定義されていないためです。
そのため、このコードでは n が NaN である場合、どの条件にも合致せず、最後の else ブロックが実行されることになります。このブロックでは、n の値そのものを {n} という形式で出力しようとしています。
Rustでは、C言語のNULLに相当する値は None です。
通常の変数は None の代入は受付けませんが、Some() を使うと None を取り得る変数が宣言できます[https://doc.rust-lang.org/stable/std/option/enum.Option.html Option in std::option - Rust]。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=afb9193c50a316090b6e3119f994f8cf some.rs]:
fn main() {
    let mut x = Some(0);
    println!("{:?}({})", x, type_of(x));
    x = None;
    println!("{:?}({})", x, type_of(x));
}
fn type_of(_: T) -> &'static str {
    std::any::type_name::()
}
実行結果:
Some(0)(core::option::Option)
None(core::option::Option)
Some() 及び None は、標準ライブラリ std::option で定義されていますが、初期化済みなので Use することなく、接頭辞Option::なしで使えます。
Rustには、if letという特別な制御構造があります。if letは、match式を簡略化するために使用されます。if let式は、単一のパターンを使用して、変数が指定された値にマッチした場合にのみ式を実行します。if letを使用すると、冗長なマッチングのコードを削減できます。
以下は、if letを使用した例です。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=0614af1127dbc6ec0d871443b16e6a67 if-let.rs]:
fn main() {
    let mut v = vec![2, 3, 5];
    if let Some(x) = v.pop() {
        println!("x = {}", x)
    } else {
        println!("done!")
    }
    if let Some(x) = v.pop() {
        println!("x = {}", x)
    } else {
        println!("done!")
    }
    if let Some(x) = v.pop() {
        println!("x = {}", x)
    } else {
        println!("done!")
    }
    if let Some(x) = v.pop() {
        println!("x = {}", x)
    } else {
        println!("done!")
    }
    if let Some(x) = v.pop() {
        println!("x = {}", x)
    } else {
        println!("done!")
    }
}
実行結果:
x = 5
x = 3
x = 2
done!
done!
.pop()メソッドは、ベクターから最後の要素を取り出し、それを返します。ただし、ベクターが空である場合はNoneを返します。
最初の行では、vec![2, 3, 5]という3つの要素を持つベクターを作成しています。
その後、5回のif let式を使用して、ベクターから要素を取り出し、それを表示するか、ベクターが空の場合にはdone!と表示します。
各if let式では、変数xを定義しています。
v.pop()の返り値がSomeであれば、ベクターの最後の要素が変数xに束縛され、println!マクロを使用してxを表示します。
そうでない場合、すなわち、ベクターが空である場合は、else節が実行されて、done!が表示されます。
Rustにおけるmatchは、値が複数のパターンのいずれかにマッチする場合に、それぞれに対応する処理を実行する制御構文です。構文は以下の通りです。
構文:
match_expr ::= 'match' expr '{' match_arm* '}'
match_arm ::= pattern '=>' expr (',' | ';')?
pattern ::= '_' | literal | identifier | ref_pattern | mut_pattern | struct_pattern | tuple_pattern | range_pattern | slice_pattern | box_pattern | '(' pattern '|' pattern ')' | '&' pattern | '@' pattern | refutable_pattern
ref_pattern ::= '&' (mut)? identifier
mut_pattern ::= 'mut'? identifier
struct_pattern ::= path '{' field_pattern (',' field_pattern)* ','? '}'
field_pattern ::= identifier ':' pattern
tuple_pattern ::= '(' (pattern (',' pattern)*)? ')'
range_pattern ::= literal '..' literal
slice_pattern ::= '[' (pattern (',' pattern)* ','?)? ']'
box_pattern ::= 'box' pattern
refutable_pattern ::= pattern ('@' identifier)?
ここで、exprは任意の式を表し、literalはリテラルを表します。また、pathはパスを表し、identifierは識別子を表します。mutはミュータビリティを表し、','と';'はそれぞれ,と;を表します。|はOR演算子を表し、'&'は参照を表し、'@'はパターンの変数名を表します。また、refutable_patternはマッチングが失敗する可能性のあるパターンを表します。
パターンは様々なものを指定することができますが、ここではいくつか代表的なものを説明します。
値を直接指定する: 3のように、具体的な値を指定します。
ワイルドカードを使う: _のように、どの値にもマッチするパターンです。
変数をバインドする: xのように、パターンに変数を書くことで、マッチした値を変数に束縛することができます。
ガード条件を指定する: x if x > 0のように、マッチした値に対して条件を指定することができます。
以下に、具体的な例を示します。
コード例:
let x = 42;
match x {
    0 => println!("zero"),
    1 => println!("one"),
    2..=10 => println!("two to ten"),
    _ => println!("something else"),
}
let mut v = vec![1, 2, 3];
match v.pop() {
    Some(x) => println!("popped value: {}", x),
    None => println!("no value"),
}
let x = Some(42);
match x {
    Some(y) if y > 0 => println!("positive value: {}", y),
    Some(_) => println!("zero or negative value"),
    None => println!("no value"),
}
実行結果:
最初の例は、変数xに対してmatch式を使用して、xが異なる値を持つ場合に異なる処理を実行する方法を示しています。xが0の場合、println!("zero")が実行されます。同様に、xが1の場合、println!("one")が実行され、xが2から10までの範囲にある場合、println!("two to ten")が実行されます。それ以外の場合は、println!("something else")が実行されます。この例では、_はワイルドカードパターンとして使用され、どの値にも一致するようになっています。
2番目の例は、match式を使用して、vecの最後の値を取得する方法を示しています。v.pop()がSome(x)を返す場合、println!("popped value: {}", x)が実行され、Noneを返す場合は、println!("no value")が実行されます。
3番目の例では、match式を使用して、Option型の値に対してパターンマッチングを行う方法を示しています。xがSome(y)を返し、yが0より大きい場合、println!("positive value: {}", y)が実行されます。yが0以下の場合、println!("zero or negative value")が実行されます。また、xがNoneの場合、println!("no value")が実行されます。この例では、ifを使用して、Some(y)の条件を更に厳密化しています。この機能をガードと呼びます。
C言語のswitch文と異なり、Rustのmatch式は、すべてのパターンをカバーしていない場合は、コンパイル時に警告を出します。これにより、プログラムにエラーが含まれている可能性がある場合に、それを事前に検出することができます。
Rustには、以下のような反復構文があります。
それぞれの構文について、詳しく解説していきます。
Rust の for は、指定された範囲内の値を反復処理するために使用されます。通常、配列、ベクトル、範囲、またはイテレータなどの反復可能オブジェクトに対して使用されます。
構文:
for_expression = "for" loop_variable "in" expression "{" statement* "}";
loop_variable = pattern;
expression = (expression_binop | expression_unop | expression) ;
pattern = identifier | "_" | literal ;
for_expressionはforループを表し、 loop_variableは反復処理のために使用される変数、 expressionは反復処理の対象となるデータのソース、 statementはループ内で実行される文を表します。 patternは、ループ変数の型と一致するパターンを表します。
identifierは、識別子の名前を表します。 literalは、文字列、数値、真偽値などのリテラル値を表します。
forループは、 loop_variableによって定義された変数に expressionで指定されたデータソースの値を順番に割り当て、それぞれの値に対して statementを実行します。
identifierは識別子を、literalはリテラルをしめします。
Rustにおけるrangeは、範囲を表す型です。範囲の生成には2つの主要な方法があります。
..（半開区間）
start..endの形式で使用され、startからendの手前（endは含まれない）までの範囲を生成します。
例えば、1..5は1から4までの範囲を生成します。
..= （閉区間）
start..=endの形式で使用され、startからendまでの閉区間を生成します（endも含まれます）。
例えば、1..=5は1から5までの範囲を生成します。
これらの範囲はforループの反復やイテレータの作成など、さまざまな場面で使用されます。例えば、forループやイテレータを使って範囲内の要素を処理することができます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=a3cd190fbd860ce8efb0d6276fb0858a for-in-range.rs]:
fn main() {
    // 半開区間の使用例
    for i in 1..5 {
        println!("{i}"); // 1, 2, 3, 4が出力される
    }
    // 閉区間の使用例
    for i in 1..=5 {
        println!("{i}"); // 1, 2, 3, 4, 5が出力される
    }
}
範囲は整数や文字など、多くの型で使用できます。範囲の使用はイテレーションや特定の範囲内の操作を行う際に便利です。
Rustにおけるiter()は、コレクション（ベクター、配列、ハッシュマップなど）をイテレート可能な形に変換するメソッドです。イテレータは、コレクション内の要素を1つずつ処理するための仕組みを提供します。
基本的な使い方は以下のようになります:
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=d45c8c0ad55adb01e50456dd7270983c iter.rs]:
fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    // ベクターのイテレータを作成する
    let mut iter = vec.iter();
    // イテレータを使って要素に順番にアクセスする
    while let Some(value) = iter.next() {
        println!("{value}");
    }
}
実行結果:
1
2
3
4
5
iter()メソッドは、イテレータを作成するための最も基本的な手段ですが、さまざまな応用もあります。
.map(): イテレータを他の形に変換する場合に使われます。たとえば、各要素に対して関数を適用して新しいイテレータを作成します。
fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    // 各要素を2倍する新しいイテレータを作成する
    let doubled_iter = vec.iter().map(|x| x * 2);
    for value in doubled_iter {
        println!("{value}");
    }
}
.filter(): 条件に一致する要素のみを含む新しいイテレータを作成します。
fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    // 偶数の要素だけを含む新しいイテレータを作成する
    let even_iter = vec.iter().filter(|&x| x % 2 == 0);
    for value in even_iter {
        println!("{value}");
    }
}
.fold(): イテレータ内の要素を畳み込んで単一の値に集約します。
fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    // 要素の合計を計算する
    let sum = vec.iter().fold(0, |acc, &x| acc + x);
    println!("合計: {sum}");
}
.reduce(): イテレータ内の要素を畳み込んで単一の値に集約します。
fn main() {
    let vec = vec![1, 2, 3, 4, 5];
    // 要素の合計を計算する
    let sum = vec.into_iter().reduce(|acc, x| acc + x);
    println!("合計: {:?}", sum);
}
これらはiter()を基盤として利用する機能の一部です。Rustのイテレータは非常に強力で、関数型プログラミングの概念を取り入れながら、効率的で安全なコードを記述するための重要な手段となっています。
iter()メソッドに加えて、rev()メソッドを使用すると、要素を逆順で取り出すこともできます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=83d50bb12645221a766052413a9d73b8 iter-rev.rs]:
fn main() {
    let v = vec![1, 3, 5, 7, 11];
    for x in v.iter().rev() {
        println!("x = {}", x)
    }
}
実行結果:
x = 11
x = 7
x = 5
x = 3
x = 1
このRustのコードは、 forループを使用して、ベクトル vの要素を反復処理し、各要素の値を出力するものです。ただし、 vの要素を逆順に処理します。
v.iter().rev()は、 vのイテレータを取得し、そのイテレータを逆順にするためのメソッドです。これにより、ベクトルの最後の要素から始まり、最初の要素まで逆順に反復処理します。
forループの本体では、 println!マクロを使用して、現在の xの値を表示しています。 {}はプレースホルダーであり、その場所に変数の値が挿入されます。この例では、 {}の中に xを指定して、ループの反復ごとに変化する xの値を表示しています。
enumerate()メソッドを使用すると、要素のインデックスと値を同時に取り出すこともできます。
コード例:
let v = vec![1, 2, 3];
for (i, val) in v.iter().enumerate() {
    println!("{}: {}", i, val);
}
このコードでは、v.iter().enumerate()メソッドを使用して、vのイテレータを作成し、各要素のインデックスと値を同時に反復処理しています。forループの本体では、変数iを使ってインデックス、valを使って値を表示しています。
zip()メソッドを使用すると、複数のイテレータを同時に取り出すことができます。
コード例:
let v1 = vec![1, 2, 3];
let v2 = vec!["one", "two", "three"];
for (i, val) in v1.iter().zip(v2.iter()) {
    println!("{}: {}", i, val);
}
このコードは、zip()メソッドを使用して、2つのベクトルを同時に反復処理する方法を示しています。
最初の行で、整数のベクトルv1と文字列のベクトルv2を定義しています。
次に、forループを使用して、v1.iter()とv2.iter()のイテレータを同時に取り出します。このとき、(i, val)というタプルの形式で、それぞれのイテレータから次の要素を取り出します。
println!マクロの中で、{}にiとvalをそれぞれ表示しています。{}の中にある:は区切り文字で、iとvalを区別するために使用されています。
Rustにおいて、whileは指定した条件式がtrueである限り、ブロック内のコードを繰返し実行する制御構文です。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=47dc5b7c9d866b3f5913a77b9a55988e while.rs]:
fn main() {
    let mut i = 0;
    while i < 5 {
        println!("i = {}", i);
        i += 1
    };
}
実行結果:
i = 0
i = 1
i = 2
i = 3
i = 4
このプログラムは、0から4までの数字を順番に表示するプログラムです。whileループを使用して、条件式i < 5がtrueである間、ループを継続します。ループの各イテレーションでは、println！マクロを使用して、変数iの現在の値を表示します。iの値は、ループ本文の最後でi += 1によって1ずつ増加します。条件式i < 5がfalseになったとき、ループが終了します。最終的に、0から4までの数字が順番に表示されます。
Rustのwhile letは、ループ処理の一種で、パターンマッチングを行い、パターンにマッチする値をループ内で取り出しながらループを繰り返します。
while letは、match構文の糖衣構文で、一つの値を取り出してパターンマッチングを行い、パターンにマッチする場合は値を取り出し、マッチしない場合はループを終了します。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=0764d8389e3afc0854b4223b8db5a32b while-let.rs]:
fn main() {
    let mut n = Some(0);
    while let Some(i) = n {
        n = if i > 5 {
            None
        } else {
            println!("i = {}", i);
            Some(i + 1)
        }
    }
}
実行結果:
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
このコードは、n という Option 型の変数を定義し、初期値を Some(0) として設定します。そして、while ループを使って n の値を取り出しながら、それが None でなければループを続けます。
while let の条件式では、n が Some(i) とパターンマッチされ、i に値がバインディングされます。このパターンマッチにより、n が Some(i) でなければループは終了します。
ループ本体では、i が 5 を超える場合は、n を None に更新してループを終了します。そうでなければ、i を表示して、Some(i + 1) を n に代入してループを継続します。
このプログラムの出力は、0 から 5 までの数値が順番に表示されます。最後に None が表示されます。
Rustのwhile letは、反復可能な値に対して、パターンマッチングを行いながら反復処理を行うことも出来ます。ベクトルに対してwhile letを使うと、ベクトルの末尾から要素を取り出しながら反復処理を行うことができます。
[https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=6b252d13f67df88f533e55dab5d3397c while-let-again.rs]:
fn main() {
    let mut v = vec![1, 3, 5, 7, 11];
    while let Some(x) = v.pop() {
        println!("x = {}", x)
    }
}
実行結果:
x = 11
x = 7
x = 5
x = 3
x = 1
このコードは、可変長配列vに値を追加し、whileループでその配列から値を取り出し、それを表示するものです。
まず、可変長配列vにvec![1, 3, 5, 7, 11]という値を設定しています。その後、while let式を使って、v.pop()の戻り値がSome(x)である限り、ループが継続されます。v.pop()は、vの最後の要素を取り出し、その要素があればSomeで包んで返し、なければNoneを返します。
while let式では、取り出した値がSome(x)である場合に、println!("x = {}", x)を実行してxの値を表示します。
つまり、このコードはvの末尾から要素を取り出しながら、取り出した要素の値を表示するという処理を続け、最後に配列が空になったらループを終了します。
{{コラム|Rustにdo-whileはありません|2=
Rustにdo-whileはありません。while の条件式に do のブロックを詰め込むことで同じことが実現できます。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=534d7cfaf805c7e8d99d4c1ba95ed3ab pseudo-do-while.rs]:
fn main() {
    let mut i = 100;
    while {
        println!("{}", i);
        i += 1;
        i < 10
    } {}
}
実行結果:
100
whileの条件式が省略されたかのように見えますが、4,5,6行目を含むブロックが、while の条件式となり値はブロックの最後の6行目の式の値です。
7行目の {} がループ本体です。
loopを使った例:
fn main() {
    let mut i = 100;
    loop {
        println!("{}", i);
        i += 1;
        if !(i < 10) {
            break;
        }
    }
}
loop のブロックの最後に脱出条件を書いた方がわかりやすいかもしれません。
loopは、明示的な条件式の指定がない限り、無限に繰り返されます。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=9349b3eff79e311c70c87d20942cf8f2 loop-and-break.rs]:
fn main() {
    let mut i = 0;
    let result = loop {
        if i > 3 {
            break 100;
        }
        println!("i = {}", i);
        i += 1;
    };
    println!("result = {}", result);
}
実行結果:
i = 0
i = 1
i = 2
i = 3
result = 100
最初に、変数iを0に初期化します。そして、loop構文で、iが3より大きくなるまで繰り返します。
各反復中に、if文が使用されています。ifの条件式は、iが3より大きくなった場合にはbreak 100;が実行され、loopから脱出します。そうでない場合は、println!()関数を使用して、iの値を出力し、iを1増やします。
最後に、loopから脱出した後にresult変数に格納される値は、break文の引数で指定された100です。そして、println!()関数を使用して、resultの値を出力します。
つまり、このコードは、iを0から3まで順に増やしながら、各値を出力し、iが3より大きくなったら100を返し、その後にresultの値を出力するという処理を行っています。
continue を実行すると、ループのブロック内の残りの処理がスキップされ、反復処理が続行されます。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=49f7412cec92162b9d77881e08f43138 continue.rs]:
fn main() {
    let mut i = 0;
    let result = loop {
        if i > 10 {
            break 100;
        }
        if i % 2 == 0 {
            i += 1;
            continue;
        }
        println!("i = {}", i);
        i += 1;
    };
    println!("result = {}", result);
}
実行結果:
i = 1
i = 3
i = 5
i = 7
i = 9
result = 100
このコードは、0から10までの奇数を出力するプログラムです。
まず、i変数を定義して0で初期化し、result変数を宣言しています。次に、loopキーワードでループを開始します。
ループ本体では、if文を使ってiが10より大きくなったら、breakキーワードを使ってループを抜けます。これにより、11以上の奇数が出力されることはありません。
次に、iが偶数である場合は、continueキーワードを使ってループの先頭に戻ります。これにより、偶数はスキップされます。
最後に、println!マクロを使って現在のiの値を出力し、iを1増やします。
ループが終了したら、最後にresultの値を出力します。breakキーワードが値を返すため、このループはresultに100を設定します。
{{コラム|Rustのプログラミングでつまづきやすいところ|2=Rustはセーフティ、パフォーマンス、そしてエクスプレッションの柔軟性を組み合わせた高度なプログラミング言語です。初めてRustを使う場合、以下のようなトピックでつまづくことがよくあります。
所有権と借用: Rustでは、各値には所有者があり、値のライフサイクルを追跡する必要があります。また、他のコードに値を渡すときは、その値を一時的に借りる必要があります。これらの概念が理解しづらい場合があります。
ライフタイム: Rustでは、各値にはライフタイムがあり、その値が使用される期間を決定します。ライフタイムの概念が不明瞭になりがちで、特に複雑なデータ構造を扱う場合に問題が発生することがあります。
パフォーマンスの最適化: Rustは高速な実行時パフォーマンスを提供しますが、それを達成するためには、手動でメモリ管理や最適化を行う必要があります。これらの最適化は、Rustの型システムと他の言語との違いを理解する必要があります。
コンパイラエラー: Rustのコンパイラは非常に厳格で、コードがコンパイルできない場合があります。エラーメッセージは詳細で役に立ちますが、初めて見た場合は驚くかもしれません。
本書では、これらのトピックについて順次取り上げてゆきます。
Rustのマクロは、macro_rules!を使ったマクロとproc_macroを使ったプロシージャマクロの2種類があります。macro_rules!を使ったマクロはパターンマッチングを用いて簡易的なマクロを定義します。一方、proc_macroを使ったプロシージャマクロは、Rustのコードを受け取り、変換したり、新しいコードを生成するためのより柔軟なマクロです。
macro_rules!は、パターンに基づいてマッチングし、そのパターンに一致した場合に指定されたコードを生成する簡易なマクロを定義します。
例えば、vec!マクロは、可変長のベクタを生成するマクロです。これはmacro_rules!を使って次のように実装されています。
macro_rules! vec {
    // パターンマッチで要素を取得して新しいベクタを生成
    ( $( $x:expr ),* ) => {
        {
            let mut temp_vec = Vec::new();
            $(temp_vec.push($x);)*
            temp_vec
        }
    };
}
fn main() {
    // `vec!`マクロを使ってベクタを生成
    let my_vec = vec![1, 2, 3, 4];
    // 生成されたベクタを表示
    println!("{:?}", my_vec);
}
これは、vec![1, 2, 3]を使うと、[1, 2, 3]というベクタを生成します。このマクロは、$( $x:expr ),*のパターンに一致して、指定された式（$x）をベクタに挿入するコードを生成します。
macro_rules!を使わずにマクロを定義する方法もあります。これは、プロシージャマクロ（proc_macro）を使用した方法です。proc_macroは、macroキーワードによって定義される関数の一種で、Rustのコードを受け取り、そのコードを操作して変換することができます。
例えば、vec!マクロをmacro_rules!ではなく、プロシージャマクロとして定義する場合は、proc_macroを使います。
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Expr, parse_quote};
pub fn my_vec(input: TokenStream) -> TokenStream {
    // 入力をパース
    let input_expr: Expr = parse_macro_input!(input);
    // 入力を取得して新しいベクタを生成するコードを生成
    let expanded = quote! {
        {
            let mut temp_vec = Vec::new();
            temp_vec.push(#input_expr);
            temp_vec
        }
    };
    // TokenStreamに変換して返す
    TokenStream::from(expanded)
}
この例では、proc_macroとしてmy_vecという新しいマクロを定義しています。my_vecは、proc_macroの関数として定義され、Rustのコードを受け取り、それを操作して新しいコードを生成します。
このプロシージャマクロを使うと、次のようにマクロを呼び出すことができます。
fn main() {
    let my_vec = my_vec!(42);
    println!("{:?}", my_vec); // [42]
}
この例では、my_vec!マクロを使用して、引数として42を渡しています。このマクロは、引数を含むベクタを生成するもので、my_vec!(42)は[42]というベクタを生成します。
この方法では、proc_macroを使用して、macro_rules!を使わずに独自のマクロを定義できます。ただし、この方法ではproc_macroと関連するライブラリ（syn、quoteなど）を使用する必要があります。
マクロ関数は、macro_rules!マクロを使って定義されます。
これは、マクロのパターンとそれに対する置換を定義するマクロです。
マクロの呼び出し元は、パターンにマッチする式を渡し、置換が適用されたコードが生成されます。
マクロ関数の例:
macro_rules! say_hello {
    () => {
        println!("Hello, world!");
    };
}
fn main() {
    say_hello!();
}
実行結果:
Hello, world!
解説
上記の例では、say_hello!()マクロを定義しています。これは、空の引数リストに対してprintln!("Hello, world!")を生成するマクロです。
マクロ属性はRustのコンパイル時にコードを修飾するために使用されます。
通常は、関数や構造体、列挙型、フィールドなどに適用されます。
マクロ属性を使用することで、コンパイル時に生成されるコードに追加の情報を提供できます。
マクロ属性の例:
struct MyStruct {
    my_field: i32,
}
fn main() {
    let my_struct = MyStruct { my_field: 42 };
    println!("{:?}", my_struct);
}
実行結果:
MyStruct { my_field: 42 }
解説
上記の例では、#[derive(Debug)]マクロ属性を使用しています。これは、MyStructにDebugトレイトを実装するために必要なコードを生成するマクロ属性です。println!マクロでmy_structを表示する際に、Debugトレイトのメソッドを呼び出して情報を表示することができます。
Rustのパッケージ単位: Rustでは、コードのパッケージングや再利用のために「クレート」(Crate)という単位が使われます。1つのクレートには、1つ以上の関連するモジュールやデータ型が含まれます。
Cargoによる管理: クレートは、RustのパッケージマネージャであるCargoによって管理されます。Cargoは、クレートの作成、ビルド、依存関係の解決などを自動化するツールです。
典型的なRustのクレートは、次のような構造を持ちます：
my_crate/
├── src/
│   ├── main.rs
│   ├── lib.rs
│   └── other_module.rs
├── Cargo.toml
└── README.md
src/: クレートのソースコードを含むディレクトリ。
src/main.rs: クレートを実行するためのエントリポイント。
src/lib.rs: ライブラリとしてコンパイルされる場合に使用されるエントリポイント。
src/other_module.rs: 他のモジュール。
Cargo.toml: クレートのメタデータ、依存関係、ビルド構成などを含むファイル。
README.md: クレートのドキュメント。
新しいクレートを作成する手順は以下の通りです：
cargo newコマンドを使用して新しいクレートのディレクトリを作成します。
Cargo.tomlファイルを編集して、クレートのメタデータを定義します。
必要に応じて、src/main.rsや他のモジュールを編集して、クレートのコードを実装します。
cargo runコマンドを使用してクレートをビルドして実行します。
クレートを他の開発者と共有するためには、それをcrates.ioという公式のクレートレジストリに公開する必要があります。公開手順は以下の通りです：
crates.ioにアカウントを作成します。
cargo loginコマンドを使用してcrates.ioにログインします。
クレートのバージョン番号を更新します。
cargo publishコマンドを使用してクレートを公開します。
Rustのクレートは、コードのパッケージングや再利用を容易にする重要な概念です。Cargoを使用してクレートを管理し、必要に応じてcrates.ioに公開することで、他の開発者とクレートを共有することができます。
Rustにおいて、パッケージはクレートと呼ばれます。クレートは、Rustのコードやライブラリをパッケージ化して共有できるようにするための仕組みです。クレートは、依存関係を解決するためのメタデータと、コードとその他のファイルから構成されています。
Rustには、crates.ioという公式のクレートレジストリがあり、開発者はそこでクレートを共有したり、他の開発者が作成したクレートを使用したりできます。
Rustにおける代数的データ型は、構造体（struct）と列挙型（enum）を指します。これらは複雑なデータ構造を表現するのに役立ちます。
構造体は異なる型のフィールドを持つことができ、それぞれのフィールドは名前を持ちます。例えば：
struct Point {
    x: i32,
    y: i32,
}
impl Point {
    fn new(x: i32, y: i32) -> Self {
        Self { x, y }
    }
    fn print(&self) {
        println!("x: {}, y: {}", self.x, self.y);
    }
}
fn main() {
    let origin = Point::new(0, 0);
    origin.print();
}
列挙型は、いくつかの異なるバリアント（variant）の中から選択することができます。それぞれのバリアントはデータを持つことができます。
enum Shape {
    Circle(f64),     // 半径を持つ
    Rectangle(f64, f64), // 幅と高さを持つ
    Square(f64),     // 1辺の長さを持つ
}
impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
            Shape::Rectangle(width, height) => width * height,
            Shape::Square(side) => side * side,
        }
    }
}
fn main() {
    let shapes = vec![
        Shape::Circle(5.0),
        Shape::Rectangle(10.0, 20.0),
        Shape::Square(15.0),
    ];
    for shape in &shapes {
        println!("Area: {}", shape.area());
    }
}
これらの代数的データ型は、Rustで柔軟なデータ構造を表現する際に役立ちます。
Rustの属性（Attribute）は、コンパイラに対してコードに対する追加情報や指示を提供するための注釈です。コードに直接書かれる特殊な構文であり、#[...]の形式で記述されます。これらの属性は、コンパイラやコードの振る舞い、コード生成、最適化、データのレイアウトなどを変更したり、制御したりするために使われます。
以下は、よく使用される属性のいくつかとその目的です：
#[derive(...)]: 自動導出（Derive Attribute）は、コンパイラに対して構造体や列挙型が特定のトレイトを自動的に実装するよう指示するために使われます。#[derive(Debug)]などがその例で、Debugトレイトを自動的に実装するよう指示します。
#[cfg(...)]: コンパイル時の条件を指定します。例えば、#[cfg(target_os = "linux")]はLinux環境のみで有効にするために使われます。
#[allow(...)] / #[deny(...)] / #[warn(...)]: コンパイラの警告レベルを変更します。allowは特定の警告を許可し、denyはエラーにするよう指示し、warnは警告として表示します。
#[repr(...)]: データのレイアウトや表現方法を制御します。例えば、#[repr(C)]はC言語のレイアウトに合わせることを示し、#[repr(align(N))]は特定のアライメントを指定します。
#[inline] / #[noinline]: インライン展開を制御します。inlineは関数をインライン展開可能として指定し、noinlineは展開を禁止します。
#[test] / #[bench]: ユニットテストやベンチマークテスト用の関数をマークします。テストランナーがこれらの関数を見つけて実行します。
#[derive(...)]、#[macro_use]、#[crate_name = "some_name"]、**#[feature(...)]**など、他にも多くの属性が存在します。
属性は様々な目的に使用され、Rustの柔軟性やコードの特定の振る舞いを制御するための重要なツールです。それぞれの属性は特定のコンテキストで役割を果たし、コードの意図をコンパイラに伝えるのに役立ちます。
// テスト用の関数を定義し、テスト用の属性を追加
fn test_addition() {
    assert_eq!(2 + 2, 4);
}
// main関数を含むコード例
fn main() {
    println!("Hello, Rust!");
    // インライン展開のための属性を持つ関数
    #[inline(always)]
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    // インライン展開を促進する属性を持つ関数
    #[inline(always)]
    fn multiply(a: i32, b: i32) -> i32 {
        a * b
    }
    // インライン展開される関数の呼び出し
    let result_add = add(3, 5);
    println!("Addition result: {}", result_add);
    // インライン展開される関数の呼び出し
    let result_multiply = multiply(4, 6);
    println!("Multiplication result: {}", result_multiply);
}
#[test]属性: test_addition関数に付与された#[test]属性は、この関数をテスト用の関数としてマークしています。この関数は、assert_eq!(2 + 2, 4);を使って2 + 2が4と等しいかテストします。
#[inline(always)]属性: add関数とmultiply関数に付与された#[inline(always)]属性は、インライン展開を促進するための指示です。インライン展開は、関数呼び出しのオーバーヘッドを削減し、効率的なコード生成を促進します。しかし、alwaysの指定は、常にインライン展開されるというわけではなく、コンパイラの判断に依存します。
main関数: main関数はプログラムのエントリーポイントです。この関数内でprintln!を使って"Hello, Rust!"を表示し、add関数とmultiply関数を呼び出しています。それぞれの関数では、インライン展開の指示が付与されています。
このコード例は、属性を使って関数をテスト対象としてマークし、またインライン展開を促進する方法を示しています。ただし、実際にコードを実行する場合は、main関数内のコードが実行されるため、test_addition関数はテストコードとして実行されることになります。
Debugトレイトは、println!マクロで構造体や列挙型の内容を表示するために使用されます。以下は、Debugトレイトを実装することでprintln!で構造体の内容を表示する例です。
 
// Debugトレイトを導出可能にするためにderiveアトリビュートを使用
struct MyStruct {
    name: String,
    age: u32,
}
fn main() {
    let my_data = MyStruct {
        name: String::from("Alice"),
        age: 30,
    };
    // 構造体の内容を表示する
    println!("My data: {:?}", my_data);
}
実行結果:
My data: MyStruct { name: "Alice", age: 30 }
この例では、MyStruct構造体にDebugトレイトを#[derive(Debug)]で導出しています。そして、main関数内でmy_dataをprintln!で表示する際に、{:?}フォーマットを使ってDebugトレイトを呼び出しています。
Debugトレイトを導出することで、println!で構造体の内容を簡単に表示することができます。#[derive(Debug)]を使うことで、デバッグ情報を出力するためのメソッドの実装を手動で書く必要がなくなります。
Rustにおけるジェネリクスは、特定の型に依存せず、複数の型で動作するコードを作成するための重要な機能です。ジェネリクスを使用することで、同じコードを複数の型で再利用したり、型安全性を保ちながら柔軟性を持たせたりすることができます。
// Tというジェネリックな型を持つ関数
fn print_value(value: T) {
    println!("Value is: {}", value);
}
fn main() {
    // 使用例
    print_value(10); // Tはi32として推論される
    print_value(2.73 as f32); // Tはf32として推論される
    print_value("Hello"); // Tは&strとして推論される
}
この例では、print_value関数がジェネリックな型Tを持ち、Tはstd::fmt::Displayトレイトを実装している型に制限されています。std::fmt::Displayトレイトは、{}でフォーマット可能な型を表します。
引数valueの型はコンパイル時に推論されます。
// ジェネリックな構造体
struct Pair {
    first: T,
    second: U,
}
fn main() {
    // 使用例
    let pair_of_int_and_str = Pair { first: 10, second: "Hello" };
    println!("first = {:?}, second = {:?}", pair_of_int_and_str.first, pair_of_int_and_str.second);
}
Pair構造体は2つの異なる型を持つことができます。使用する際に具体的な型を指定することで、ジェネリックな構造体を作成できます。
// ジェネリックなトレイト
trait Printable {
    fn print(&self);
}
// TがPrintableトレイトを実装していることを要求する関数
fn print_trait(item: T) {
    item.print();
}
// 使用例
struct MyType;
impl Printable for MyType {
    fn print(&self) {
        println!("Printing MyType");
    }
}
fn main() {
    let obj = MyType;
    print_trait(obj); // Printableトレイトを実装したMyTypeのインスタンスを受け取る
}
ここでは、Printableというジェネリックなトレイトを定義し、print_trait関数でPrintableトレイトを実装した型Tを受け取る方法を示しています。
ジェネリクスは、関数、構造体、列挙型、トレイトなどのRustのさまざまな要素で使用できます。これにより、柔軟性のあるコードを作成し、再利用性を高めることができます。
ジェネリックスにおいて、型制約（type constraint）は、ジェネリックな型パラメータに対して特定の条件やトレイトの制約を課すことを指します。これにより、ジェネリックな型が特定の性質を持つことを保証し、安全性を確保することができます。
Rustでは、traitを使用して型制約を実装します。例えば、std::fmt::Displayトレイトを持つ型に制約を課したい場合、以下のように実装します。
fn print_value(value: T) {
    println!("Value is: {}", value);
}
ここではという構文を使用して、Tがstd::fmt::Displayトレイトを実装している必要があることを宣言しています。この制約により、print_value関数はstd::fmt::Displayトレイトを実装した型に対してのみ呼び出しが可能になります。
また、複数のトレイト制約を持つこともできます。例えば、std::fmt::Debugとstd::fmt::Displayトレイトの両方を実装した型を要求する場合は、次のように書きます。
fn print_value(value: T) {
    println!("Value is: {:?}", value);
}
struct Point {
    x: T,
    y: T,
}
// Point型に対するDisplayトレイトの実装
impl std::fmt::Display for Point {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Point({}, {})", self.x, self.y)
    }
}
fn main() {
    let int_point = Point { x: 5, y: 10 };
    print_value(int_point); // `Point`型は`std::fmt::Debug`と`std::fmt::Display`を実装している
    let float_point = Point { x: 1.5, y: 3.2 };
    print_value(float_point); // 同様に、`Point`型は`std::fmt::Debug`と`std::fmt::Display`を実装している
}
Tがstd::fmt::Debugとstd::fmt::Displayの両方を実装している必要があります。
これにより、ジェネリックなコードをより安全に、かつ特定の条件下で使用できるように制約を課すことができます。
Rustでは、Result型とpanicによる例外処理が一般的です。Result型は成功または失敗を表す列挙型で、Okは成功時の値、Errはエラー時の情報を持ちます。
まず、Result型を使用した例を見てみましょう:
use std::fs::File;
use std::io::{self, Read};
fn read_file_contents(file_path: &str) -> Result {
    let mut file = File::open(file_path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}
fn main() {
    let file_path = "/etc/hosts";
    match read_file_contents(file_path) {
        Ok(contents) => println!("File contents: {}", contents),
        Err(e) => println!("Error reading file: {:?}", e),
    }
}
この例では、read_file_contents関数がResultを返します。これは、成功時には文字列をOkで、エラー時にはio::ErrorをErrで返すことを示しています。ファイルを開いたり、読み込んだりするメソッドの呼び出しには?演算子を使用し、エラーが発生した場合は早期リターンしてエラーを返します。
matchブロックでは、read_file_contentsの戻り値に対してOkとErrの両方の可能性に対処し、それぞれ成功時の振る舞いとエラー時の振る舞いを定義しています。これにより、関数の呼び出し元で適切にエラーハンドリングを行うことができます。
また、Rustにはpanic!マクロを使用してプログラムを異常終了させる方法もあります。これは致命的なエラーが発生した場合に使用されますが、エラーを適切に処理するためにResult型を使うことが推奨されます。
fn main() {
    let v = vec![1, 2, 3];
    let index = 5;
    let value = v.get(index).expect("Failed to get the value at index");
    println!("Value at index {}: {}", index, value);
}
 
この例では、getメソッドはOption型を返し、expectメソッドはSomeの場合は中の値を返し、Noneの場合は指定したメッセージとともにプログラムをpanicさせます。
ただし、expectを使う際には、panicが発生した際に表示されるメッセージは注意深く選ぶ必要があります。
panic!()は通常、予期せぬ状況やプログラムの継続が不可能な状況で使われることがあります。以下はそのような例です。
fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Attempted to divide by zero!"); // 0で割ろうとした場合、致命的なエラーとしてpanic!()を呼ぶ
    }
    a / b // 正常な割り算を行う
}
fn main() {
    let dividend = 10;
    let divisor = 0;
    let result = divide(dividend, divisor); // divide関数を呼び出す
    println!("Result of division: {}", result);
}
  
この例では、divide()関数でbが0の場合にpanic!()が呼ばれています。0で割ることは数学的に定義されていないため、これは致命的なエラーであり、プログラムの実行を中断させます。
panic!()は、このような状況に直面した場合に、プログラムを停止させるための手段として使われます。しかし、このようなエラーは通常、if文やmatch文などの条件分岐を使用して事前にチェックして、エラーハンドリングを行うことが推奨されます。
Resultを使ってエラーハンドリングを行うことで、panic!()に頼らずにエラーを適切に処理できます。
fn divide(a: i32, b: i32) -> Result {
    if b == 0 {
        Err("Attempted to divide by zero!") // 0で割ろうとした場合、エラーをResultで返す
    } else {
        Ok(a / b) // 正常な割り算の結果をOkで返す
    }
}
fn main() {
    let dividend = 10;
    let divisor = 0;
    match divide(dividend, divisor) {
        Ok(result) => println!("Result of division: {}", result),
        Err(e) => println!("Error: {}", e), // エラーを適切に処理する
    }
}
divide()関数はResultを返し、0で割るエラーの場合にはErrを、正常な計算の場合にはOkを返します。matchブロックでは、OkとErrの両方のケースを処理し、エラーが発生した場合にはエラーメッセージを表示します。
このようにResult型を使用することで、エラーハンドリングを柔軟かつ安全に行うことができます。panic!()に頼るよりも、エラーを予測し、適切に処理する方が望ましいです。
Option型は、何らかの値が存在するかどうかを表現するRustの列挙型です。Option型はSomeとNoneの２つのバリアントを持ち、Someは値が存在することを示し、Noneは値が存在しないことを示します。
Option型は、特定の操作が値を返さない可能性がある場合や、値が存在しない場合にエラーを返す代わりにNoneを返すために使われます。このような状況では、Result型を使用せずに、Option型が利用されることがあります。
以下はOption型の例です：
fn divide(a: i32, b: i32) -> Option {
    if b == 0 {
        None // 0で割ろうとした場合、Noneを返す
    } else {
        Some(a / b) // 正常な割り算の結果をSomeで返す
    }
}
fn main() {
    let dividend = 10;
    let divisor = 0;
    match divide(dividend, divisor) {
        Some(result) => println!("Result of division: {}", result), // Someの場合は値を表示
        None => println!("Error: Division by zero!"), // Noneの場合はエラーメッセージを表示
    }
}
 
この例では、divide()関数はOptionを返し、0で割るエラーの場合にはNoneを、正常な計算の場合にはSomeを返します。matchブロックでは、SomeとNoneの両方のケースを処理し、Noneの場合はエラーメッセージを表示します。
Option型は、特に値が存在しないことが普通に起こり得る場面で、エラー処理や結果の取り扱いを行う際に有用です。例外的な状況ではなく、むしろ普通の操作の一部として考えられる「値の有無」を扱う際に利用されることが多いです。
RustのIteratorトレイトは、コレクションやデータのシーケンスを反復処理するための非常に強力な機能です。Iteratorは、next() メソッドを提供し、それを使用して次の要素を返し、シーケンスの終わりに達した場合は None を返します。
基本的な使い方は次のようになります:
イテレータの作成: コレクションやデータからイテレータを作成します。iter()やinto_iter()、iter_mut()などのメソッドを使用して、それぞれイミュータブルな参照、所有権、ミュータブルな参照を使ったイテレータを取得できます。
let numbers = vec![1, 2, 3, 4, 5];
let mut iter = numbers.iter(); // イミュータブルなイテレータ
next()を使用した反復処理: next()メソッドを使って、イテレータから次の要素を取得します。
match iter.next() {
    Some(number) => println!("Number: {}", number),
    None => println!("End of sequence"),
}
forループを使用した反復処理: 一般的には、forループを使用してイテレータを処理します。
for number in numbers.iter() {
    println!("Number: {}", number);
}
Iteratorトレイトは、map()、filter()、fold()などの便利なメソッドも提供しており、これらを組み合わせることでデータを効果的に処理できます。
let numbers = vec![1, 2, 3, 4, 5];
// 各要素を2倍して新しいベクターを作成する
let doubled: Vec = numbers.iter().map(|x| x * 2).collect();
// 偶数のみをフィルタリングする
let evens: Vec = numbers.into_iter().filter(|&x| x % 2 == 0).collect();
// 全要素を合計する
let sum: i32 = numbers.iter().sum();
Iteratorトレイトは、Rustでのデータ処理を非常に柔軟で効率的にします。関数型プログラミングの考え方に基づいた強力な機能を提供しています。
Iteratorトレイトを使用して独自のイテレータを実装する例を示します。
例えば、0から始まり、指定されたステップごとに増加するカウンターを作成するイテレータを実装してみましょう。
struct Counter {
    current: u32,
    step: u32,
    max: Option,
}
impl Counter {
    fn new(start: u32, step: u32, max: Option) -> Counter {
        Counter {
            current: start,
            step,
            max,
        }
    }
}
impl Iterator for Counter {
    type Item = u32;
    fn next(&mut self) -> Option {
        match self.max {
            Some(max) if self.current >= max => None,
            _ => {
                let result = self.current;
                self.current += self.step;
                Some(result)
            }
        }
    }
}
fn main() {
    let counter = Counter::new(0, 2, Some(10));
    for num in counter {
        println!("{}", num);
    }
}
 
この例では、Counter構造体はIteratorトレイトを実装しています。next()メソッドは、現在の値を返し、カウンターを指定されたステップで増分させます。また、max値が設定されており、その値に達するとイテレータは終了します。
main()関数内では、Counterイテレータを使用して0から10まで2ずつ増加する数列を生成しています。
Iteratorトレイトを実装することで、独自のイテレータを作成し、柔軟な反復処理を行うことができます。
implキーワードは、Rustで特定の型に対してメソッドやトレイトを実装するために使用されます。基礎から始めて、応用的な使い方まで見ていきましょう。
メソッドの実装
struct MyStruct {
    value: i32,
}
impl MyStruct {
    // MyStruct型に対するメソッドの実装
    fn new(value: i32) -> MyStruct {
        MyStruct { value }
    }
    fn get_value(&self) -> i32 {
        self.value
    }
}
fn main() {
    let instance = MyStruct::new(42);
    println!("Value: {}", instance.get_value()); // メソッド呼び出し
}
implブロック内で、MyStructに対するnewメソッドとget_valueメソッドを実装しています。main関数でこれらのメソッドを使用しています。
トレイトの実装
// 'Printable' という名前の機能を定義しています。
// これは、ある型が特定の振る舞いを持つことを宣言します。
trait Printable {
    // 'print' という名前の機能を提供しています。
    // これは、任意の型が実装する必要があるメソッドです。
    fn print(&self);
}
// 'MyType' という名前のデータ構造を定義しています。
// これは整数値を保持する構造体です。
struct MyType {
    value: i32, // 'MyType' 構造体が保持する整数値のフィールドです。
}
// 'Printable' という機能を 'MyType' に実装しています。
// これにより、'MyType' インスタンスは 'Printable' で提供される振る舞いを持ちます。
impl Printable for MyType {
    // 'Printable' で要求された 'print' 機能を 'MyType' に実装しています。
    fn print(&self) {
        // 'MyType' インスタンスが 'print' を実行すると、値が表示されます。
        println!("Value: {}", self.value);
    }
}
fn main() {
    // 'MyType' の新しいインスタンスを作成し、整数値を設定しています。
    let obj = MyType { value: 10 };
    // 'Printable' で定義された 'print' 機能を呼び出しています。
    // これにより、 'MyType' の値が出力されます（この場合は "Value: 10"）。
    obj.print();
}
{{コラム|トレイトとインターフェイスやプロトコルとの類似性|2=トレイトは他の言語でのインターフェースやプロトコルに似ています。これらの概念は、異なる型や構造体が共通の振る舞いを持つことを許可し、それによってポリモーフィズム（多様性）を実現します。
インターフェース
共通の振る舞い: インターフェースは、異なるクラスが共通の振る舞いを持つことを保証します。他の言語では、この振る舞いはインターフェースで定義され、クラスはそれを実装します。
メソッドの宣言: インターフェースでは、クラスが実装しなければならないメソッドの宣言が含まれます。
多重継承の代替: インターフェースは多重継承の代替手段としても使われ、クラスは複数のインターフェースを実装することができます。
プロトコル
抽象的な振る舞いの定義: プロトコルは、特定の振る舞いや機能を表す抽象的な規約です。Swiftなどの言語ではプロトコルが使われ、クラスや構造体はそれらを適合させます。
メソッドの要求: プロトコルは、適合する型によって実装されるメソッドやプロパティの要求を定義します。
型の適合性の強化: プロトコルに適合することで、様々な型を同じ抽象的な概念に束縛することができます。
Rustのトレイト
共通の振る舞いの提供: トレイトは、構造体や他の型に共通の振る舞いを提供します。それぞれの型はトレイトを実装することで、その振る舞いを持つことができます。
メソッドの宣言: トレイトではメソッドの宣言が行われ、それを実装することでトレイトが利用できるようになります。
型間の相互運用性と柔軟性: トレイトは型間での相互運用性や柔軟性を提供し、異なる型が同じ振る舞いを共有することができます。
これらの概念は異なる言語で微妙に異なる場合がありますが、トレイト、インターフェース、プロトコルはいずれも多様な型が共通の振る舞いを共有するための仕組みとして機能します。
ジェネリックな構造体に対する実装
// ジェネリックなデータ構造体 'MyGeneric' を定義しています。
// '' は型パラメータであり、任意の型を受け入れます。
struct MyGeneric {
    value: T, // 'T' 型の値を保持する 'value' フィールドです。
}
// 'MyGeneric' に対するジェネリックなメソッド実装です。
impl MyGeneric {
    // 新しい 'MyGeneric' インスタンスを生成する 'new' メソッドです。
    // 渡された値で 'value' フィールドを初期化します。
    fn new(value: T) -> MyGeneric {
        MyGeneric { value }
    }
    // 'value' フィールドへの参照を返す 'get_value' メソッドです。
    fn get_value(&self) -> &T {
        &self.value
    }
}
fn main() {
    // 'MyGeneric' 型のインスタンスを作成しています。
    // 'value' フィールドには整数値 42 が格納されます。
    let instance = MyGeneric::new(42);
    // 'get_value' メソッドを呼び出して 'value' フィールドの値を取得し、出力しています。
    println!("Value: {:?}", instance.get_value()); // ジェネリックなメソッド呼び出し
    // 'MyGeneric<&str>' 型のインスタンスを作成しています。
    // 'value' フィールドには文字列 "hello" が格納されます。
    let instance = MyGeneric::new("hello");
    // 'get_value' メソッドを呼び出して 'value' フィールドの値を取得し、出力しています。
    println!("Value: {:?}", instance.get_value()); // ジェネリックなメソッド呼び出し
}
このコードは、MyGenericをi32型と&str型の両方でインスタンス化しています。ジェネリックなデータ構造体とそのジェネリックなメソッドを利用して、異なる型に対して同じメソッドを使用する様子を示しています。println!マクロ内の{:?}は、Debugトレイトを実装する型の値を表示するためのフォーマット指定子です。これにより、異なる型の値も出力できます。
----
implを使ったさまざまな例を挙げてみましょう。
// Summaryトレイトを定義します。
trait Summary {
    fn summarize(&self) -> String;
}
// Summaryトレイトを実装するBook構造体を定義します。
struct Book {
    title: String,
    author: String,
}
// BookにSummaryトレイトを実装します。
impl Summary for Book {
    fn summarize(&self) -> String {
        format!("{} by {}", self.title, self.author)
    }
}
// summarize_any関数はSummaryトレイトを実装した任意の型に対して要約を取得します。
fn summarize_any(item: &impl Summary) -> String {
    item.summarize()
}
fn main() {
    let book = Book {
        title: String::from("Harry Potter"),
        author: String::from("J.K. Rowling"),
    };
    println!("Summary: {}", summarize_any(&book));
}
この例では、Summaryトレイトを実装した様々な型に対して共通のsummarize_any関数を使用して、異なる型の値に対して要約を取得できます。このようなジェネリックで柔軟なアプローチは、異なる型に対して一貫した操作を提供する場合に非常に便利です。
// 長方形を表す 'Rectangle' 構造体です。
struct Rectangle {
    width: u32,  // 長方形の幅を表す 'width' フィールド
    height: u32, // 長方形の高さを表す 'height' フィールド
}
// 'Rectangle' 構造体に関するメソッドを実装しています。
impl Rectangle {
    // 新しい 'Rectangle' インスタンスを生成する 'new' メソッドです。
    fn new(width: u32, height: u32) -> Self {
        Rectangle { width, height }
    }
}
// 'Area' という名前のトレイトを定義しています。
// このトレイトは 'area' メソッドを持ち、長方形の面積を計算します。
trait Area {
    // 長方形の面積を計算する 'area' メソッドです。
    fn area(&self) -> u32;
}
// 'Area' トレイトを 'Rectangle' 構造体に実装しています。
// 'Rectangle' には 'Area' トレイトの 'area' メソッドが実装されます。
impl Area for Rectangle {
    // 'Rectangle' の面積を計算する 'area' メソッドの実装です。
    fn area(&self) -> u32 {
        self.width * self.height
    }
}
fn main() {
    // 幅が5、高さが10の 'Rectangle' インスタンスを作成しています。
    let rect = Rectangle::new(5, 10);
    // 'Area' トレイトの 'area' メソッドを呼び出して、長方形の面積を出力しています。
    println!("Area of rectangle: {}", rect.area());
}
ここでは、Rectangle構造体にnewメソッドを実装し、またAreaトレイトを実装しています。main関数でRectangleのインスタンスを作成し、Areaトレイトのメソッドであるarea()を呼び出しています。
// 同じ型の2つの要素を持つ 'Pair' 構造体です。
struct Pair {
    first: T,   // ペアの最初の要素を表す 'first' フィールド
    second: T,  // ペアの2番目の要素を表す 'second' フィールド
}
// 'Pair' 構造体に関するメソッドを実装しています。
impl Pair {
    // 新しい 'Pair' インスタンスを生成する 'new' メソッドです。
    // 渡された2つの値で 'first' と 'second' フィールドを初期化します。
    fn new(first: T, second: T) -> Self {
        Pair { first, second }
    }
    // 'first' フィールドへの参照を返す 'get_first' メソッドです。
    fn get_first(&self) -> &T {
        &self.first
    }
    // 'second' フィールドへの参照を返す 'get_second' メソッドです。
    fn get_second(&self) -> &T {
        &self.second
    }
}
fn main() {
    // 整数型を持つ 'Pair' インスタンスを作成しています。
    let pair = Pair::new(42, 24);
    // 'get_first' メソッドを使ってペアの最初の要素を出力しています。
    println!("First element: {}", pair.get_first());
    // 'get_second' メソッドを使ってペアの2番目の要素を出力しています。
    println!("Second element: {}", pair.get_second());
}
Pair構造体に対してT型のジェネリックなメソッドを実装しています。この例ではget_firstメソッドを定義し、main関数でそれを呼び出しています。
// 'Weather' 列挙型です。3つの異なる天気を表します。
enum Weather {
    Sunny,
    Cloudy,
    Rainy,
}
// 'Description' トレイトは、様々な要素に対する説明を提供します。
trait Description {
    fn describe(&self) -> &'static str;
}
// 'Description' トレイトを 'Weather' 列挙型に実装しています。
impl Description for Weather {
    // 'describe' メソッドは、各 'Weather' の状態に対する説明を提供します。
    fn describe(&self) -> &'static str {
        match self {
            Weather::Sunny => "It's sunny today!",
            Weather::Cloudy => "It's cloudy today.",
            Weather::Rainy => "It's raining today.",
        }
    }
}
fn main() {
    // 'Weather' 列挙型のすべてのヴァリアントを反復処理します。
    for weather in &[Weather::Sunny, Weather::Cloudy, Weather::Rainy] {
        // 各天気状況に対する説明を出力します。
        println!("{:?}: {}", weather, weather.describe());
    }
}
Weather列挙型に対してDescriptionトレイトを実装して、各ヴァリアントに対する説明を返すdescribeメソッドを定義しています。main関数でWeatherのインスタンスを作成し、その説明を表示しています。
これらの例は、implを使って様々なタイプの型に対してメソッドやトレイトを実装する方法を示しています。この機能を利用することで、Rustの柔軟で型安全なコーディングを行うことができます。
Rustでの関数は、プログラム内で再利用可能なコードブロックを定義するために使われます。関数は特定のタスクを実行するための手続きを含み、必要に応じて引数を受け取り、結果を返すことができます。基本的な関数の定義と使用方法を以下に示します。
// 関数の定義
fn add(a: i32, b: i32) -> i32 {
    a + b // 最後の式の結果が自動的に返り値になる
}
 
この例では、addという名前の関数が定義されています。aとbは整数型(i32)の引数を受け取ります。-> i32は関数がi32型の値を返すことを示しています。
let result = add(3, 5);
println!("Result: {}", result); // "Result: 8"が出力される
add関数は3と5を引数に取り、それらを足して8を返します。println!マクロを使ってその結果を出力しています。
引数: 関数に渡す値。関数の定義において、引数は型を指定する必要があります。
戻り値: ->演算子を使って関数が返す値の型を指定します。Rustでは最後の式の結果が自動的に返り値となります。
Rustの関数は複数の値を返すこともできます。
 
fn calculate(a: i32, b: i32) -> (i32, i32) {
    (a + b, a - b)
}
let (sum, difference) = calculate(10, 5);
println!("Sum: {}, Difference: {}", sum, difference); // "Sum: 15, Difference: 5"が出力される
再帰: 自分自身を呼び出すことができます。
クロージャ: 無名の関数を作成し、変数にキャプチャさせることができます。
ジェネリクス: 型を指定せずに関数を定義することができ、後から具体的な型を指定できます。
Rustの関数は安全性、速度、パターンマッチング、ジェネリクス、所有権など、言語の多くの特徴を活用しています。これらの特性は、Rustを強力なプログラミング言語にしています。
Rustの関数とライフタイムは、関連性がありますが、関数のシグネチャ内でライフタイムを使用することは必ずしも必要ではありません。しかし、関数が参照を含む場合や、ジェネリクスを使う場合には、ライフタイムの指定が必要になることがあります。
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
この例では、longest関数は2つの文字列スライスを引数として受け取り、それらのうち長さが長い方の参照を返します。'aはライフタイムパラメータであり、2つの引数と返り値の参照のライフタイムが同じことを示しています。これにより、返される参照が有効なスコープを保証します。
Rustでは、ライフタイムの省略規則があります。特定のパターンにおいては、コンパイラが暗黙的にライフタイムを推論することができます。例えば、次のような関数シグネチャではライフタイムの省略が行われます。
fn longest(x: &str, y: &str) -> &str {
    // ...
}
このような場合、コンパイラは適切なライフタイムを自動的に推論します。ただし、ライフタイムの省略は特定の条件に限定され、全ての場面で使えるわけではありません。
ライフタイムは主に、参照の有効期間を指定するために使用され、特に関数内で参照を扱う際に重要な役割を果たします。関数が複数の参照を扱い、それらの有効期間を整理する必要がある場合には、ライフタイムの指定が必要になることがあります。
Rustではクロージャも関数として扱われます。クロージャは自身のスコープ外の変数をキャプチャして利用できます。これは非常に便利で、関数よりも柔軟な振る舞いを提供します。
次のコード例では、クロージャと関数の組み合わせを使って、外部スコープの変数をキャプチャして利用する方法を示します。
fn main() {
    let base_number = 10;
    // クロージャの定義
    let add_to_base = |x| x + base_number;
    let new_number = 7;
    // クロージャの使用
    let result = add_to_base(new_number);
    println!("Result: {}", result); // "Result: 17"が出力される
}
この例では、base_numberという変数がadd_to_baseクロージャにキャプチャされ、後でクロージャ内で使用されています。クロージャは外部の変数をキャプチャすることができ、そのコンテキストを保持して使用できる点が関数とは異なる特徴です。
Rustの関数は、パターンマッチングやジェネリクス、ライフタイム、クロージャなどの機能と組み合わせて、安全で効率的なコードを記述するための強力なツールです。
Rustは、関数型プログラミングの要素を備えた汎用プログラミング言語です。Rustでは、関数を変数やデータ構造に格納したり、関数を関数のパラメータとして渡したりすることができます。これらの機能は、高階関数として知られています。
Rustで高階関数を使用すると、コードの再利用性と保守性を向上させることができます。また、コードをより簡潔で読みやすくすることもできます。
Rustで高階関数を使用する方法はいくつかあります。
Rustでは、関数を変数に格納することができます。これにより、関数を繰り返し使用したり、関数を別の関数に渡したりすることができます。
fn square(x: i32) -> i32 {
    x * x
}
let square_function = square;
println!("The square of 5 is {}", square_function(5));
このコードでは、square()関数をsquare_function変数に格納しています。その後、square_function()関数を呼び出すことで、square()関数と同じ結果を得ることができます。
Rustでは、関数を関数のパラメータとして渡すことができます。これにより、関数を別の関数に処理させることができます。
fn map_numbers(numbers: &[i32], f: fn(i32) -> i32) -> Vec {
    let mut result = Vec::new();
    for number in numbers {
        result.push(f(number));
    }
    result
}
fn square(x: i32) -> i32 {
    x * x
}
let numbers = [1, 2, 3, 4, 5];
let squared_numbers = map_numbers(numbers, square);
println!("The squared numbers are: {:?}", squared_numbers);
このコードでは、map_numbers()関数は、numbers配列の各要素をf関数に渡し、その結果を新しい配列に格納します。
Rustでは、クロージャを使用して高階関数を作成することができます。クロージャは、関数本体の一部として定義された関数です。クロージャは、変数やデータ構造を捕捉して、関数本体内で使用することができます。
fn filter_numbers(numbers: &[i32], f: impl Fn(i32) -> bool) -> Vec {
    let mut result = Vec::new();
    for number in numbers {
        if f(number) {
            result.push(number);
        }
    }
    result
}
fn is_even(x: i32) -> bool {
    x % 2 == 0
}
let numbers = [1, 2, 3, 4, 5];
let even_numbers = filter_numbers(numbers, is_even);
println!("The even numbers are: {:?}", even_numbers);
このコードでは、filter_numbers()関数は、numbers配列の各要素をfクロージャに渡し、その結果がtrueである場合、その要素を新しい配列に格納します。
Rustで高階関数を使用すると、コードの再利用性と保守性を向上させることができます。また、コードをより簡潔で読みやすくすることもできます。
Rustの標準ライブラリー（Standard Library）は、Rustコンパイラにバンドルされており、基本的なデータ構造、OSとのやり取り、スレッド、ファイルI/O、ネットワーキングなどの多くの機能を提供しています。以下に、標準ライブラリーの主要なカテゴリを紹介します。
Vec, VecDeque: ベクターや双方向キューなどの動的な配列。
HashMap, BTreeMap: ハッシュマップやBツリーマップなどのキーと値のペアを保持するマップ。
HashSet, BTreeSet: ハッシュセットやBツリーセットなどのユニークな値を保持するセット。
std::thread: スレッドの生成と操作を提供。
std::sync: Mutex、Atomicなどの同期機能を提供するモジュール。
std::fs: ファイルシステムとの相互作用を可能にするモジュール。
std::net: ネットワーキングのためのモジュール。
std::primitive: Rustのプリミティブ型（整数、浮動小数点数など）の機能を提供。
std::env: 環境変数の取得などのOS環境に関する操作。
std::time: 時間に関する機能を提供。
std::io: 標準入出力やバッファリング、ファイルI/OなどのI/O操作を提供。
std::str: 文字列の操作、変換、検索などの機能を提供。
std::alloc: メモリの割り当てと解放のための機能。
std::marker: マーカートレイトを提供し、コンパイラへのヒントを与える。
これらは標準ライブラリーの一部であり、Rustの基本的な機能を提供しています。開発者はこれらのモジュールや機能を組み合わせて、安全で効率的なプログラムを構築できます。
このコードギャラリーは、さまざまなRustの機能やパターン、ベストプラクティスを示すためのサンプルコード集です。
fn eratosthenes(n: usize) {
    let mut sieve = vec![true; n + 1];
    sieve[0] = false;
    sieve[1] = false;
    for i in 2..=n {
        if sieve[i] {
            println!("{}", i);
            let mut j = i * 2;
            while j <= n {
                sieve[j] = false;
                j += i;
            }
        }
    }
}
fn main() {
    eratosthenes(100);
}
このRustのコードは、エラトステネスの篩を使用して与えられた範囲内の素数を見つけるものです。
eratosthenes 関数は、与えられた n までの素数を見つけるためのエラトステネスの篩アルゴリズムを実装しています。このアルゴリズムでは、最初に n + 1 サイズの sieve というブール型の配列を作成します。この配列は、各インデックスが素数かどうかを示します。
sieve[0] と sieve[1] は素数ではないので、それらを false に設定します。
2 から n までの各数について、その数が素数である場合は、その数の倍数を素数ではないとマークします。これにより、素数の倍数を持つ数は素数ではないことがわかります。
main 関数では、eratosthenes 関数を呼び出し、100までの素数を見つけます。見つかった素数は画面に出力されます。
このアルゴリズムは素数を見つけるための効率的な方法の一つであり、与えられた範囲内の素数を見つけることができます。
fn gcd2(m: i32, n: i32) -> i32 {
    if n == 0 {
        m
    } else {
        gcd2(n, m % n)
    }
}
fn gcd(ints: &[i32]) -> i32 {
    ints.iter().fold(ints[0], |acc, &value| gcd2(acc, value))
}
fn lcm2(m: i32, n: i32) -> i32 {
    m * n / gcd2(m, n)
}
fn lcm(ints: &[i32]) -> i32 {
    ints.iter().fold(ints[0], |acc, &value| lcm2(acc, value))
}
fn main() {
    println!("gcd2(30, 45) => {}", gcd2(30, 45));
    println!("gcd(&[30, 72, 12]) => {}", gcd(&[30, 72, 12]));
    println!("lcm2(30, 72) => {}", lcm2(30, 72));
    println!("lcm(&[30, 42, 72]) => {}", lcm(&[30, 42, 72]));
}
このコードは高階関数を利用しています。fold関数は特に重要で、与えられた配列内の要素に対して特定の操作を順番に適用することができます。
まず、gcd関数では、ints配列内の要素に対してfold関数を使って最大公約数（gcd2関数）を計算しています。foldは初期値としてints[0]を受け取り、各要素valueに対してgcd2(acc, value)を適用し、次の要素に対して再帰的にgcd2を適用します。これにより、配列内のすべての要素の最大公約数が計算されます。
同様に、lcm関数もfoldを利用しています。ここではlcm2関数が利用され、各要素に対して最小公倍数を求めるための計算が行われます。
高階関数の利用により、配列内の要素に対して繰り返し処理を行う必要がある場合でも、シンプルで効率的なコードを書くことができます。
二分法
fn bisection(low: f64, high: f64, f: impl Fn(f64) -> f64) -> f64 {
    let x = (low + high) / 2.0;
    let fx = f(x);
    match () {
        _ if (fx.abs() - 1.0e-10) < f64::EPSILON => x,
        _ if fx < 0.0 => bisection(x, high, f),
        _ => bisection(low, x, f),
    }
}
fn main() {
    let result1 = bisection(0.0, 3.0, |x| x - 1.0);
    println!("{}", result1);
    let result2 = bisection(0.0, 3.0, |x| x * x - 1.0);
    println!("{}", result2);
}
旧課程(-2012年度)高等学校数学B/数値計算とコンピューター#2分法の例を Rust に移植しました。
このRustのコードは、二分法（bisection method）を使って与えられた関数の根を見つけるものです。
bisection関数は、lowからhighの範囲で与えられた関数 f の根を探します。f は Fn(f64) -> f64 のトレイトを実装しており、実際の関数の定義は呼び出し時に与えられます。
この関数は再帰的に呼び出されます。与えられた区間 [low, high] の中央値 x を求め、その点での関数の値 f(x) を計算します。この値が非常に小さいか（ここでは 1.0e-10未満）、または非常に近い数になるまで low または high を更新して、区間を狭めていきます。
main関数では、2つの異なる関数 x - 1 と x^2 - 1 に対して bisection 関数を呼び出して、それぞれの関数の根を探し、println! マクロを使って根を表示しています。
Rustにクラスはありませんが、構造体がメソッドを持つことが出来ます。
struct Hello {
    s: String,
}
impl Hello {
    fn new(s: &str) -> Hello {
        let s = if s.is_empty() { "world" } else { s };
        Hello { s: s.to_string() }
    }
    fn to_string(&self) -> String {
        format!("Hello {}!", self.s)
    }
    fn print(&self) {
        println!("{}", self.s);
    }
}
fn main() {
    let hello1 = Hello::new("");
    println!("{}", hello1.to_string());
    hello1.print();
    let hello2 = Hello::new("my friend");
    println!("{}", hello2.to_string());
    hello2.print();
    println!("
Hello.constructor.name => Hello
hello1 => {:?}
hello2.s => {}", hello1, hello2.s);
}
このRustのコードは、Helloという名前の構造体を定義し、その構造体に関連するメソッドや、main()関数を含んでいます。
まず、Hello構造体はString型のsフィールドを持っています。#[derive(Debug)]アトリビュートは、この構造体にDebugトレイトを自動的に実装するようコンパイラに指示しています。Debugトレイトを実装することで、デバッグ目的で構造体の内容を出力できるようになります。
impl Helloブロックでは、Hello構造体に対するメソッドが定義されています。
newメソッドは、引数として文字列を受け取り、それが空文字列の場合はデフォルトの文字列 "world" を持つHello構造体を生成します。それ以外の場合は、引数で渡された文字列を使用してHello構造体を作成します。
to_stringメソッドは、Hello構造体のインスタンスに対して、挨拶文を含む文字列を生成します。
printメソッドは、Hello構造体のインスタンスのsフィールド（挨拶文）を標準出力に表示します。
main()関数では、Hello構造体を使ってインスタンスを生成し、メソッドを呼び出しています。println!マクロを使用して、構造体やそのフィールドをデバッグ出力しています。最後のprintln!マクロでは、hello1のデバッグ表示（{:?}）とhello2のsフィールドを出力しています。
Go/メソッドとインターフェースからの移植です。
use std::f64::consts::PI;
struct GeoCoord {
    longitude: f64,
    latitude: f64,
}
impl GeoCoord {
    fn distance(&self, other: &GeoCoord) -> f64 {
        let i = PI / 180.0;
        let r = 6371.008;
        let lat_i = self.latitude * i;
        let other_lat_i = other.latitude * i;
        let long_diff_i = (self.longitude - other.longitude) * i;
        let sin_lat = f64::sin(lat_i) * f64::sin(other_lat_i);
        let cos_lat = f64::cos(lat_i) * f64::cos(other_lat_i);
        let cos_long_diff = f64::cos(long_diff_i);
        let distance = f64::acos(sin_lat + cos_lat * cos_long_diff) * r;
        distance
    }
}
impl std::fmt::Display for GeoCoord {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let (mut ew, mut ns) = ("東経", "北緯");
        let mut long = self.longitude;
        let mut lat = self.latitude;
        if long < 0.0 {
            ew = "西経";
            long = -long;
        }
        if lat < 0.0 {
            ns = "南緯";
            lat = -lat;
        }
        write!(f, "({}: {}, {}: {})", ew, long, ns, lat)
    }
}
fn main() {
    let sites = vec![
        ("東京駅", GeoCoord { longitude: 139.7673068, latitude: 35.6809591 }),
        ("シドニー・オペラハウス", GeoCoord { longitude: 151.215278, latitude: -33.856778 }),
        ("グリニッジ天文台", GeoCoord { longitude: -0.0014, latitude: 51.4778 }),
    ];
    for (name, gc) in &sites {
        println!("{}: {}", name, gc);
    }
    let ks: Vec<&str> = sites.iter().map(|(k, _)| *k).collect();
    for i in 0..sites.len() {
        let ksi = ks[i];
        let ksx = ks[(i + 1) % sites.len()];
        println!(
            "{} - {}: {:.2} [km]",
            ksi,
            ksx,
            sites[i].1.distance(&sites[(i + 1) % sites.len()].1)
        );
    }
}
逆ポーランド記法は、数式の演算子を後置記法で表現する方法です。通常の中置記法では演算子がオペランドの間に置かれますが、逆ポーランド記法では演算子がオペランドの後ろに置かれます。これにより、括弧や演算子の優先順位を考える必要がなくなり、計算機で容易に評価できる形式になります。
例えば、中置記法での式 3 + 4 * 5 は、逆ポーランド記法では 3 4 5 * + と表現されます。この記法では、演算子が対象のオペランドに対して順番に適用されます。
enum Token {
    Add,
    Sub,
    Mul,
    Div,
    Operand(i32),
}
impl Token {
    fn evaluate(&self, stack: &mut Vec) -> Result<(), &'static str> {
        match self {
            Token::Add | Token::Sub | Token::Mul | Token::Div => {
                if stack.len() < 2 {
                    return Err("Invalid expression: not enough operands for operator");
                }
                let operand2 = stack.pop().unwrap();
                let operand1 = stack.pop().unwrap();
                match self {
                    Token::Add => stack.push(operand1 + operand2),
                    Token::Sub => stack.push(operand1 - operand2),
                    Token::Mul => stack.push(operand1 * operand2),
                    Token::Div => {
                        if operand2 == 0 {
                            return Err("Division by zero");
                        }
                        stack.push(operand1 / operand2);
                    }
                    _ => unreachable!(),
                }
            }
            Token::Operand(num) => {
                stack.push(*num);
            }
        }
        Ok(())
    }
}
fn evaluate_expression(expression: &str) -> Result {
    let mut stack: Vec = Vec::new();
    let tokens: Vec = expression
        .split_whitespace()
        .map(|token| {
            if let Ok(parsed_num) = token.parse::() {
                Token::Operand(parsed_num)
            } else {
                match token {
                    "+" => Token::Add,
                    "-" => Token::Sub,
                    "*" => Token::Mul,
                    "/" => Token::Div,
                    _ => unreachable!(),
                }
            }
        })
        .collect();
    for token in tokens {
        if let Err(err) = token.evaluate(&mut stack) {
            return Err(err);
        }
    }
    if stack.len() != 1 {
        return Err("Invalid expression: too many operands or operators");
    }
    Ok(stack[0])
}
fn main() {
    let expression = "5 3 2 * + 8 2 / -";
    match evaluate_expression(expression) {
        Ok(result) => println!("Result: {}", result),
        Err(err) => println!("Error: {}", err),
    }
}
このコードは、Tokenという列挙型を使って逆ポーランド記法の式を評価する関数を実装しています。
まず、TokenはAdd、Sub、Mul、Div、Operandの5つのバリアントを持ちます。Operandは整数値を保持します。
Tokenにはevaluateというメソッドが実装されています。このメソッドでは、Tokenの各バリアントに対する処理が行われます。Add、Sub、Mul、Divの場合は、スタックから2つの値を取り出して、それらを演算し結果をスタックに積みます。Operandの場合は、その値をスタックに積みます。
evaluate_expression関数では、与えられた式をトークン化してTokenのベクターに変換し、それぞれのトークンに対してevaluateメソッドを実行します。各トークンの評価においてエラーが発生した場合、そのエラーメッセージが直ちに返されます。最終的に、スタックに残った値が1つでない場合もエラーが返されます。
main関数では、evaluate_expressionの結果に応じて結果を出力するか、エラーを表示します。これにより、逆ポーランド記法の式を評価し、正常な結果またはエラーメッセージを表示できます。
enum Token {
    Number(i32),
    Plus,
    Minus,
    Multiply,
    Divide,
}
fn main() {
    let input = "12+34*56/78";
    let tokens = parse_input(input);
    let rpn = infix_to_rpn(tokens);
    println!("{:?}", rpn);
}
fn parse_input(input: &str) -> Vec {
    let mut tokens = Vec::new();
    let mut num = String::new();
    for c in input.chars() {
        match c {
            '0'..='9' => num.push(c),
            '+' | '-' | '*' | '/' => {
                if !num.is_empty() {
                    let n = num.parse().unwrap();
                    tokens.push(Token::Number(n));
                    num.clear();
                }
                match c {
                    '+' => tokens.push(Token::Plus),
                    '-' => tokens.push(Token::Minus),
                    '*' => tokens.push(Token::Multiply),
                    '/' => tokens.push(Token::Divide),
                    _ => unreachable!(),
                }
            }
            _ => panic!("Invalid character in input!"),
        }
    }
    if !num.is_empty() {
        let n = num.parse().unwrap();
        tokens.push(Token::Number(n));
    }
    tokens
}
fn infix_to_rpn(tokens: Vec) -> Vec {
    let mut rpn = Vec::new();
    let mut stack = Vec::new();
    for token in tokens {
        match token {
            Token::Number(_) => rpn.push(token),
            Token::Plus | Token::Minus | Token::Multiply | Token::Divide => {
                while let Some(top) = stack.last().copied() {
                    if precedence(&token) <= precedence(⊤) {
                        rpn.push(stack.pop().unwrap());
                    } else {
                        break;
                    }
                }
                stack.push(token);
            }
        }
    }
    while let Some(op) = stack.pop() {
        rpn.push(op);
    }
    rpn
}
fn precedence(token: &Token) -> i32 {
    match token {
        Token::Multiply | Token::Divide => 2,
        Token::Plus | Token::Minus => 1,
        _ => 0,
    }
}
実行結果:
[Number(12), Number(34), Number(56), Multiply, Number(78), Divide, Plus]
このコードは、与えられた文字列を逆ポーランド記法（RPN）に変換するプログラムです。以下にその構造を解説します：
Token 列挙型: 数字と演算子を表す列挙型です。Number は数字を、Plus, Minus, Multiply, Divide はそれぞれ演算子を表します。derive(Debug, Clone, Copy) が付与されており、デバッグ表示やクローン、コピーが可能です。
parse_input 関数: 与えられた文字列をトークンに分割します。数字の場合は文字列を数値に変換して Token::Number に、演算子の場合は対応する Token に変換し、それらを Vec に収集します。
infix_to_rpn 関数: 中置記法のトークンのベクターを逆ポーランド記法に変換します。スタックとRPNベクターを使用して、トークンを処理します。演算子の場合、スタックのトップとの優先順位を比較して、適切な順序でRPNに追加します。
precedence 関数: 演算子の優先順位を返します。乗算と除算が優先され、それ以外の演算子は同じ優先順位です。
このコードは、入力された文字列を数値と演算子に分割し、それらを逆ポーランド記法に変換する機能を持っています。特定の演算子の優先順位を考慮しながら適切な順序で演算子を配置し、RPNを生成します。
enum Token {
    Number(f64),
    Plus,
    Minus,
    Multiply,
    Divide,
    LParen,
    RParen,
    EOF,
}
struct Lexer<'a> {
    input: &'a str,
    position: usize,
}
impl<'a> Lexer<'a> {
    fn new(input: &'a str) -> Lexer<'a> {
        Lexer { input, position: 0 }
    }
    fn skip_whitespace(&mut self) {
        while self.position < self.input.len() && self.input.chars().nth(self.position).unwrap().is_whitespace() {
            self.position += 1;
        }
    }
    fn next_token(&mut self) -> Token {
        self.skip_whitespace();
        if self.position >= self.input.len() {
            return Token::EOF;
        }
        let current_char = self.input.chars().nth(self.position).unwrap();
        match current_char {
            '+' => {
                self.position += 1;
                Token::Plus
            }
            '-' => {
                self.position += 1;
                Token::Minus
            }
            '*' => {
                self.position += 1;
                Token::Multiply
            }
            '/' => {
                self.position += 1;
                Token::Divide
            }
            '(' => {
                self.position += 1;
                Token::LParen
            }
            ')' => {
                self.position += 1;
                Token::RParen
            }
            _ => {
                if current_char.is_digit(10) || current_char == '.' {
                    let start = self.position;
                    while self.position < self.input.len() && (self.input.chars().nth(self.position).unwrap().is_digit(10) || self.input.chars().nth(self.position).unwrap() == '.') {
                        self.position += 1;
                    }
                    let number_str = &self.input[start..self.position];
                    let number = number_str.parse::().unwrap();
                    Token::Number(number)
                } else {
                    panic!("Invalid character found: {}", current_char);
                }
            }
        }
    }
}
struct Parser<'a> {
    lexer: Lexer<'a>,
    current_token: Token,
}
impl<'a> Parser<'a> {
    fn new(mut lexer: Lexer<'a>) -> Parser<'a> {
        let current_token = lexer.next_token();
        Parser { lexer, current_token }
    }
    fn eat(&mut self, token: Token) {
        if self.current_token == token {
            self.current_token = self.lexer.next_token();
        } else {
            panic!("Invalid syntax");
        }
    }
    fn factor(&mut self) -> Vec {
        match self.current_token {
            Token::Number(num) => {
                self.eat(Token::Number(num));
                vec![Token::Number(num)]
            }
            Token::LParen => {
                self.eat(Token::LParen);
                let result = self.expr();
                self.eat(Token::RParen);
                result
            }
            _ => panic!("Invalid syntax"),
        }
    }
    fn term(&mut self) -> Vec {
        let mut result = self.factor();
        while vec![Token::Multiply, Token::Divide].contains(&self.current_token) {
            match self.current_token {
                Token::Multiply => {
                    self.eat(Token::Multiply);
                    let mut next_factor = self.factor();
                    result.append(&mut next_factor);
                    result.push(Token::Multiply);
                }
                Token::Divide => {
                    self.eat(Token::Divide);
                    let mut next_factor = self.factor();
                    result.append(&mut next_factor);
                    result.push(Token::Divide);
                }
                _ => panic!("Invalid syntax"),
            }
        }
        result
    }
    fn expr(&mut self) -> Vec {
        let mut result = self.term();
        while vec![Token::Plus, Token::Minus].contains(&self.current_token) {
            match self.current_token {
                Token::Plus => {
                    self.eat(Token::Plus);
                    let mut next_term = self.term();
                    result.append(&mut next_term);
                    result.push(Token::Plus);
                }
                Token::Minus => {
                    self.eat(Token::Minus);
                    let mut next_term = self.term();
                    result.append(&mut next_term);
                    result.push(Token::Minus);
                }
                _ => panic!("Invalid syntax"),
            }
        }
        result
    }
}
fn generate_reverse_polish_notation(input: &str) -> Vec {
    let lexer = Lexer::new(input);
    let mut parser = Parser::new(lexer);
    parser.expr()
}
fn main() {
    let result = generate_reverse_polish_notation("12+34*56/78");
    println!("{:?}", result);
}
コードは、与えられた数式を逆ポーランド記法に変換するためのプログラムです。ここでは、Lexer（字句解析器）とParser（構文解析器）という2つの主要な構成要素があります。
Token
Token 列挙型は、数式をトークンに分割するために使用されます。数字、演算子、および括弧のトークンを定義します。
Lexer
Lexer は、与えられた数式文字列をトークンに分割する役割を担います。next_token メソッドは、数式の文字列を走査して、各文字がどの種類のトークンに対応するかを判断します。
Parser
Parser は、Lexer によって生成されたトークンのストリームを受け取り、逆ポーランド表記に変換します。再帰的に式を解析し、優先順位を考慮しながら、逆ポーランド表記のトークン列を生成します。
factor() メソッドは、数または括弧で始まる要素（ファクター）を解析します。
term() メソッドは、乗算と除算の演算子を解析します。
expr() メソッドは、加算と減算の演算子を解析します。
generate_reverse_polish_notation 関数
この関数は、与えられた数式文字列を逆ポーランド表記に変換します。Lexer を使ってトークンに分割し、Parser を使って逆ポーランド表記のトークン列を生成します。
main 関数
generate_reverse_polish_notation を使って、指定された式を逆ポーランド表記で出力します。
逆ポーランド記法は、演算子がオペランドの後ろに置かれるので、式を解析してトークン列に変換することで、演算の優先順位を反映した形で数式を表現することができます。
----
これらのコードは、与えられた数学式を逆ポーランド記法（Reverse Polish Notation, RPN）に変換する方法を示していますが、アプローチが異なります。
1番目のコードは、文字列を直接解析してトークンに分割し、その後逆ポーランド記法に変換しています。一方、2番目のコードは、字句解析器（lexer）とパーサー（parser）を使用して、トークンに分割し、その後パースして逆ポーランド記法に変換しています。
1番目のコードは、基本的な数値と演算子の処理に集中しています。一方で、2番目のコードは字句解析や構文解析の段階を厳密に分離しています。また、2番目のコードは小数点もサポートしており、より柔軟な数値表現を可能にしています。
どちらのコードも同じ目的を果たしていますが、アプローチの違いが見られます。1番目のコードはシンプルで直感的ですが、拡張性に欠けるかもしれません。
一方で、2番目のコードはより複雑ですが、より柔軟で拡張性があります。それぞれのコードには長所と短所がありますが、どちらも与えられた数式を逆ポーランド記法に変換する点では同等の結果を提供します。実際には２番めのコードは不動小数点数やカッコに対応しています。
use nom::character::complete::{char, digit1};
use nom::combinator::map;
use nom::multi::many0;
use nom::sequence::delimited;
use nom::IResult;
enum Token {
    Number(i32),
    Plus,
    Minus,
    Multiply,
    Divide,
}
fn main() {
    let input = "12+34*56/78";
    let (_, tokens) = parse_input(input).unwrap();
    let rpn = infix_to_rpn(tokens);
    println!("{:?}", rpn);
}
fn parse_input(input: &str) -> IResult<&str, Vec> {
    many0(parse_token)(input)
}
fn parse_token(input: &str) -> IResult<&str, Token> {
    let (input, token) = delimited(
        nom::character::complete::space0,
        nom::branch::alt((
            map(digit1, |s: &str| Token::Number(s.parse().unwrap())),
            map(char('+'), |_| Token::Plus),
            map(char('-'), |_| Token::Minus),
            map(char('*'), |_| Token::Multiply),
            map(char('/'), |_| Token::Divide),
        )),
        nom::character::complete::space0,
    )(input)?;
    Ok((input, token))
}
fn infix_to_rpn(tokens: Vec) -> Vec {
    let mut rpn = Vec::new();
    let mut stack = Vec::new();
    for token in tokens {
        match token {
            Token::Number(_) => rpn.push(token),
            Token::Plus | Token::Minus | Token::Multiply | Token::Divide => {
                while let Some(top) = stack.last().copied() {
                    if precedence(&token) <= precedence(⊤) {
                        rpn.push(stack.pop().unwrap());
                    } else {
                        break;
                    }
                }
                stack.push(token);
            }
        }
    }
    while let Some(op) = stack.pop() {
        rpn.push(op);
    }
    rpn
}
fn precedence(token: &Token) -> i32 {
    match token {
        Token::Multiply | Token::Divide => 2,
        Token::Plus | Token::Minus => 1,
        _ => 0,
    }
}
このコードは、nomというパーサーコンビネータライブラリを使用して、与えられた文字列を解析し、トークンに分割する機能を持っています。前のコードと比較してみましょう。
parse_input 関数: many0コンビネータを使って、parse_tokenを繰り返し適用し、入力文字列をトークンのベクターに変換します。IResult型を返します。
parse_token 関数: delimitedコンビネータを使用してトークンの前後のスペースを処理し、与えられた文字列を様々なルールにマッチングさせます。数字、演算子それぞれのパースを行い、Token列挙型のトークンを返します。
infix_to_rpn 関数: 前のコードと同じですが、与えられたトークンのベクターを逆ポーランド記法に変換する機能を持っています。
このコードは、nomを使ってトークン分割を行い、より柔軟なパースを可能にしています。nomを使用することで、トークンのパースやスペースの処理など、より複雑なルールを柔軟に記述できるようになります。
extern crate num_complex;
use num_complex::Complex;
enum Token {
    Number(Complex),
    Plus,
    Minus,
    Multiply,
    Divide,
    LParen,
    RParen,
    EOF,
}
struct Lexer<'a> {
    input: &'a str,
    position: usize,
}
impl<'a> Lexer<'a> {
    fn new(input: &'a str) -> Lexer<'a> {
        Lexer { input, position: 0 }
    }
    fn skip_whitespace(&mut self) {
        while self.position < self.input.len() && self.input.chars().nth(self.position).unwrap().is_whitespace() {
            self.position += 1;
        }
    }
    fn next_token(&mut self) -> Token {
        self.skip_whitespace();
        if self.position >= self.input.len() {
            return Token::EOF;
        }
        let current_char = self.input.chars().nth(self.position).unwrap();
        match current_char {
            '+' => {
                self.position += 1;
                Token::Plus
            }
            '-' => {
                self.position += 1;
                Token::Minus
            }
            '*' => {
                self.position += 1;
                Token::Multiply
            }
            '/' => {
                self.position += 1;
                Token::Divide
            }
            '(' => {
                self.position += 1;
                Token::LParen
            }
            ')' => {
                self.position += 1;
                Token::RParen
            }
            'i' => {
                self.position += 1;
                Token::Number(Complex::new(0.0, 1.0))
            }
            _ if current_char.is_digit(10) || current_char == '.' => {
                let start = self.position;
                while self.position < self.input.len()
                    && (self.input.chars().nth(self.position).unwrap().is_digit(10)
                        || self.input.chars().nth(self.position).unwrap() == '.')
                {
                    self.position += 1;
                }
                let number_str = &self.input[start..self.position];
                let number = number_str.parse::().unwrap();
                if let Some('i') = self.input.chars().nth(self.position) {
                    self.position += 1;
                    Token::Number(Complex::new(0.0, number))
                } else {
                    Token::Number(Complex::new(number, 0.0))
                }
            }
            _ => panic!("Invalid character found: {}", current_char),
        }
    }
}
struct Parser<'a> {
    lexer: Lexer<'a>,
    current_token: Token,
}
impl<'a> Parser<'a> {
    fn new(mut lexer: Lexer<'a>) -> Parser<'a> {
        let current_token = lexer.next_token();
        Parser { lexer, current_token }
    }
    fn eat(&mut self, token: Token) {
        if self.current_token == token {
            self.current_token = self.lexer.next_token();
        } else {
            panic!("Invalid syntax");
        }
    }
    fn factor(&mut self) -> Complex {
        let token = self.current_token.clone();
        match token {
            Token::Number(num) => {
                self.eat(Token::Number(num));
                num
            }
            Token::LParen => {
                self.eat(Token::LParen);
                let result = self.expr();
                self.eat(Token::RParen);
                result
            }
            _ => panic!("Invalid syntax"),
        }
    }
    fn term(&mut self) -> Complex {
        let mut result = self.factor();
        while vec![Token::Multiply, Token::Divide].contains(&self.current_token) {
            let token = self.current_token.clone();
            match token {
                Token::Multiply => {
                    self.eat(Token::Multiply);
                    let next_factor = self.factor();
                    result = result * next_factor;
                }
                Token::Divide => {
                    self.eat(Token::Divide);
                    let next_factor = self.factor();
                    result = result / next_factor;
                }
                _ => panic!("Invalid syntax"),
            }
        }
        result
    }
    fn expr(&mut self) -> Complex {
        let mut result = self.term();
        while vec![Token::Plus, Token::Minus].contains(&self.current_token) {
            let token = self.current_token.clone();
            match token {
                Token::Plus => {
                    self.eat(Token::Plus);
                    let next_term = self.term();
                    result = result + next_term;
                }
                Token::Minus => {
                    self.eat(Token::Minus);
                    let next_term = self.term();
                    result = result - next_term;
                }
                _ => panic!("Invalid syntax"),
            }
        }
        result
    }
}
fn main() {
    let lexer = Lexer::new("(2+ 3i)*4i");
    let mut parser = Parser::new(lexer);
    let result = parser.expr();
    println!("{:?}", result);
}
このコードは、数式をパースして複素数を計算する簡単な計算機の基本的な実装です。Rustの機能を活用して、トークン列を生成するLexerと、そのトークン列を解析して計算を行うParserを定義しています。
Tokenは、パーサーが認識するトークンの種類を表すenumです。Lexerは文字列を受け取り、その文字列をトークンに分割する役割を果たします。各トークンは、演算子や数値、括弧などを表現しています。Parserは、Lexerが生成したトークン列を受け取り、それを解析して数式を計算します。
Lexerは空白をスキップし、文字列を一文字ずつ見ていき、トークン列を生成します。Parserはトークン列を再帰的に解析し、四則演算を行って複素数を計算します。演算子の優先順位や括弧の処理も考慮されています。
このコードは、入力文字列 (2+ 3i)*4i を受け取り、それを計算して結果を表示します。各段階でトークンが正しく識別され、演算子や数値が正しく解釈されることを期待しています。
コード内のパニックは、予期しないトークンや構文エラーがあった場合に発生します。これらのエラーは、コードが期待する形式に文字列が合致しなかった場合に発生します。
このコードを用いると、複雑な数式も計算できますが、入力の検証やエラー処理についてはまだ改善の余地があります。
extern crate num_complex;
use num_complex::Complex;
fn main() {
    // 複素数の作成
    let a = Complex::new(3.0, 4.0);
    let b = Complex::new(-2.0, 5.0);
    println!("a: {a}");
    println!("b: {b}");
    println!("a + b: {}", a + b);
    println!("a - b: {}", a - b);
    println!("a * b: {}", a * b);
    println!("a / b: {}", a / b);
}
実行結果:
a: 3+4i
b: -2+5i
a + b: 1+9i
a - b: 5-1i
a * b: -26+7i
a / b: 0.4827586206896552-0.7931034482758621i
このコードは、num-complexクレートを使用して複素数を扱うRustの例です。
extern crate num_complex; および use num_complex::Complex; は、num-complexクレートからComplex型を使えるようにするためのインポートです。
Complex::new(3.0, 4.0); および Complex::new(-2.0, 5.0); は、実部と虚部を指定して複素数を作成しています。
println!("a: {a}"); および println!("b: {b}"); は、複素数 a と b を出力しています。
b: {}", a * b);、println!("a / b: {}", a / b); は、それぞれ複素数 a と b の加算、減算、乗算、除算を行っています。結果を文字列として出力しています。
修正されたコードは次のようになります：
Goから順列・組合わせを移植
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=73612aa97bd4a1541a0313f38effde87 順列]:
fn permutation(s: &[T], n: usize) -> Vec> {
    if s.is_empty() {
        panic!("slice is nil");
    }
    if n == 1 {
        let mut result = Vec::new();
        for v in s.iter() {
            result.push(vec![v.clone()]);
        }
        return result;
    }
    let mut result = Vec::new();
    for (i, v) in s.iter().enumerate() {
        let mut sf = Vec::new();
        for (j, w) in s.iter().enumerate() {
            if j != i {
                sf.push(w.clone());
            }
        }
        for w in permutation(&sf, n - 1) {
            let mut v_w = vec![v.clone()];
            v_w.extend_from_slice(&w);
            result.push(v_w);
        }
    }
    result
}
fn main() {
    println!("{:?}", permutation(&[1, 2, 3], 1));
    println!("{:?}", permutation(&[0, 1, 2], 2));
    println!(
        "{:?}",
        permutation(&["abc".to_string(), "def".to_string(), "xyz".to_string()], 3)
    );
    println!("{:?}", permutation::(&[], 2));
}
実行結果:
1], [2], [3
0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1
"abc", "def", "xyz"], ["abc", "xyz", "def"], ["def", "abc", "xyz"], ["def", "xyz", "abc"], ["xyz", "abc", "def"], ["xyz", "def", "abc"
解説
上記の移植において、主に以下の点に注意が必要でした。
ジェネリック型の宣言方法がGoとは異なるため、func Permutation[T any](s []T, n int) のような書き方はできません。Rustでは、fn permutation(s: &[T], n: usize) のように、の前に:を付けてジェネリック境界を宣言します。
Goのmakeは、新しい配列やスライスを作成するための組み込み関数ですが、RustではVec::with_capacity()やVec::new()を使用します。
panic!("slice is nil")は、Rustのパニック処理において、エラーメッセージを伴うパニックを発生させるために使用されます。
Vecに要素を追加するには、Goのappendに相当するRustのメソッドであるVec::push()や、Vec::extend_from_slice()を使用します。また、Vecの要素数は、len()ではなくlen()とVec::capacity()の両方を使って取得する必要があります。
[https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=06e15597fcf3bdc585abeccd3edb9454 組合わせ]:
fn combination(s: &[T], n: usize) -> Vec> {
    if s.is_empty() {
        panic!("slice is empty");
    }
    if n == 1 {
        let mut result = Vec::new();
        for v in s {
            result.push(vec![v.clone()]);
        }
        return result;
    }
    let mut result = Vec::new();
    for i in 0..=(s.len() - n) {
        let v = s[i].clone();
        for w in combination(&s[i + 1..], n - 1) {
            let mut res = vec![v.clone()];
            res.extend(w);
            result.push(res);
        }
    }
    return result;
}
fn main() {
    println!("{:?}", combination(&[1, 2, 3], 1));
    println!("{:?}", combination(&[0, 1, 2], 2));
    println!(
        "{:?}",
        combination(&["abc", "def", "xyz"], 3)
    );
    // println!("{:?}", combination(&[], 2)); 要素型が確定できない
}
実行結果:
1], [2], [3
0, 1], [0, 2], [1, 2
"abc", "def", "xyz"
解説
上記の移植において、主に以下の点に注意が必要でした。
Rustのジェネリック関数の型パラメータには制約が必要なため、Tがクローン可能であることを示すCloneトレイトを指定する必要があります。
Goのスライスと異なり、Rustのスライスは要素数が0の場合にも安全であるため、ErrNilSliceに相当する処理はslice.is_empty()で判定することができます。
Goのスライスと異なり、Rustのスライスは範囲外アクセスがパニックを引き起こすため、再帰呼び出し時にはスライスの範囲を明示的に指定する必要があります。