新米Rustaceanの🌾🦀による🌾🦀のためのRust入門「C++/C#プログラマーでも読めるようになる」

Rustで簡単なツールを作ってみました。はじめてのTUI（モドキ）のツールです。

https://github.com/arkbig/mntime

このバージョン0.1.0を作ったことで得られた知見をまとめてみます。
長文になってしまったので目次をうまく使ってください。（スマホ画面だと上部の目次をタップしないと表示されないので少し見づらいです。）

「いいね」、「ツイート」、「バッジを贈る」、「コメント」大歓迎です！

作成ツール紹介

みなさん、timeコマンドでコマンドの実行時間を計測しますよね？Rust製のhyperfineというツールがあり、複数回実行して平均を出したり、複数コマンドを比較できたり便利です。
これを見て私はメモリ使用量も計測できたらうれしいなと思ったんです。

そう、このmntimeコマンドを使えば、実行時間とメモリ使用量の平均値が分かるんです！

そんなツールですがRustで作った経緯は、最近ターミナル環境を整えました。そのとき、モダンで便利なナウいコマンドラインツールにRust製が多いのに気付いたんです。（目の付け所がよい！）Rustだと簡単にコマンドラインツールが作れるんじゃないか？と思い飛びついてしまいました。

それが、こんなに難しいとは…。この苦労を話したいので記事にしました。Rust初心者の人はぜひ読んで飛び越えていってください。

自己紹介

私は普段C#で社内ツールを作っています。ちょっと前はC++でゲームを作ってたりしてました。
PythonやJavaScriptもたまに使いますが、１ファイルだけのちょっとしたスクリプトくらいです。
今回のプロジェクトはRust, TUI, Git, GitHub, OSSと本格的に作るのはじめての環境でいろいろ苦労しました。いえ、まだ理解してない機能が多いので今も苦労しています。
とはいえ、流行っている環境なので整備がしっかりされていて感心することが多いプロジェクトでした。

ということで、私がC++,C#プログラマーの視点でRustの基本を書いてみます。

参考文献

• 実践Rustプログラミング入門

https://www.amazon.co.jp/dp/4798061700/

• The Rust Programming Language 日本語版

https://doc.rust-jp.rs/book-ja/

• 標準ライブラリ API Reference

https://doc.rust-lang.org/std/

• クレートリポジトリ

https://crates.io

開発環境

今回はRust v1.63.0を使って開発をしました。
マシンはMac mini M1を使い、エディタはVisual Studio Code(VSCode)で、Rust用に次の拡張機能をインストールしてます。

• CodeLLDB: デバッガ
• rust-analyzer: Rustコード作成補助（昔はrust-lang.rustが使われてたらしい）

では前置きが長くなりましたが、mntimeコマンドのバージョン0.1.0を作るのに利用した機能を紹介していきます。

用語集

• Rustacean（ラステイシャン）: Rustを書く人のこと。Crustacean（甲殻類）が語源で、よくカニのアイコンが使われる。（公式アイコンは自転車のギア）
• Edition（エディション、版）: Rustの大規模変更バージョン。各クレートが別のEditionでもビルドができる。
• cargo（カーゴ、積み荷）: Rustのビルドツール、パッケージ管理ツールです。サブコマンドでいろいろな機能がある。
• crate（クレート、木箱）: ライブラリ。主にcrates.ioで公開されている。
• module（モジュール、部品の集まり）: C#でいうnamespaceのようなもの。
• trait（トレイト、特徴）: C#でいうインタフェースのようなもの。
• derive（ディライブ、導き出す）: マクロの１種でコードの型定義から別のコードを自動生成する。よくtraitの派生を自動実装するとかに使われる。
• attribute（アトリビュート、属性）: マクロの１種で型定義以外（関数やフィールドなど）かも別のコードを自動生成する。よくtestで使われる。
• panic（パニック、慌る）: スレッドを強制終了させる。
• unwrap（アンラップ、包装を解く）: 正常値を期待して展開する。異常値ならパニックが発生。
• let（レット、仮に〜としよう、貸す）: 変数宣言。変数に値を束縛する。

長くなったので要約

C++/C#を知っている人向けのとりあえずソースコードを読むのに必要な最低限の知識をまとめます。

• cargoコマンドがビルドシステム兼パッケージマネージャーです。ビルドはcargo buildもしくはcargo runで行い、cargo addでライブラリ（クレート）を追加できます。
• Cargo.tomlファイルに書かれたライブラリ（クレート）を自動でリンクしてくれます。
• ソースコード分割するには、mod <モジュール名>を使って使用するファイル（モジュール）を明示する必要があります。
• use <パス>で名前解決を省略できます。パス指定はクレート名::モジュール名::対象の形です。その際、self::は自分の階層を表し、super::はひとつ上の階層を表します。普通のパス指定の.と..のようなものです。またcrate::はプログラムのルート階層を表します。
• 変数宣言はlet（不変）/let mut（変更可）で行います。&で参照、*で逆参照ができます。型推論があり、いろいろな場所で型を省略できます。
• 基本型の変数はコピー渡し/代入ですが、一般的にはムーブ渡し/代入です。
• 変数は通常スタック領域にのりますが、Box<T>::new(123)とするとヒープ領域にのります。
• 列挙型enumは値ごとにを別々の変数を保持できます。
• if let Some(x) { println!({x}) }やmatch expr { Ok(x) => {println!({x})}, Err(_) => {panic!()}}のようなパターンマッチができます。
  • 標準でよく使う列挙型が２つあり、Option<T>がSome(_)とNone持ち、Result<T,E>がOk(_)とErr(_)を持っています。
  • Result<>式は?をつけるとErr(_)時に早期return Err(_)してくれます。Option<>も同様にNoneを早期リターンできる。また、Some(x)やOK(x)のxを取り出すのに、unwrap()もよく使われますが、None、Err(_)の場合panic!()が発生します。
• classはなくstructのみで、メンバー関数はimpl 構造体名 { fn func(&self){} }で定義します。
• 継承はtraitがinterface / abstructのような感じで、impl トレイト名 for 構造体名 { }で実装します。
• クロージャは|arg,arg2| {〜}の形です。
• マクロは!で終わります。呼び出しはmacro!(〜)、macro![〜]、macro!{〜}どれでもいいです。定義はmacro_rule!を利用します。
• #[〜]アトリビュートでさまざまな修飾があります。

それぞれ、以降で少し詳細に説明しています。

cargoの使い方

cargoというRustエコシステムのためのツールが標準で付いています。これがパッケージ管理やビルド、テスト、ドキュメント生成などいろいろこなしてくれる何でも屋です。このcargoの機能から私が使ったものを紹介します。

プロジェクト作成

cargo new <path>
# すでにフォルダがあるなら
cargo init [path]

<path>にRustプロジェクトを作成します。Cargo.tomlファイルやsrcフォルダが作られます。デフォルトはアプリ用テンプレートを使用しますが、--libオプションが指定されるとライブラリ用テンプレートが使われます。

ツールインストール

cargo install <crate> ...
# アンインストール
cargo uninstall <crate> ...

crates.ioから<crate>をインストールします。デフォルトインストール先は$HOME/.cargo/binです。<crate>は--git <URL>でGitHubなどGitリポジトリを直接指定したり、--path <PATH>でローカルのパスを直接指定したりできます。

今のところ私は次のものをインストールしています。

• cargo-audit: cargo auditでセキュリティ脆弱性報告のあったクレートバージョンを使用しているか確認できます。

• cargo-expand: cargo expandでマクロを展開して確認できます。

• cargo-license: cargo licenseで依存クレートのライセンス名を表示します。

  • README.md用にパイプ区切りのテーブル出力するワンライナー

    # 直接依存しているものだけリストアップ
    cargo license --direct-deps-only --avoid-build-deps --avoid-dev-deps | awk -F ":" 'BEGIN {printf "|License|crate|\n|-|-|\n"} {printf "|%s|%s|\n", $1, $2}'
    # 再起的に依存しているものも含めてリストアップ
    cargo license --avoid-build-deps --avoid-dev-deps | awk -F ":" 'BEGIN {printf "|License|crate|\n|-|-|\n"} {printf "|%s|%s|\n", $1, $2}'
    

• cargo-trend: cargo trend <crates> ...でクレートのダウンロード数をtrend.svgファイルにグラフ化してくれます。--relativeオプションで数ではなく比率でグラフ化できます。

クレート検索

cargo search <query>

crates.ioからクレートを探します。

クレート追加

cargo add <DEP> ...

依存クレートをCargo.tomlファイルに追加します。--gitや--path、--registryオプションでクレート検索場所を指定できます。--features <FEATURES>で追加するクレートの機能を選択可能です。また、--devでtestsやexamples、benchmarks用にインストールしたり、--buildでビルドスクリプト用にインストールできます。

クレート依存関係確認

cargo tree

ツリー形式で依存クレートを表示できます。

ビルドチェック

cargo check

ソースコードを解析してビルドエラーを確認します。バイナリ生成までいかないのでbuildより高速です。

ビルド

cargo build

ソースコードをビルドします。--releaseオプションで最適化のかかったリリースモードでビルドします。buildコマンドはあまり使わず、普段は後述の直接実行を使用します。

実行

cargo run -- [args] ...

ソースコードをビルドして実行します。--で区切った後の引数が実行ファイル側のオプションになります。--example [<NAME>]でexamples/フォルダ下の<NAME>をビルド＆実行できます。

テスト

cargo test

テストを実行します。ソースコード中の#[test]アトリビュートのついた関数だけでなく、ドキュメントコメント中のコードもテストしてくれます。

ドキュメント作成

cargo doc

ソースコードに書いたドキュメントコメントからドキュメントを作成します。--openオプションで生成したものをブラウザで開いてくれます。（Safariだと正しく表示されなかったので、Chromeで開き直して見てます。）

ソースコードフォーマット

cargo fmt

ソースコードをフォーマットしてくれます。

ソースコード分析

cargo clippy

ソースコードを分析してくれます。いわゆるLinterです。--fixオプションで自動修正できるものは対応してくれます。

削除

cargo clean

cargoが生成したファイルたちを削除します。

crates.ioにクレートを公開

cargo login
cargo publish

cargo publishで公開するには事前に次の作業が必要です。--dry-runオプションでチェックだけ走ります。

• Cargo.tomlに必要な情報を書く
• crates.ioでアカウントを作成しAPIトークンを準備する
• cargo loginでログインするための、APIトークンを保存する

公開したくないものはCargo.tomlにpublish=falseを書いておくと間違えて実行してもエラーになります。

詳しくはCrates.ioにクレートを公開するを参照ください。

Cargo.tomlについて

Cargo.tomlにパッケージのメタ情報が書かれています。詳しくはThe Manifest Formatを参照ください。

[package]セクション

プロジェクトの名前やバージョン、READMEの場所などで、crates.ioに公開するときにもここの情報が使われます。

[dependencies]セクション

パッケージに必要な依存クレートを書きます。cargo addで追加ができますが、直接追記してもいいです。

[dev-dependencies]セクション

testsやexamples、benchmarks用に必要な依存クレートを書きます。cargo add --devで追加できます。

[build-dependencies]セクション

ビルドスクリプト用に必要な依存クレートを書きます。cargo add --buildで追加できます。

Cargo.lock

ビルドするとCargo.tomlのdependenciesにもとづいてクレートがダウンロードされ、そのバージョンがCargo.lockに記載されます。Cargo.lockファイルは実行ファイルプロジェクトならバージョン管理に追加し、ライブラリプロジェクトならバージョン管理からignoreするのがいいようです。

https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html

ソースコード分割

Rustはバイナリプロジェクトならsrc/main.rs、ライブラリプロジェクトならsrc/lib.rsがそれぞれエントリーポイントのファイルです。特に指定がなければこの１ファイルのみがビルドされます。
単純なスクリプト処理でなければ、複数のファイルに分けて管理することになるでしょう。その場合モジュールとして分割します。

同じファイル内でモジュールを分ける

main.rs

fn my_func() {
    println!("Hello, world!");
}
fn main() {
  my_module::hoge(); // 下層へのアクセスは`モジュール名::`
}
mod my_module {
  pub fn hoge() {
    super::my_func(); // 上層へのアクセスは`super::`
  }
}

このように、ファイル内にmod <モジュール名> {〜}と書くとモジュールを定義できます。入れ子の場合、下層から上層はsuperを使ってアクセスできます。上層から下層の場合は<モジュール名>でアクセスできますが、pubとしたpublicなものだけです。
ちなみにpub(<公開範囲>)で範囲を指定できます。

• pub(in <path>): 指定のパスに公開
• pub(self): 同じモジュール内に公開
• pub(super): 親モジュール内に公開
• pub(crate): 同じクレート内に公開

同フォルダ内でモジュールを分ける

📂 src
├── main.rs
└── my_module.rs

main.rs

fn my_func() {
    println!("Hello, world!");
}
fn main() {
    my_module::hoge();
}
// 解析されるmain.rsでモジュール分割宣言をする
// これが無いとmy_module.rsは解析されない
mod my_module;

my_module.rs

// mod {〜}で囲まない（ファイル名がモジュール名になる）
pub fn hoge() {
    super::my_func();
}

ファイル分割しただけではビルド対象に追加されず、main.rsでmod モジュール名;と宣言しないといけない。最初はこれを書かなくてうまくビルドできず、外部クレート化して暫定対応してた。（おかげでthrobber-widgets-tuiが作られた）

子フォルダにモジュールを分ける（2018エディションで追加されたバージョン）

📂 src
├── main.rs
├── my_module.rs // 子フォルダと同名
└── 📂 my_module
    ├── bar.rs
    └── foo.rs

main.rs

fn my_func() {
    println!("Hello, world!");
}
fn main() {
    my_module::bar::hoge(); // 階層指定が１つ深くなった
}
mod my_module;

my_module.rs

// フォルダ名と同じファイル名.rsを作成
pub mod bar; // 下層フォルダ内のビルド対象ファイルを列挙する
mod foo; // pubしなくても同じ階層（ここだとbar)からはアクセスできる

// modだけでなく
pub fn foo() {
    // ここにも定義が書ける
}

// 別のモジュールをまるでここで定義したように公開できる
// crate::foo::fuga()でなく、crate::fuga()でアクセスできる
pub use self::foo::fuga;

my_module/bar.rs

pub fn hoge() {
    super::foo::fuga(); // 同じ階層モジュールへのアクセス
}

my_module/foo.rs

pub fn fuga() {
    crate::my_func(); // super::super::でもいいが、最上層はcrate::でアクセスできる
}

フォルダと同名のファイルを用意すると、サブモジュールとしてフォルダが使用できます。

子フォルダにモジュールを分ける（昔からあるバージョン）

📂 src
├── main.rs
└── 📂 my_module
    ├── bar.rs
    ├── foo.rs
    └── mod.rs // サブモジュールのエントリーポイント

2018エディション版とだいたい同じですが、my_module.rsファイルがmy_module/mod.rsファイルになっています。
この方式だと複数サブモジュールのフォルダがあるとエディタで多数のmod.rsファイルが開かれて紛らわしいため新しい方式が追加されました。とはいえ、１つのフォルダにまとまっているという利点があるので引き続きこちらの方式も使われています。（フォルダ下でmod.rsじゃなくてフォルダ名と同名ファイルが置ければ良かったのに、なんで１階層上に置く必要があったんだろうか。）

クレート分割

📂 src
├── main.rs
└── 📂 my_crate // 独立したライブラリ（場所はどこでもいい）
    ├── Cargo.toml
    └── 📂 src
        └── lib.rs // ライブラリのエントリーポイント

ソースコード分割より厳密に権限を分けるには、別ライブラリとしてクレート分割をします。

# クレート作成
cargo new --lib my_crate
# 作成したクレートの利用申請
cargo add --path my_crate

main.rs

fn main() {
    my_crate::add(1, 2);
}

my_crate/src/lib.rs

pub fn add(left: usize, right: usize) -> usize {
    left + right
}

クレートの作成場所は今回src/配下にしていますが、どこでも（プロジェクト外でも）いいです。ライブラリのエントリーポイントはlib.rsとなっています。

そして使用する側でcargo add --pathとするとローカルのファイルをCargo.tomlの[dependencies]に追加できます。cargo add --gitだとGitリポジトリ（GitHubとか）も指定できるので、crates.ioで公開しなくても使用できます。
呼び出しはクレート名::*と指定します。もし、クレート側がモジュールに別れている場合my_crate::my_module::my_funcのように指定します。

use

Rustにはuse <path>という、C++のusing namespaceのようなものがあります。
モジュールやクレートの階層が深くなると毎回フルパスで書くと冗長になったり、別のクレートと簡単に差し替えられるようにしたいとき利用します。

main.rs

fn my_func() {
    println!("Hello, world!");
}
fn main() {
    use my_module::hoge;
    hoge(); // my_moduleのhogeを使用する
}
mod my_module {
    pub fn hoge() {
        super::my_func();
    }
}

パスを省略できるだけでなく、as エイリアス名を付与すると別名をつけることも可能です。

fn main() {
    use my_module::hoge as my_hoge; // 別名をつける
    my_hoge(); // my_moduleのhogeを使用する
}

パスの省略だけでなく、トレイトの利用にもuse <path>の指定が必要なときもあります。（きちんと理解できてません。）この場合省略は不要であればas _とアンダースコアを使うと正しく参照しつつ、省略できない状態にできます。

use rand::Rng as _; // グローバルにも書ける
fn main() {
    let mut rng = rand::thread_rng();
    rng.gen()
}

また、{〜}を使えば、複数同時に指定できます。

use my_crate::{hoge as _, module_foo::bar};

以上が基本的なuseの使い方ですが、たまにextern crateキーワードを見ることがあります。これは昔の書き方で、今は９割９分の場面で必要なくなったらしいです。

https://doc.rust-jp.rs/edition-guide/rust-2018/path-changes.html

変数

let / let mut

Rustの変数宣言はletを使用します。デフォルトだと変更不可（immutable）です。letは「（やりたいことを）させる、（アパートなどの不動産を）貸す、仮に〜としよう」などの意味があります。binding（束縛）とも言います。

let x = 1;
x = 2; // ビルドエラー。変更不可
let x = 2; // 再定義はできる

let mutとすると変更可（mutable）になります。

let mut x = 1;
x = 2; // 変更できる
let x = x; // 再定義可能（let mutもOK）

型指定もできます。

let x: i32 = 1;
let x: f64 = 2.0; // 浮動小数型は小数点必須（`2.`でもOK）

const

constで定数を宣言できます。今のところconstは型指定を省略できません。constは大文字を使うのが推奨されています。

const X: i32 = 1;
const X: f64 = 2.0; // ビルドエラー。letと違い同名は同じスコープ内では使えない
let y = 2;
const Y: i32 = y; // ビルドエラー。constはビルド中に分かる定数しか代入できない

static

staticでプログラム実行中生存し続ける変数が宣言できます。const同様に型指定を省略できませんし、大文字を使うのが推奨されています。

static X: i32 = 1;
static X: f64 = 2.0; // ビルドエラー。letと違い同名は同じスコープ内では使えない
let y = 2;
const Y: i32 = y; // ビルドエラー。staticはビルド中に分かる定数しか代入できない
static mut Z: i32 = 2; // mutで変更可能になるが、参照する場所すべてunsafe操作になる
unsafe { Z = 3; }

once_cell (lazy-static)

staticがビルド中に分かる定数しか代入できないのは不便ですので、動的変数を設定できプログラム実行中生存し続ける変数を使えるようにするクレートがあります。
昔から使われているのはlazy-staticですが、最近はOnceCellに置き換わってきています。OnceCellが標準入りする？

fn main() {
    use once_cell::sync::OnceCell;
    let mut x = 2;
    static X: OnceCell<i32> = OnceCell::new();
    let y = *X.get_or_init(|| x);
    println!("{}", y); // => 2
    x = 3;
    let y = *X.get_or_init(|| x); // ２回目以降は初期化済みの値を取得する
    println!("{}", y); // => 2
}
// 関数内static変数にして返すのが良い
fn hoge() -> i32 {
    static hoge: OnceCell<i32> = OnceCell::new();
    *hoge.get_or_init(|| 1)
}

変更可能なstaticを定義したい場合は、OnceCellとMutexを組み合わせます。staticはスレッドセーフにする必要があり、Cell<_>が使えません。

fn main() {
    use once_cell::sync::OnceCell;
    static X: OnceCell<std::sync::Mutex<i32>> = OnceCell::new();
    X.set(std::sync::Mutex::new(1)); // 初期化
    println!("{}", *X.get().unwrap().lock().as_ref().unwrap()); // => 1
    *X.get().unwrap().lock().unwrap() = 2; // 初期化したMutexを取得し、その値を変更
    println!("{}", *X.get().unwrap().lock().as_ref().unwrap()); // => 2
}

参照

基本型を除きRustはムーブセマンティクスがデフォルトとなってます。関数呼び出しのたびムーブしているとたいへんなので参照のしくみもあります。
&で参照を表します。これをborrowing（借用）と言い、ムーブセマンティクスはownership（所有権）の移動となります。

fn puts(msg: String) {
    println!("{}", msg);
}
fn puts_ref(msg: &String) {
    println!("{}", msg);
}
fn main() {
    let msg = "hoge".to_string();
    puts_ref(&msg);
    puts_ref(&msg);
    puts(msg);
    puts(msg); // ビルドエラー。ムーブ済み変数の参照
}

&mutで変更可能な参照ができます。ただし、&含めてただ１つのみしか参照できません。

fn main() {
    let mut msg = "hoge".to_string();
    {
        let x = &msg;
    }
    {
        let mut y = &mut msg;
        y.insert_str(0, "foo.");
    }
    println!("{}", msg); //=> foo.hoge

    let u = &msg;
    let w = &mut msg; //ビルドエラー。可変参照はただ１つのみ存在できる
    msg = "bar".to_string(); //ビルドエラー。参照で貸し出してる（borrowed）ので変更不可
    println!("{}", u);
}`

ライフタイム

変数には有効な期間がありライフタイムと言います。Dropトレイトを実装しているとライフタイムが尽きるときにdrop()が呼び出されます。

struct My {
    msg: &'static str
}
impl Drop for My {
    fn drop(&mut self) {
        print!("{},", self.msg);
    }
}
fn main() {
    let a = My { msg: "a" };
    let b = My { msg: "b" };
    {
        let c = My { msg: "c" };
    }
}
//=>
// c,b,a,

これのa, b, cを参照で借用してみます。

fn main() {
    let a = My { msg: "a" };
    let b = My { msg: "b" };
    let mut x = &a;
    x = &b;
    {
        let c = My { msg: "c" };
        x = &c; // xのライフタイムがcのライフタイムより長いためビルドエラー
    }
    x; // この行を消すとビルドできる
}

上記コードだと、xのライフタイムがmain関数の終了までありますが、cのライフタイムが関数内スコープだけと短くなっています。このように借用する側の方が長生きするのはできません。しかし、Rust 1.32以降なら最後の行のx;を削除するとビルドができてしまいます。これは現在のRustはレキシカルスコープによらないライフタイム（NLL, None Lexical Lifetime）である借用チェッカーが導入されていて、最後に使用したところまででライフタイムが尽きるようになりました。

ところでstruct Myのフィールドに&'static strという型指定があります。これはライフタイムが'static（プログラム実行中ずっと有効）な&strを表しています。'staticは特殊なライフタイム注釈です。通常は<'〜>を使って宣言する必要があります。

// この関数の返り値のライフタイムは引数のライフタイム（短い方が適用される）と同じ
fn which<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x == y {
        x
    } else {
        y
    }
}
fn main() {
    let mut x = "x";
    {
        let msg = "msg".to_string();
        x = which("hoge", msg.as_str()); // ビルドエラー。
        // "hoge"はstaticなライフタイムで、msgはこのスコープ内だけなので、
        // 短いmsgと同じライフタイムが返ってくる
    }
    //この行を消せば借用チェッカーがいい感じに判断して、ビルドエラーがなくなる
    println!("{}", x);
}

型

数値型

Rustのスカラー型の整数、浮動小数はビットサイズを使って表します。

• 符号付き整数: i8,i16,i32,i64やポインタサイズに依存するisize
• 符号なし整数: u8,u16,u32,u64,usize
• 浮動小数: f32,f64

整数リテラルの基準はi32で、浮動小数リテラルの基準はf64です。型を明示するには接尾辞をつけます（123u16、1.2f32とか）。
数値リテラルは_を桁区切りに使え（無視され）、16進数は0x、8進数は0o、2進数は0bの接頭辞をつけます（1_234、0xff、0o664、0b1010とか）。
浮動小数リテラルはe（10の冪乗）表記もできます（1.23e2==123）。
また、バイト(u8)を表すb'A'もあります。

整数はソートができますが、浮動小数はNANがあるためソートはできません。

fn main() {
    let mut x = vec![1, 4, 2, 3];
    x.sort();
    let mut y = vec![1.0, 4.0, 2.0, 3.0];
    y.sort(); // ビルドエラー。NANがあるのでソートが用意されていない
}

論理値型

Rustでの論理値はtrue,falseです。

文字型

Rustの文字はUTF-8で、最小単位はcharです。文字列はstr型で、通常は&strの形で使われます。また、標準ライブラリで定義されているStringもよく使われます。

タプル型

タプルは複数の値をひとつの複合型にまとめた型です。(〜)で表します。

fn main() {
    let tuple: (i32, f64, u8) = (500, 6.4, 1);
    tuple.0; // 500
    tuple.1; // 6.4
    tuple.2; // 1
}

配列型

配列は[〜]で表します。

fn main() {
    let arr: [i32; 5] = [ 0, 1, 2, 3, 4 ];
    arr[0]; // 0オリジン
    let x = &arr[2..4]; // スライス[2, 3]
    let y = &arr[2..=4]; // スライス[2, 3, 4] inclusive ranges
    let z = &arr[2..]; // スライス[2, 3, 4]
    let u = &arr[..2]; // スライス[0, 1]
}

配列型名が少し特殊で、サイズ指定有りは[型名; 要素数]、サイズ指定なしだと[型名]です。

列挙型

enumで列挙子が定義できます。C++と違って、値が変数をもつことができます。（確認してませんが、enum型のサイズはC++のunionのように最大の値になります。）

enum Msg {
    Quit,
    PrintH(String), // String型を持つ値
    ReportPoint(i32, i32), // ２つのi32を持つ値
}
fn main() {
    let x = Msg::Quit;
    let y = Msg::PrintH("msg".to_string());
    let z = Msg::ReportPoint(1, 2);
}

制御構文の説明で取り上げますが、かなりパワフルです。C++のnullptrのように扱えるOptionやエラー処理に使えるResultもenumです。

// イメージです。
// enum Option {
//     Some(〜),
//     None,
// }
// イメージです。
// enum Result {
//     Ok(〜),
//     Err(〜),
// }
fn main() {
    let opt_x = Some(1);
    if opt_x.is_some() {
        println!("Some={}", opt_x.unwrap());
    }
    let opt_y = Option::<i32>::None;
    if opt_y.is_none() {
        println!("None")
    }
    let res_x: Result<i32, i32> = Ok(2);
    if res_x.is_ok() {
        println!("Ok={}", res_x.unwrap());
    }
    let res_y = Result::<i32, i32>::Err(3);
    if res_y.is_err() {
        println!("Err={}", res_y.err().unwrap());
    }
}
//=>
// Some=1
// None
// Ok=2
// Err=3

構造体

structで独自の型を定義できます。C++と違ってデフォルトがprivateで、classのメンバー関数のような機能もできます。

// 構造体定義
struct My {
    pub x: i32, // public
    pub y: i32, // public
    z: i32, // private
}
// メンバー関数は別で定義
impl My {
    // 決まったコンストラクタは無いが、慣例としてnewが使われる
    // self引数がないのでクラス関数
    pub fn new(x: i32, y: i32) -> Self {
        My { x: x, y: y, z: 1 }
    }
    // x, yを受け取って、&mut Myを返す。メンバ関数になる。
    pub fn add(&mut self, x: i32, y: i32) -> &mut Self {
        self.x += x;
        self.y += y;
        self
    }
}
fn main() {
    let mut x = My::new(1, 2); // クラス関数はクラス名::関数名()で呼び出す
    x.add(3, 4).add(5, 6);  // &Selfを返すメンバ関数だと連続呼び出しができる
}

trait（トレイト、特性）

C#でいうところのinterfaceやabstructが、Rustではtraitとなります。

// トレイト宣言
trait Hoge {
    fn hoge(&self);
    // デフォルト実装も書ける
    fn fuga(&self) {
        println!("Hoge");
    }
}
// 継承１
struct Foo {}
// トレイト実装
impl Hoge for Foo {
    fn hoge(&self) {
        println!("Foo");
    }
}
// 通常の関連関数は別途いつもどおり定義できる
impl Foo {
    fn add(&mut self, x: i32) {

    }
}
// 継承２
struct Bar {}
// トレイト実装
impl Hoge for Bar {
    fn hoge(&self) {
        println!("Bar");
    }
    fn fuga(&self) {
        println!("Bar");
    }
}
fn main() {
    let x = Foo{};
    let y = Bar{};
    x.hoge(); //=> Foo
    x.fuga(); //=> Hoge
    y.hoge(); //=> Bar
    y.fuga(); //=> Bar
}

トレイト実装はimpl トレイト名 for 構造体名キーワードを使用します。デフォルト実装があれば、継承先では定義不要で、もし定義すればオーバーライドされます。

derive（ディライブ、導き出す）

Rustには#[derive(〜)]という、C#のアトリビュートのようなものがあります。（Rustにもアトリビュートあります）
これはマクロの１種で型定義から別のコードを自動生成してくれます。よくtraitの派生を自動実装するとかに使われます。

#[derive(Debug)] // 自動生成対象の直前に書く
struct MyStruct {
    foo: i32,
}
fn main() {
    let s = MyStruct { foo: 1 };
    println!("{:?}", s); // {:?}でDebug::fmt()が出力される
}

↑これが↓こう。（イメージです、ビルドできません。）

struct MyStruct {
    foo: i32,
}
// `cargo install cargo-expand`後に`cargo expand`でマクロの展開を確認できる
impl ::core::fmt::Debug for MyStruct {
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field1_finish(
            f,
            "MyStruct",
            "foo",
            &&self.foo,
        )
    }
}
fn main() {
    let s = MyStruct { foo: 1 };
    println!("{:?}", s);
}

#[derive(Debug)]により、Debugトレイトの実装が自動生成されます。
今回mntimeで使ったものたち。

• clap::Parser: コマンドライン引数の解析ライブラリclapのstruct定義から引数解析するコードを生成する。

  // Cargo.tomlやドキュメントコメントもヘルプメッセージに使用される
  #[derive(clap::Parser)]
  #[clap(author, version, about, long_about = None, setting = clap::builder::AppSettings::TrailingVarArg | clap::builder::AppSettings::DeriveDisplayOrder)]
  pub struct CliArgs {
      /// Perform NUM runs for each command.
      #[clap(short, long, value_parser, value_name = "NUM", default_value_t = 10)]
      pub runs: u16,
  
      /// Set the shell to use for executing benchmarked commands.
      ///
      /// This is executed as `sh -c time command1`.
      /// If execution confirmation is not obtained, also try `/usr/bin/env bash`.
      ///
      /// e.g.) sh, /opt/homebrew/bin/zsh
      #[clap(short = 'S', long, value_name = "COMMAND", default_value = "sh")]
      pub shell: String,
  
      /// Use shell built-in time.
      #[clap(long)]
      pub use_builtin: bool,
  
      /// The commands to benchmark.
      ///
      /// If multiple commands are specified, each is executed and compared.
      /// One command is specified with "--" delimiters (recommended) or quotation.
      /// However, in the case of command-only quotation marks,
      /// the subsequent ones are considered to be the arguments of the command.
      ///
      /// e.g.) mntime command1 --flag arg -- command2 -- 'command3 -f -- args' command4 -o "output files"
      #[clap(value_parser, required = true)]
      commands: Vec<String>,
  }
  

• Clone: Cloneトレイトを実装し、clone()、clone_from()ができるようになる。

• Copy: デフォルトのムーブセマンティクスではなく、コピーセマンティクスとして扱うよう指示する。実装がないマーカートレイトです。（i32や&strなど基本的な型はコピーセマンティクスです。）

• Debug: Debugトレイトを実装し、{:?}や{:#?}のプレースホルダが使えるようになる。

  #[derive(Debug)]
  struct MyStruct {
      foo: i32,
  }
  fn main() {
      let s = MyStruct { foo: 1 };
      println!("{:?}", s);
      //=>
      // MyStruct { foo: 1 }
  
      println!("{:#?}", s);
      //=>
      // MyStruct {
      //     foo: 1,
      // }
  }
  

  ちなみに{}だけのプレースホルダはstd::fmt::Displayトレイトを実装して、fmt()を使えるようにしておく必要がある。

• Default: Defaultトレイトを実装し、default()が使えるようになる。enumにつける場合は、#[default]アトリビュートでデフォルト値を指定する必要があります。

  #[derive(Default)]
  enum Kind {
      #[default]
      A,
      B,
      C
  }
  

• Eq: PartialEqが比較関数を実装し、Eqはすべての値の組み合わせがPartialEqを満たすことを示すマーカートレイトです。浮動小数はNANが比較できないので、Eqがつきません。

• Hash: Hashトレイトを実装し、hash()、hash_slice()が使えるようになる。各フィールドのhashの組み合わせて作られる。

• PartialEq: PartialEqトレイトを実装し、eq()、ne()ができるようになる。

• strum::AsRefStr: enumを拡張してくれる便利マクロ集strumの１機能で、as_ref()で文字列へ変換できるようになる。

• strum::EnumIter: enumを拡張してくれる便利マクロ集strumの１機能で、iter()で列挙値をイテレーターで回せるようになる。

  use strum::IntoEnumIterator as _;
  #[derive(strum::AsRefStr, strum::EnumIter)]
  enum Color {
      Red,
      Green { range: usize },
      Blue(usize),
      Yellow,
  }
  fn main() {
      for color in Color::iter() {
          println!("{}", color.as_ref());
          //=>
          // Red
          // Green
          // Blue
          // Yellow
      }
  }
  

• thiserror::Error: エラーメッセージの実装を楽にしてくれるライブラリthiserrorの定義です。

  #[derive(thiserror::Error)]
  enum CmdError {
      #[error("Execution command is not finished yet. This is a bug in the source code.")]
      NotFinished,
      #[error("Could not parse the output of the `{0}` command. This is a source code issue, please provide the developer with the output of the `{0}` command.")]
      ParseError(&'static str),
  }
  

ジェネリック型

C++でいうtemplate（テンプレート）はRustではGeneric（ジェネリック）で代用します。似たような処理を同じに扱います。

// Tがジェネリック型
fn func<T>(a: T, b: T) -> T
where // Tの満たすべき条件
    T: std::ops::Add<Output=T> // TはAddトレイトを実装ていて、加算ができ結果はTとなる
{
    a + b
}
// whereなしで書くこともできる。
fn func2<T: std::ops::Add<Output=T>>(a: T, b: T) -> T {
    a + b
}
fn main() {
    let x = func(1, 2); // i32
    let y = func(1.0, 2.0); // f64
    let z = func2(1u32, 2u32); // u32
}

Box型

Rustは基本的に変数はスタック領域に保存されます。Boxを使うと変数をヒープ領域に保存されます。
スタックはビルド時にサイズを指定しスレッドごとに持っています。しくみが単純だしメモリアドレスが集約しているので速いです。関数のたびにベース位置が上下し、使いすぎるとスタックオーバーフローになってメモリ破壊が起きてしまうとたいへんです。
また、スタックは関数内での使用量がビルド時にわかっている必要があるので、動的な型をもつことができません。
ヒープはプログラム実行中に動的にOSからメモリを要求するので、大きなサイズも問題ありません（もちろん使用量が多すぎると確保失敗してエラーになります）。こちらはスタックに比べると複雑だしメモリ空間が広いので、遅くなっています。とはいえ最近のCPUはキャッシュが効くので無茶な使い方しなければ十分早いです。

Boxもジェネリックのひとつです。

struct MyLarge {} // サイズの大きい構造体と思ってください。
impl MyLarge {
    fn func(&self){
        println!("MyLarge");
    }
    fn func_mut(&mut self) -> &mut Self {
        println!("mut MyLarge");
        self
    }
}
fn main() {
    let x = Box::<MyLarge>::new(MyLarge{}); // 大きいものの確保
    let mut y = x; // ポインターの差し替えだけなので、大きいものでも早い
    y.func(); // 通常の型と同じように使える
    y.func_mut();
    let arr = ["a", "b", "c"];
    puts(Box::new(arr));
}
// 引数の配列がビルド時にサイズ不明のため、Boxで包む
fn puts(arr: Box<[&str]>) {
    for s in arr.iter() {
        print!("{},", s);
    }
}

Boxを使うとポリモフィズムが実現できます。

#[derive(Debug)]
struct MyPoint {
    x: i32,
    y: i32,
}
// 処理を切り替えられるように、トレイトを宣言する
trait PrintTrait {
    fn print(&self, p: MyPoint);
}
// 処理１
struct DbgPrint;
impl PrintTrait for DbgPrint {
    fn print(&self, p: MyPoint) {
        println!("{:?}", p); // デバッグ出力
    }
}
// 処理２
struct PrettyPrint;
impl PrintTrait for PrettyPrint {
    fn print(&self, p: MyPoint) {
        println!("{:#?}", p); // デバッグプリティ出力
    }
}
// トレイトはビルド時にサイズがわからないのでBox<〜>で囲む
// 2015エディションからはトレイトの使用と分かるようにdynキーワードが必要
fn my_print(f: Box<dyn PrintTrait>, p: MyPoint) {
    f.print(p); // トレイトの関数呼び出しをすると、引数で受け取った実装の処理が行われる
}
fn main() {
    let p = MyPoint{x:1,y:2};
    // ここを変えると処理を変えられる。
    let f: Box<dyn PrintTrait> = Box::new(DbgPrint);
    //let f = Box::new(PrettyPrint); // ここでは正しく型推論できるので省略可
    my_print(f, p);
}
//=>
// MyPoint { x: 1, y: 2 }

型エイリアス

Rustではtype エイリアス名 = 型名;とすると別名を付けることができます。

type Point = (u32, u32);
fn func(x: Point) {
}
fn main() {
    let p: Point = (1, 2); // エイリアス名が使えるが、実際は元の型
    func(p);
    func((3, 4)); // 型エイリアス元のを直接使える
}

void

C++でいうvoidはRustだと()となります。紛らわしいですがOk(())のように２重括弧の形（OK()列挙子に()何も入れないを表す）になることもあります。

関数・クロージャ・マクロ

通常関数

ここまでも使っているfnキーワードで関数が定義できます。RustではC++の引数の型を変えるオーバーロードはできません。

fn ret_string(x: i32) -> String {
    return format!("{}", x); // 返り値はreturnで返せる
}
// ビルドエラー。引数の型が違うオーバーロードはできない
fn ret_string(x: f64) -> String {
    format!("{}", x) // 最後の行でセミコロンがなければ、それが返り値となる
}

この場合はジェネリック型を使います。

trait IntOrFloat{}
impl IntOrFloat for i32{}
impl IntOrFloat for f64{}
fn ret_string<T>(x: T) -> String
where
    T: IntOrFloat + std::fmt::Display // +で複数の条件をANDできる（ORはなさそう？）
{
    format!("{}", x)
}
fn main() {
    let x = ret_string(1);
    let y = ret_string(1.0);
    let z = ret_string(1u32); // ビルドエラー。u32は受け取れない
}

クロージャ

無名関数とかラムダ式とか呼ばれるものはRustだとクロージャとなります。|args|{exprs}の構文です。

fn exec
    <F: FnOnce(i32, i32) -> i32> // １回呼び出すi32を２つ受け取り、i32を返すクロージャ
    (f: F) -> String // このexec関数自体はクロージャを受け取り、Stringを返す関数
{
    let x = f(2, 3);
    format!("{x}")
}
fn main() {
    let x = "hoge".to_string();
    let y =exec(|a, b| {
        println!("in:{}={},{}", x, a, b);
        a + b
    });
    println!("out:{}={}", x, y);
//=>
// in:hoge=2,3
// out:hoge=5
}

move || {}にすると、クロージャ内でキャプチャする変数の所有権が移動します。

fn main() {
    let x = "hoge".to_string();
    let y =exec(move |y| {
        println!("{}={}", x, y);
        y
    });
    println!("{}={}", x, y); // ビルドエラー。xがmoveされている
}

{〜}の波括弧は式１つなら省略ができます。

fn main() {
    let x = "hoge".to_string();
    let y =exec(|y| y);
    println!("{}={}", x, y);
}

FnOnceのトレイトはほかにFnとFnMutが標準で用意されています。

fn exec_fn<F: Fn()>(f: F) {
    f();
    f();
}
fn exec_fn_mut<F: FnMut()>(mut f: F) {
    f();
    f();
}
fn exec_fn_once<F: FnOnce()>(f: F) {
    f();
    //f(); // ２回目は呼び出せない
}
fn main() {
    let mut x = "hoge".to_string();
    exec_fn(|| {
        //x.insert(0, '#'); // mutableキャプチャーはできない
        println!("{}", x)
    });
    exec_fn_mut(|| {
        x.insert(0, '>');
        println!("{}", x)
    });
    exec_fn_once(|| {
        x.insert(0, '\t');
        println!("{}", x)
    });
//=>
// hoge
// hoge
// >hoge
// >>hoge
//         >>hoge
}

• Fn: 何度でも呼び出せる純粋関数。mutableキャプチャはできない。一番制限がきつい。
• FnMut: 何度でも呼び出せる副作用のある関数。mutableキャプチャできる。所有権の移動は制限される。
• FnOnce: １度だけ呼び出せる副作用のある関数。mutableキャプチャできる。制限がゆるい。

宣言的マクロ

macro_rules!でマクロを宣言します。呼び出しは!()、![]、!{}のどれかが使えます。関数的なのは!()。配列的なのは![]。構造的なのは!{}。とすることで混乱を少なくします。

macro_rules! abs {
    ($x:expr) => {
        if 0 <= $x {
            $x
        } else {
            -$x
        }
    }
}
fn main() {
    let x = abs!(-1);
    let y = abs![2*2];
    let z = abs!{-3*3};
    println!("{},{},{}", x, y, z);
//=>
// 1,4,9
}

cargo expandで見るとマクロ呼び出し部分は次のようになっています。

    let x = if 0 <= -1 { -1 } else { --1 };
    let y = if 0 <= 2 * 2 { 2 * 2 } else { -(2 * 2) };
    let z = if 0 <= -3 * 3 { -3 * 3 } else { -(-3 * 3) };

C++と違って、マクロの引数は構文木で１塊として扱われます。そのため、四則演算で優先順位が変わっておかしくなるということがありません。

以下は引数で処理を分けたり、可変個の引数を受け取る例です。

macro_rules! max {
    ($x:ty) => { // 引数１つだけのバージョン（expr式ではなくty型を受け取る）
        <$x>::MAX
    };
    ($x:expr,$( $y:expr), *) => { // ２個目の$yが１つ以上の引数
        {
            let mut max = $x;
            $( // 可変引数をループで回す
                max = if max < $y {
                    $y
                } else {
                    max
                };
            )*
            max
        }
    }
}
fn main() {
    let x = max!(-1, 3, 0, 9, -9);
    println!("{}", );
//=>
// 9
}

マクロの引数タイプはexpr、ty、以外にもblockやidentなどいろいろあります。

ちなみにassert!()やassert_eq!()はマクロですが、C++と違ってリリースビルドでも有効です。リリースビルドで無効になるdebug_assert!()や'debug_assert_eq!()が用意されています。また、debugと付いていればリリースビルドで無効になるわけではなく、Debugトレイトやdbg!()なんかもリリースビルドでも有効です。

手続き的マクロ

#[derive(マクロ名)]とか[マクロ名]で修飾するのもマクロの１種で手続きマクロと呼ばれるようです。
自分で定義できますが、複雑なのでここでは説明省略します。私も理解してないので、必要になったらまた本を読み直します。

• 実践Rustプログラミング入門

https://www.amazon.co.jp/dp/4798061700/

制御フロー

分岐

Rustの分岐にはifを利用します。C++と違って式なので値を返せるので３項演算子にも使用します。

fn main() {
    let x = 1;
    let y = if x == 0 {
        100 // 式として値を返す場合は、最後のセミコロンはなし
    } else if x == 1 {
        99 // 他の分岐と同じ型を返す
    } else {
        100/x // 他の分岐と同じ型を返す
    };
}

また、if letで変数を束縛できます。

// Option<T>もどき
enum OptInt {
    Some(i32),
    None,
}
fn main() {
    let x = OptInt::Some(1); // Option<T>ならSome(1)だけでいい
    let y = OptInt::None;
    let z = &x;
    // Someだったらvalに値をバインドする
    if let OptInt::Some(val) = z { // Option<T>ならSome(val)だけでいい
        println!("{}", val); //=> 1
    } else {
        // Noneの場合
    }
}

パターンマッチング

C++でいうところのswitchにあたるのが、Rustではmatchです。

enum Color {
    Red,
    Green { range: usize },
    Blue(usize),
    Yellow,
}
fn main() {
    let x = Color::Blue(0);
    x
    match x {
        Color::Red => {}
        Color::Green{range:_} => {} // Greenで値はなんでもいい(`_`)
        Color::Blue(0) => {println!("OK");} // Blueで値が0なら
        // Blueで値はなんでもいい(先に処理される0以外)。値はvalにバインドされる
        Color::Blue(val) => {println!("{}", val);}
        _ => {} // その他、C++ switchのdefault:
    }
}

matchはすべての分岐をカバーする必要があります。（本当なら上記コードでは_ =>は使わない方が、enum要素追加時のミスが減る）
if letのようにパターンマッチした場合、値を変数にバインドできます。

繰り返し

Rustの繰り返しはloopを使います。

fn hoge() -> bool {
    return false;
}
fn fuga() -> bool {
    return true;
}
fn main() {
    loop {
        if hoge() {
            continue;
        }
        if fuga() {
            break;
        }
    }
}

if同様にloopも値を返すことができます。その場合break valのように書けます。

条件付き繰り返し

while条件つきループもあります。

fn main() {
    while(true) {
        break;
    }
}

イテレータループ

C#でいうforeachが、Rustではforになります。

fn main() {
    let x = vec![1, 2, 3];
    'l1: for i in x {
        while(true) {
            if (i == 0) {
                break 'l1;
            }
        }
    }
}

loop、while、forともにラベルを付けられ（上記例だと'l1:）、breakでラベルを指定すると一気に外側のループも抜けられます。

コレクション操作

制御フローとは違いますが、イテレータループの代わりにiter()でイテレータにして各種操作関数が使えます。

fn main() {
    let x = vec![9, 1, 8, 2];
    // 最小値取得
    println!("{}", x.iter().min().unwrap()); //=> 1
    // 加算合計取得
    println!("{}", x.iter().sum::<i32>()); //=> 20
    // 5未満のリストに変換
    println!("{:?}", x.iter().filter(|&x| *x < 5)
                             .collect::<Vec<_>>()); //=> [1, 2]
    // 畳み込みで乗算合計取得
    println!("{}", x.iter().fold(1, |s, x| s * x)); //=> 144
    // チェーン呼び出しもできます。
    println!("{}", (1..) // 無限リストから
        .filter(|x| 1 == x % 2) // 奇数だけに絞って
        .nth(3) // オフセット3（４個目）を取り出す
        .unwrap()); //=> 7
}

イテレータの取り出し方で使う関数が違っています。

• iter(): &Tとリスト内の値に対する参照としてイテレータを回す。
• iter_mut(): '&mut T'とリスト内の値に対するmutableな参照としてイテレータを回す。
• into_iter(): Tもしくはmut Tとmoved valueとしてイテレータを回す。元のリストは所有権がなくなるので、以降では使えなくなります。

エラー処理

Result

Rustには例外処理がないのでエラーは戻り値で表します。そのための型Result<T, E>型が用意されていて、Ok(_)で正常値を、Err(_)でエラー情報を取得できます。?を使うと、Ok(_)なら継続、Err(_)ならreturn Err(_)を短縮してかけます。
ちなみにOption<_>に?を使うと、Some(_)なら継続、Noneならreturn Noneを短縮してかけます。

fn div(x: i32) -> Result<i32, &'static str> {
    if x != 0 {
        Ok(100 / x)
    } else {
        Err("zero divide!")
    }
}
fn hoge(x: i32) -> Result<i32, &'static str> {
    let y = div(x)?;
    // ?は下記のシンタックスシュガー
    // let y = match div(x) {
    //     Ok(t) => t,
    //     Err(e) => return Err(e),
    // };
    println!("OK");
    Ok(y)
}
fn main() {
    let x = div(5); // Result<>型
    let y = x.unwrap(); // Result<>からOkのi32を取り出す。ただしErrならパニックが発生
}

パニック

エラーを処理せずにその場でスレッドを終了させるpanic!()もあります。ResultやOptionで正常値が入っているのが分かっていれば、unwap()が使えます。もし異常値が入っていればpanic!()でパニックが発生します。

fn div(x: i32) -> Result<i32, &'static str> {
    if x == 0 {
        Err("zero divide!")
    } else {
        Ok(100 / x)
    }
}
fn main() {
    let x = div(5); // Result<>型
    let y = x.unwrap(); // Result<>からOkのi32を取り出す。ただしErrならpanic!()が発生
}

パニックでも処理を継続したい場合は、catch_unwind()を使うと、Result<Ret, E>型にラップしてくれます。ただしパニック発生時の出力はされるのでエラー処理には使えません。Cライブラリ呼び出しのFFI境界を超える場合に安全のため使う感じのようです。

fn main() {
    // 結果をResult<Ret, E>型にラップして返す
    let x = std::panic::catch_unwind(|| {
        assert!(false);
    });
    if let Err(payload) = x { // パニックが発生すれば、Err(_)にパニック情報が入ってる
        eprintln!("panicked");
        std::panic::resume_unwind(payload); // パニックを再発行
    }
}

通常はパニック時に巻き戻りが発生し、Dropトレイトが呼ばれるなどの後始末します。ただし、パニック中のdrop()中でパニックが発生するなどの２重パニックは即時強制終了されたり、ビルドオプションでpanic="abort"が指定されるとパニックハンドラだけ実行されます。abortモードにすると、巻き戻りのための余分なオーバーヘッドがなくなるので組込みなど極限まで削りたいときに使うようです。
そのパニックハンドラはset_hookで置き換えることが可能です。

fn initialize_cli() {
    // 既存のパニックハンドラを取得
    let default_panic_hook = std::panic::take_hook();
    // パニックハンドラを上書き
    std::panic::set_hook(Box::new(move |panic_info| {
        finalize_cli();
        // 保存したパニックハンドラを呼び出す
        default_panic_hook(panic_info);
    }));
}

実装補助用のマクロでパニックを意図的に発生させるものもあります。

• todo!: 最終的には実装するが、今はまだ未対応のときに使用する。
• unimplemented!: 実装する予定がない（呼ばれることを想定していない）ときに使用する。
• unreachable!: 処理が到達しないとき（分岐漏れ指摘の対応時）などに使用する。

エラー処理が楽になるライブラリ

エラー処理を楽に書けるようにする外部クレートがあります。Anyhowとthiserrorです。どちらも同じ方が作られていて、組み合わせて使用可能です。

use anyhow::Context as _;
// thiserrorで、エラーメッセージを簡単に定義できる
#[derive(thiserror::Error, Debug)]
enum MyErr {
    #[error("This is test error")]
    Test,
}
// anyhowでResultの指定が楽になる。
fn hoge(x: i32) -> anyhow::Result<Vec<u8>> {
    if x == 0 {
        Err(MyErr::Test.into())
    } else {
        let path = format!("path/{}.txt", x);
        let content = std::fs::read(path.as_str())
            // anyhowのcontextでエラーメッセージに付加情報を与えられる
            .with_context(|| format!("Failed to read str from {}", path))?;
        Ok(content)
    }
}
fn main() -> anyhow::Result<()> {
    hoge(0)?;
    //=>
    // Error: This is test error
    hoge(1)?;
    //=>
    // Error: Failed to read str from path/1.txt

    // Caused by:
    //     No such file or directory (os error 2)

    Ok(())
}

マルチスレッド

Rustにはマルチスレッドに必要な機能が用意されています。標準では最低限のものだけですが、外部クレートを使えばより便利になったりするようです。
ここでは単純なスレッドについて説明します(説明しませんが、Rustにはasync、awaitもあります)。

Cell

Cellは変更可能メモリ配置で、C++でいうmutable宣言のようにimmutableな構造体の中でも変更可能なフィールドが作れます。

struct SomeStruct {
    regular_field: u8,
    special_field: std::cell::Cell<u8>,
}
fn main() {
    let my_struct = SomeStruct {
        regular_field: 1,
        special_field: std::cell::Cell::new(1),
    };
    let new_value = 2;

    // my_struct.regular_field = new_value; // immutableなのでエラー

    my_struct.special_field.set(new_value); // immutableなのに、変更可
    assert_eq!(my_struct.special_field.get(), new_value);
}

Cellが保持する型によって使えるメソッドが変わります。

• get()はCopyトレイトが必要です。値をコピーして返します。
• take()はDefaultトレイトが必要です。値をdefault()と入れ替え、元の値を返します。

RefCell

RefCellは保持する値への参照が取れるCellの上位版です。

struct SomeStruct {
    cell: std::cell::Cell<u8>,
    refcell: std::cell::RefCell<u8>,
}
fn square(x: &mut u8) {
    return *x *= *x;
}
fn main() {
    let my_struct = SomeStruct {
        cell: std::cell::Cell::new(3),
        refcell: std::cell::RefCell::new(3),
    };
    square(&mut my_struct.refcell.borrow_mut());
    assert_eq!(*my_struct.refcell.borrow(), 9);
    // 参照を手段がなく、コピーになる。ただし、let mutされていると、get_mut()で参照が取れる
    square(&mut my_struct.cell.get());
    //assert_eq!(my_struct.cell.get(), 9); // 実行エラー
}

CellとRefCellが別れているのは、借用チェッカーが影響しています。RefCellは動的な借用チェッカーとなり、ビルド時ではなく実行時に借用チェックが走ります。そのため、オーバーヘッドが存在するので、通常はCellがいいでしょう。

// Cell利用版はビルドエラーが出る
fn main() {
    let mut x = std::cell::Cell::new(1);
    let y = x.get_mut(); // ここで１回目の変更可能な借用している
    x.set(2); // ここで２回目の変更可能な借用になりビルドエラー
    println!("{},{}", x.get(), *y);
}

// RefCell利用版はビルドが通る。しかし実行時にパニックが発生する。
fn main() {
    let x = std::cell::RefCell::new(1);
    let y = x.borrow_mut(); // ここで１回目の変更可能な借用している
    *x.borrow_mut() = 2; // ここで２回目の変更可能な借用になるがビルドエラーは発生しない
    println!("{},{}", *x.borrow(), *y);
}
/*=>
thread 'main' panicked at 'already borrowed: BorrowMutError', src/main.rs:5:8
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
*/

Rc/Arc

RustのRcとArcは参照カウンター方式で値を保持します。違いは、Arcのカウンター操作がスレッドセーフになっている点です。ArcはAtomically Reference Counterの略です。

fn main() {
    let a: std::rc::Weak<i32>;
    let b: std::rc::Rc<i32>;
    let x: std::rc::Weak<i32>;
    {
        let c = std::rc::Rc::new(1); // カウンター = 1
        a = std::rc::Rc::downgrade(&c); // Weakはカウンター操作しない
        if let Some(d) = a.upgrade() {
            println!("a={d}");
        }
        b = c.clone(); // カウンターアップ = 2
        // cが破棄され、カウンターダウン = 1
    }
    {
        let y = std::rc::Rc::new(2); // カウンター = 1
        x = std::rc::Rc::downgrade(&y);
        if let Some(z) = x.upgrade() {
            println!("x={z}");
        }
        // yが破棄され、カウンターダウン = 0
    }
    if let Some(d) = a.upgrade() { // カウンターが1なのでtrue
        println!("a={d}");
    }
    if let Some(z) = x.upgrade() { // カウンターが0なのでfalse
        println!("{z}");
    }
}
/*=>
a=1
x=2
a=1
*/

Atomic

ArcがAtomicallyというのは、カウンター操作がこのAtomic型を利用しているからです。通常の型だと、値操作が複数のCPU命令になることがあり、マルチスレッド時に挙動が予測不可能になることがあります。ロックをすれば安全ですが、そこまでは必要ない小さな操作を１つのCPU命令（操作中にほかから割り込まれない）で行うのがアトミックな操作です。

fn main() {
    let mut x = std::sync::atomic::AtomicI32::new(1);
    // スレッド競合時の順番保証の方式（きちんと覚えてません、必要になったら調べてる）
    let order = std::sync::atomic::Ordering::Relaxed;
    assert_eq!(x.load(order), 1);
    x.store(2, order);
    assert_eq!(*x.get_mut(), 2);
    x.compare_exchange(2, 3, order, order); // 今の値が2だったら、3を代入する
    assert_eq!(*x.get_mut(), 3);
    x.fetch_add(1, order); // increment
    assert_eq!(*x.get_mut(), 4);
}

標準で用意されている型は公式ドキュメントに書かれています。

thread_local

Rustのスレッドローカルストレージはthread_local!マクロで定義可能です。

fn main() {
    thread_local! {
        // Cellはまだunstableなようなので、RefCellを使用
        pub static FOO: std::cell::RefCell<i32>  = std::cell::RefCell::new(1);
        static BAR: std::cell::RefCell<i32>  = std::cell::RefCell::new(2);
    }
    FOO.with(|x| {
        assert_eq!(*x.borrow(), 1);
    });
    BAR.with(|x|{
        *x.borrow_mut() = 3;
        assert_eq!(*x.borrow(), 3);
    });
}

実際の型はLocalKey<〜>となります。

thread

Rustでのスレッド生成はstd::thread::spawn()で行います。

use std::borrow::Borrow;

fn func() {
    thread_local! {
        static BAR: std::cell::RefCell<i32>  = std::cell::RefCell::new(2);
    }
    BAR.with(|x|{
        println!("{}", *x.borrow());
        *x.borrow_mut() += 1;
        println!("{}", *x.borrow());
    });
}
fn main() {
    let t1 = std::thread::spawn(|| {
        func();
    });
    let t2 = std::thread::spawn(||{
        func();
    });
    t1.join();
    t2.join();
}
//=>
// 2
// 3
// 2
// 3

スレッドのスコープは通常、プログラム終了までになってしまいます。そのため借用チェッカーでビルドエラーになることがあります。その場合はthread::scope()でスレッドのスコープを明示します。

fn main() {
    let mut a = vec![1, 2, 3];
    let mut x = 0;
    std::thread::scope(|s| {
        s.spawn(|| {
            println!("hello from the first scoped thread");
            // We can borrow `a` here.
            dbg!(&a);
        });
        s.spawn(|| {
            println!("hello from the second scoped thread");
            // We can even mutably borrow `x` here,
            // because no other threads are using it.
            x += a[0] + a[2];
        });
        println!("hello from the main thread");
    });
    // After the scope, we can modify and access our variables again:
    a.push(4);
    assert_eq!(x, a.len());
}

Mutex

Rustでロックを扱うにはMutexを使います。通常Arc<Mutex<>>の形で使い、各スレッドで保持できるようにします。

use std::borrow::{BorrowMut as _, Borrow as _};
fn main() {
    use std::sync::Arc;
    let data = Arc::new(std::sync::Mutex::new("".to_string()));
    let mut handles = Vec::<std::thread::JoinHandle<()>>::new();
    for i in 0..6 {
        let data = Arc::clone(&data); // Arcの機能で参照カウンターを増やしてクローン
        handles.push(
            std::thread::spawn(move || { // ムーブクロージャ
                let mut lock = data.lock().unwrap(); // ロック取得。MutexGuard<>型
                lock.borrow_mut().push((b'a' + i) as char)
            })
        )
    }
    for h in handles {
        h.join().unwrap();
    }
    println!("{}", data.lock().unwrap().borrow()); //=> abcdefとかabcefdとか
}

ロック中にパニックが発生すると、Poisoning（中毒）状態になります。

channels

Rustにはスレッド間でデータのやりとりに使えるチャンネルの機能もあります。標準では多送信->単受信のMulti-Producer, Single-Consumerだけあります。
チャンネルはFIFOで、バッファに貯められます。そのため、先に送信しても正しく受信できます。

fn main() {
    let mut data = "".to_string();
    let (tx, rx) = std::sync::mpsc::channel(); // 送信用と受信用の対になるチャンネル
    let mut handles = Vec::<std::thread::JoinHandle<()>>::new();
    for i in 0..6 {
        let tx = tx.clone(); // 送信用チャンネルを複製
        handles.push(
            std::thread::spawn(move || { // ムーブクロージャ
                tx.send((b'a' + i) as char); // 送信
            })
        )
    }
    let timeout = std::time::Duration::from_millis(100);
    loop {
        match rx.recv_timeout(timeout) { // 受信
            Ok(ch) => {
                data.push(ch);
            }
            Err(std::sync::mpsc::RecvTimeoutError::Timeout) => { // タイムアウト時
                handles.retain(|h| { // 未終了スレッドだけ残す（終了したものは削除）
                    !h.is_finished()
                });
                if handles.is_empty() {
                    break; // 全スレッド終了
                }
            }
            Err(_) => {
                panic!("ERROR");
            }
        }
    }
    println!("{}", data); //=> abcdefとかabcefdとか
}

チャンネルは送信側がすべて閉じられると、受信がエラーになります。これを利用して、スレッドの終了の判定をシンプルにできます。

fn main() {
    let mut data = "".to_string();
    let (tx, rx) = std::sync::mpsc::channel();
    for i in 0..6 {
        let tx = tx.clone();
        std::thread::spawn(move || {
            tx.send((b'a' + i) as char);
            // スレッド終了時に送信チャンネルが１つ閉じられる
        });
    }
    drop(tx); // オリジナルの送信チャンネルが閉じられる
    while let Ok(ch) = rx.recv() { // すべての送信チャンネルが閉じられたらErrになる
        data.push(ch);
    }
    println!("{}", data); //=> abcdefとかabcefdとか
}

Send / Sync

マルチスレッドに関係するSend/Syncマーカートレイトというものがあります。これらはコンパイラが自動で決定して付与してくれます。
Sendがあるものだけ、スレッドを超えて転送でき、Syncがあるものだけ、スレッド間で参照の共有ができます。

use rand::distributions::uniform::SampleBorrow;

fn main() {
    let rc = std::rc::Rc::new(1);
    let arc = std::sync::Arc::new(2);
    for i in 0..6 {
        let rc = rc.clone();
        let arc = arc.clone();
        std::thread::spawn(move || {
            println!("{}", *rc); // ビルドエラー。
            println!("{}", arc.borrow());
        });
    }
}

そのほかの周辺機能

Doc comments

C++のDoxygenのようなドキュメントコメントがRustでは標準で用意されています。しかもcrates.ioへ公開すると、自動生成されたドキュメントファイルをdocs.rsで見ることができます。

//! このファイルの概要
//!
//! このファイルの詳細な説明
//! ２行以上書くことができます。

/// 構造体の概要
///
/// 構造体の詳細な説明
///
/// **Wow** Markdown記法も使える（改行は入れられず、空行の段落分けを使う）
struct My {
    /// フィールドの概要
    ///
    /// フィールドの詳細な説明
    x: i32,
}

/// 関数の概要
///
/// # Examples:
/// ```
/// # use std::io; // # 始まりはドキュメントに出力されないが、テスト時のみ有効
/// assert!(1, 2)
/// ```
/// コード例も書けます。
/// lib.rsがあれば、ライブラリビルド後にテストされる
fn func() {
}

//!でインナーラインドキュメント（先行ワードの記載）を開始、///でアウターラインドキュメント（後続ワードの説明）を開始します。複数行コメントバージョンもあり/*! 〜 */でインナーブロックドキュメント、/** 〜 */でアウターブロックドキュメントとなります。よく見るのは、ファイルのドキュメントコメントは//!で始めます。それ以外のドキュメントコメントは///で始めます。
ドキュメントコメントにはマークダウン記法をつかうことができ、コードブロックでテストコードを書けます。この記事書くときに気付いたのですが、ドキュメントコメント中のテストはライブラリターゲットのみ有効で、バイナリターゲットの場合lib.rsファイルを用意してライブラリとしてもビルドできるようにしないといけないようです。（この記事書いてよかった。）

main.rsとlib.rsを両方使う場合、混同しないようにCargo.tomlの[lib]セクションで名前を変えるのがいいでしょう。

cargo docでtarget/docフォルダにドキュメントファイルが生成されます。cargo doc --openとすると、生成したファイルをブラウザで開いてくれます（手元のSafariでは正しく表示できないので、Chromeで開き直してます）。

ちなみにRustの複数行コメントはネストが可能です。

/* 複数行コメント
/* 入れ子コメント開始 C++ならここでコメントが終了してしまう */
しかしRustはネストできるので、この行もコメントです。
*/
fn main()

test

Rustにはテスト環境も標準で用意されています。

/** Calc double number

# Examples:
```
# use test_rs::*; // テストはライブラリと別にビルドされるので、フルパス指定が必要
let x = hoge(1);
assert_eq!(2, x);
let x = hoge(9);
assert_eq!(18, x);
```
 */
pub fn hoge(x: i32) -> i32 {
    x * 2
}
#[cfg(test)] // testビルド時のみ有効になる
mod test {
    use super::*; // 慣例
    #[test] // これがあるとテスト対象になる
    fn hoge_zero() {
        assert_eq!(0, hoge(0));
    }
    #[test]
    fn hoge_negative() {
        assert_eq!(-2, hoge(-1));
        assert_eq!(-18, hoge(-9));
    }
}

まずはドキュメンテーションテストについてです。ドキュメンテーションコメント中のコードブロックはテスト対象となります（ただしライブラリターゲットのみでバイナリターゲットはテストされない）。これはライブラリをビルドして、それに依存する一時的なバイナリがビルドされ実行されます。各コードブロックが別々にfn main() { コードブロック }とメイン関数で囲われたコードとして実行されます。
そのため、テストできるのはpubのついた公開されたものだけで、呼び出しにはライブラリのクレート名からのパスで書く必要があります。#始まりはドキュメントに載らないので、ビルドでは必要だが情報としては不要な行に使うとすっきりしたドキュメントになります。
コードブロックの言語指定をRust以外（たとえば ```txtとか）にした場合はテスト対象外になります。無視するのを表す ```ignoreアトリビュートもあります。アトリビュートは ```hould_panicでテスト中パニックが発生するかチェック、 ```no_runでビルドのみでテストはしない、などほかにもあります。
詳細はDocumentation testsを参照ください。

次にユニットテストについてです。#[test]注釈をfnの前につけるとその関数はテスト関数として使用されます。こちらの場合は同じファイル（モジュール）なのでプライベートなものもテスト可能です。通常は子モジュールとしてmod test{ 〜 }で囲み、さらに#[cfg(test)]注釈をつけてテスト時のみ有効化します。また、testモジュール中は呼び出しパスを省略するためuse super::*;がよく使われます。

最後に統合テストについてです。srcフォルダと同じ階層でtestsフォルダを用意し、その中に.rsファイルを置くと、それぞれがテストバイナリとしてビルドされます。その中で#[test]注釈されたfnがテスト関数として実行されます。こちらはドキュメンテーションテストと同じく、別バイナリとしてビルドされるので公開のものしかテストできません。

fmt/lint

cargo fmtでソースコードが自動フォーマットされます。
cargo clippyでリンターが走ります。cargo clippy --fixとすると修正できるものは自動で修正されます。

まとめ

Rustは所有権（ライフタイムや借用含む）が理解できれば、サクサクかけてパフォーマンスもいいでしょう。きっと。
それまではコンパイラと共闘して、彼らのメッセージを受け取ってレベルアップしていきましょう。C++と比べたら格段に分かりやすく話しかけてくれてますよ。
そしてバグの少ない安全なプログラムを作って、よりよい世界になるのを願ってます。

「いいね」、「ツイート」、「バッジを贈る」、「コメント」大歓迎です！