Rust 100 Ex 🏃【3/37】 可変・ループ・オーバーフロー

前の記事

- [【0】 準備](https://qiita.com/namn1125/items/bd1b4cd028874189a3c1) ← 初回
- ...
- [【2】 if・パニック・演習](https://qiita.com/namn1125/items/13870965e8273bc87bce) ← 前回
- 【3】 可変・ループ・オーバーフロー ← 今回

<details><summary>全記事一覧</summary>

- [【0】 準備](https://qiita.com/namn1125/items/bd1b4cd028874189a3c1)
- [【1】 構文・整数・変数](https://qiita.com/namn1125/items/c776768baec89b8a0438)
- [【2】 if・パニック・演習](https://qiita.com/namn1125/items/13870965e8273bc87bce)
- [【3】 可変・ループ・オーバーフロー](https://qiita.com/namn1125/items/4f57f8aede2f5201016f)
- [【4】 キャスト・構造体 (たまにUFCS)](https://qiita.com/namn1125/items/227ed5bbedbb775c5d27)
- [【5】 バリデーション・モジュールの公開範囲 ～ → カプセル化！～](https://qiita.com/namn1125/items/46721cceccbfa9ec3c7a)
- [【6】 カプセル化の続きと所有権とセッター ～そして不変参照と可変参照！～](https://qiita.com/namn1125/items/442de7798d49f777384c)
- [【7】 スタック・ヒープと参照のサイズ ～メモリの話～](https://qiita.com/namn1125/items/780d80e4340f0e34dbf6)
- [【8】 デストラクタ(変数の終わり)・トレイト ～終わりと始まり～](https://qiita.com/namn1125/items/7247edde3b6bd0b85b25)
- [【9】 Orphan rule (孤児ルール)・演算子オーバーロード・derive ～Empowerment 💪 ～](https://qiita.com/namn1125/items/e565713b423301a80c76)
- [【10】 トレイト境界・文字列・Derefトレイト ～トレイトのアレコレ～](https://qiita.com/namn1125/items/9060faee2965f23e0e3d)
- [【11】 Sized トレイト・From トレイト・関連型 ～おもしろトレイトと関連型～](https://qiita.com/namn1125/items/b68990712d379a3d6a49)
- [【12】 Clone・Copy・Dropトレイト ～覚えるべき主要トレイトたち～](https://qiita.com/namn1125/items/c6f34945f331c7229746)
- [【13】 トレイトまとめ・列挙型・match式 ～最強のトレイトの次は、最強の列挙型～](https://qiita.com/namn1125/items/6b2cc31d6a47f9ffaff6)
- [【14】 フィールド付き列挙型とOption型 ～チョクワガタ～](https://qiita.com/namn1125/items/6fe69d1cab6c7936c698)
- [【15】 Result型 ～Rust流エラーハンドリング術～](https://qiita.com/namn1125/items/698aafaf22ec4bfd1bde)
- [【16】 Errorトレイトと外部クレート ～依存はCargo.tomlに全部お任せ！～](https://qiita.com/namn1125/items/9dae7b728fa0668e4102)
- [【17】 thiserror・TryFrom ～トレイトもResultも自由自在！～](https://qiita.com/namn1125/items/d67006a29b7ff5d6148c)
- [【18】 Errorのネスト・慣例的な書き方 ～Rustらしさの目醒め～](https://qiita.com/namn1125/items/705829027661a38e4a4f)
- [【19】 配列・動的配列 ～スタックが使われる配列と、ヒープに保存できる動的配列～](https://qiita.com/namn1125/items/9c49fd4c08f3e61896c7)
- [【20】 動的配列のリサイズ・イテレータ ～またまたトレイト登場！～](https://qiita.com/namn1125/items/6e4dede789c6de97f396)
- [【21】 イテレータ・ライフタイム ～ライフタイム注釈ようやく登場！～](https://qiita.com/namn1125/items/9a1224abf733f29a980a)
- [【22】 コンビネータ・RPIT ～ :dragon: 「 `Iterator` トレイトを実装してるやつ」～](https://qiita.com/namn1125/items/27fe20f2d60803c94357)
- [【23】 `impl Trait` ・スライス ～配列の欠片～](https://qiita.com/namn1125/items/7601d0268293ce7fcf28)
- [【24】 可変スライス・下書き構造体 ～構造体で状態表現～](https://qiita.com/namn1125/items/a9acc7dc2ca7c4c55cc3)
- [【25】 インデックス・可変インデックス ～インデックスもトレイト！～](https://qiita.com/namn1125/items/bd43375362af10ea8b42)
- [【26】 HashMap・順序・BTreeMap ～Rustの辞書型～](https://qiita.com/namn1125/items/a2806cded12fa719a1cb)
- [【27】 スレッド・'staticライフタイム ～並列処理に見るRustの恩恵～](https://qiita.com/namn1125/items/5a4a09172834063268b1)
- [【28】 リーク・スコープ付きスレッド ～ライフタイムに技あり！～](https://qiita.com/namn1125/items/34a0aacd4d40f9234aef)
- [【29】 チャネル・参照の内部可変性 ～Rustの虎の子、mpscと `Rc<RefCell<T>>`～](https://qiita.com/namn1125/items/861e72dbb4b837508948)
- [【30】 双方向通信・リファクタリング ～返信用封筒を入れよう！～](https://qiita.com/namn1125/items/46f03de967d0de46737e)
- [【31】 上限付きチャネル・PATCH機能 ～パンクしないように制御！～](https://qiita.com/namn1125/items/d7ae8a205ee969339401)
- [【32】 `Send`・排他的ロック(`Mutex`)・非対称排他的ロック(`RwLock`) ～真打 `Arc<Mutex<T>>` 登場～](https://qiita.com/namn1125/items/eee890dc8672e975e70c)
- [【33】 チャネルなしで実装・Syncの話 ～考察回です～](https://qiita.com/namn1125/items/cc8bee3871b727e564e3)
- [【34】 `async fn`・非同期タスク生成 ～Rustの非同期入門～](https://qiita.com/namn1125/items/9c32b730a283ad76c891)
- [【35】 非同期ランタイム・Futureトレイト ～非同期のお作法～](https://qiita.com/namn1125/items/c840d48f8f558613ec10)
- [【36】 ブロッキング・非同期用の実装・キャンセル ～ラストスパート！～](https://qiita.com/namn1125/items/39c139da3f1f26264353)
- [【37】 Axumでクラサバ！ ～最終回～](https://qiita.com/namn1125/items/bae492f823fbe60e9974)
- [【おまけ1】 Rustで勘違いしていたこと3選 🏄🌴 【100 Exercises To Learn Rust 🦀 完走記事 🏃】](https://qiita.com/namn1125/items/2a59f486cce30fd2b889)
- [【おまけ2】 【🙇 懺悔 🙇】Qiitanグッズ欲しさに1日に33記事投稿した話またはQiita CLIとcargo scriptを布教する的な何か](https://qiita.com/namn1125/items/8e552694b389c5b13b5e)
</details>

[100 Exercise To Learn Rust](https://rust-exercises.com/) 演習第3回になります！ループ構造2つと、[前々回](https://qiita.com/namn1125/items/c776768baec89b8a0438) に関連しているかもしれないオーバーフローの話になります！

今回の関連ページ

- [2.6. Loops: while](https://rust-exercises.com/02_basic_calculator/06_while)
- [2.7. Loops: for](https://rust-exercises.com/02_basic_calculator/07_for)
- [2.8. Overflow and underflow](https://rust-exercises.com/02_basic_calculator/08_overflow)

では行きましょう！

# [[02_basic_calculator/06_while](https://github.com/mainmatter/100-exercises-to-learn-rust/blob/main/exercises/02_basic_calculator/06_while/src/lib.rs)] while

- [2.6. Loops: while](https://rust-exercises.com/02_basic_calculator/06_while)

問題はこちらです。

```rust:lib.rs
// Rewrite the factorial function using a `while` loop.
pub fn factorial(n: u32) -> u32 {
    // The `todo!()` macro is a placeholder that the compiler
    // interprets as "I'll get back to this later", thus
    // suppressing type errors.
    // It panics at runtime.
    todo!()
}
```

<details><summary>テストを含めた全体</summary>

```rust:lib.rs
// Rewrite the factorial function using a `while` loop.
pub fn factorial(n: u32) -> u32 {
    // The `todo!()` macro is a placeholder that the compiler
    // interprets as "I'll get back to this later", thus
    // suppressing type errors.
    // It panics at runtime.
    todo!()
}

#[cfg(test)]
mod tests {
    use crate::factorial;

    #[test]
    fn first() {
        assert_eq!(factorial(0), 1);
    }

    #[test]
    fn second() {
        assert_eq!(factorial(1), 1);
    }

    #[test]
    fn third() {
        assert_eq!(factorial(2), 2);
    }

    #[test]
    fn fifth() {
        assert_eq!(factorial(5), 120);
    }
}
```
</details>

[前回](https://qiita.com/namn1125/items/13870965e8273bc87bce)、階乗を求めるコードを再帰で書きましたが、これをwhileループで書くという問題のようです。

`todo!` マクロはまだ未実装であることを示し、ここに到達するとコードがパニックするようになっています。多分いつかの回で取り扱うのでしょうが、この `todo!` マクロは「関数の返り値と同じ型の値を返した」ことにできる特殊な性質があるため、コンパイルエラーにならなかったりします。

ともかく、この部分を置き換えてwhileループにすれば良さそうです。

## 解説

```rust:lib.rs
pub fn factorial(n: u32) -> u32 {
    let mut res = 1;

    let mut i = 1;
    while i <= n {
        res *= i;
    
        i += 1;
    }

    res
}
```

... **めちゃくちゃfor文で書きたい** ...while文をこんな風に無理に使うことがないため、逆にテンパってしまいました...

この問題で新しく出てきている要素は2つあります。

- while文
- `mut` キーワード

この節でついでに「可変」を登場させているみたいですね。実際、こういうループ構造で良く使うキーワードだったりするので理にかなっています。

Rustではデフォルトですべての変数は **不変** です。そして意図的に仕組まない限り[^mutinimut]、この不変性は構造体から参照、配列まで至るところで保たれています。値が変わらないことはコードを読む人に安心感を与え、「この関数で可変参照渡しされてるんじゃなかろうか...」といった余計な詮索をする必要がない明確なコーディングを実現しています！

[^mutinimut]: 例えば[「可変参照」を内側に持つ構造体を不変として束縛する](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=2df7c0d72790feede86cf0f9082c298c)といったことをすれば例外的に可変要素を持つ不変な値を作ることはできます。できますがまず自分で書くことはないです。

しかし全てが不変だと不便な時があり、その代表が繰り返し変数です。そしてこういう可変な変数を用いたいときのために `mut` キーワードがあります。このキーワードを書くことで「この変数は副作用を受けて変化することがある」と読み手に常に明示的に伝えることができるのです！

話をwhileループの方に戻しましょう。(if式もそうでしたが)条件節をカッコで包んでいない以外は特に他言語との違いは無いんじゃないかと思います。if式と異なり、評価されたところで返す値が決まらないため式としての性質は持たないです(伏線)。

:::note
**i++はないの？**

インクリメント構文はありません。この辺が理由じゃないかなと思います → [Rustでは++すら許されない #C++ - Qiita](https://qiita.com/namn1125/items/0707955b410d3dd035e8)

そもそも `i++` は一つの構文で複数のことをやりすぎです。横着要素はあまり好まない(導入に慎重な)言語ゆえにわざと用意していないと考えられます。
:::

# [[02_basic_calculator/07_for](https://github.com/mainmatter/100-exercises-to-learn-rust/blob/main/exercises/02_basic_calculator/07_for/src/lib.rs)] for

- [2.7. Loops: for](https://rust-exercises.com/02_basic_calculator/07_for)

問題はこちらです。やっと `for` で書かせてもらえる...！

```rust:lib.rs
// Rewrite the factorial function using a `for` loop.
pub fn factorial(n: u32) -> u32 {
    todo!()
}
```

<details><summary>テストを含めた全体</summary>

```rust:lib.rs
// Rewrite the factorial function using a `for` loop.
pub fn factorial(n: u32) -> u32 {
    todo!()
}

#[cfg(test)]
mod tests {
    use crate::factorial;

    #[test]
    fn first() {
        assert_eq!(factorial(0), 1);
    }

    #[test]
    fn second() {
        assert_eq!(factorial(1), 1);
    }

    #[test]
    fn third() {
        assert_eq!(factorial(2), 2);
    }

    #[test]
    fn fifth() {
        assert_eq!(factorial(5), 120);
    }
}
```
</details>

こうして何問もお題として使えるって、階乗は優秀ですね...

## 解説

```rust:lib.rs
pub fn factorial(n: u32) -> u32 {
    let mut res = 1;
    for i in 1..=n {
        res *= i;
    }
    res
}
```

繰り返し変数のスコープをforループに閉じ込めることができており、whileループよりもスッキリしたコードになっています！`i` に `mut` が要らないお陰で、各ループ内では `i` が変化しないことが保証されていて非常に良いですね。

ただしまだ可変変数 `res` が残っていますね...これすらもイテレータ的な書き方( [`map`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.map) や [`reduce`](https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.reduce) を使う等)をすればなくすことができたりします。

後ほど登場するであろうその「イテレータ」に関係していますが、`1..=5` は `1, 2, 3, 4, 5` を生成する [`Range`](https://doc.rust-lang.org/std/ops/struct.Range.html) という型の値で、for文に特有の構文というわけでありません。for文はあくまでも `for 変数 in イテレータ {}` という構文であり、 `Range` 型等のイテレータから要素を一つずつ取り出して処理しています。

:::note
**loop式**

whileやforは値を返さないから式ではなかったのですが、一方でloop式は値を返すことが可能です(伏線回収)。

loop式は `loop {}` と書くのですが、これは `while true {}` 、すなわち無限ループを意味する専用構文です。

無限ループ専用ゆえに抜け出すには`break`が必須なため、`break`を使用することで値を返すことができる仕様となっています。

```rust:Rust
let mut i = 0;

let res = loop {
    if i == 10 {
        break i;
    }

    println!("{}", i);

    i += 1;
};

println!("{}", res);
```

`break i;`で、抜け出した時に式として`i`の中身を返しています！

...まぁ使用機会は少ないと思います。おもしろ構文だったので紹介してみました
:::

# [[02_basic_calculator/08_overflow](https://github.com/mainmatter/100-exercises-to-learn-rust/blob/main/exercises/02_basic_calculator/08_overflow/src/lib.rs)] オーバーフロー

- [2.8. Overflow and underflow](https://rust-exercises.com/02_basic_calculator/08_overflow)

問題はこちらです。

```rust:lib.rs
// Customize the `dev` profile to wrap around on overflow.
// Check Cargo's documentation to find out the right syntax:
// https://doc.rust-lang.org/cargo/reference/profiles.html
//
// For reasons that we'll explain later, the customization needs to be done in the `Cargo.toml`
// at the root of the repository, not in the `Cargo.toml` of the exercise.

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

#[cfg(test)]
mod tests {
    use crate::factorial;

    #[test]
    fn twentieth() {
        // 20! is 2432902008176640000, which is too large to fit in a u32
        // With the default dev profile, this will panic when you run `cargo test`
        // We want it to wrap around instead
        assert_eq!(factorial(20), 2_192_834_560);
        //                           ☝️
        // A large number literal using underscores to improve readability!
    }

    // ...省略...
}
```

<details><summary>省略なし</summary>

```rust:lib.rs
// Customize the `dev` profile to wrap around on overflow.
// Check Cargo's documentation to find out the right syntax:
// https://doc.rust-lang.org/cargo/reference/profiles.html
//
// For reasons that we'll explain later, the customization needs to be done in the `Cargo.toml`
// at the root of the repository, not in the `Cargo.toml` of the exercise.

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

#[cfg(test)]
mod tests {
    use crate::factorial;

    #[test]
    fn twentieth() {
        // 20! is 2432902008176640000, which is too large to fit in a u32
        // With the default dev profile, this will panic when you run `cargo test`
        // We want it to wrap around instead
        assert_eq!(factorial(20), 2_192_834_560);
        //                           ☝️
        // A large number literal using underscores to improve readability!
    }

    #[test]
    fn first() {
        assert_eq!(factorial(0), 1);
    }

    #[test]
    fn second() {
        assert_eq!(factorial(1), 1);
    }

    #[test]
    fn third() {
        assert_eq!(factorial(2), 2);
    }

    #[test]
    fn fifth() {
        assert_eq!(factorial(5), 120);
    }
}
```
</details>

ってさっきの問題の答えが書いてる...！？

そして何をすればよいかわかりにくい問題ですが、どうやら「 `20! = 2432902008176640000` は大きすぎるからオーバーフローによりパニックしちゃうので、パニックしないように `Cargo.toml` の設定を書き換えて！ 」という問題らしいです。

## 解説

プロジェクトのCargo.toml (exercises内の問題ごとの[Cargo.toml](https://github.com/mainmatter/100-exercises-to-learn-rust/blob/main/exercises/02_basic_calculator/08_overflow/Cargo.toml)ではなく、大本の[Cargo.toml](https://github.com/mainmatter/100-exercises-to-learn-rust/blob/main/Cargo.toml)です) の方に、オーバーフロー発生時に無視する設定を追記します。

```diff_toml:Cargo.toml
[workspace]
members = ["exercises/*/*", "helpers/common", "helpers/mdbook-exercise-linker", "helpers/ticket_fields"]
resolver = "2"

+ [profile.dev]
+ overflow-checks = false
```

...いや、無理やりすぎるだろ...？！ちなみに `dev` (デバッグビルド) だと `overflow-checks` のデフォルト値は `true` な一方で、 `release` (リリースビルド) だとデフォルト値は `false` になっています。[AtCoder](https://atcoder.jp/?lang=ja)でRustを選択して解答するとリリースビルドが行われるため、手元(デバッグビルド)だとオーバーフローのせいでRE (ランタイムエラー) になるケースが、回答送信後にWA (誤答) で表示されるという初見殺しがあるのですが、つまりプロファイルのデフォルト値が原因なわけです。

オーバーフローへの対策には色々ありますね。AtCoderで回答する際は `10e9+7` 等の素数で剰余を取ったりしますし、筆者が専攻していた暗号学では「有限体」というものを用いて全ての演算結果が必ず有限集合(体)の中に収まるような計算しか取り扱わなかったりします[^ff]。

[^ff]: もちろん、有限体ではなく普通に実数を使う暗号なんかもあったりしますが、筆者は有限体を用いる暗号が好きでした。

素数での剰余を取るわけではないので演算の整合性が取れなくなる気がしますが、本問のテストケースは単に溢れたらまた0からカウントしている(wrap aroundしている)実装になってそうです。Cargo.tomlを編集してオーバーフローが検知できなくなるのは避けたいので、wrap aroundしていることを踏まえて別解も考えてみました。

```rust:lib.rs
pub fn factorial(n: u32) -> u32 {
    let mut result = 1u32;
    for i in 1..=n {
        result = result.wrapping_mul(i);
    }
    result
}
```

[`u32::wrapping_mul`](https://doc.rust-lang.org/std/primitive.u32.html#method.wrapping_mul) を使えばwrap aroundに演算を行ってくれ、テストを通すことができます！ソースコード側でオーバーフローに配慮されていることを明記していたほうが、一々Cargo.tomlを見なくて済んで良さそうですね。

では次の問題に行きましょう！

次の記事: [【4】 キャスト・構造体 (たまにUFCS)](https://qiita.com/namn1125/items/227ed5bbedbb775c5d27)

<details><summary>登場したPlayground</summary>

(実際に無効化したことはないですが、)Rust Playground上のデータが喪失する可能性を鑑みて、一応記事にもソースコードを掲載することとしました。

URL: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=2df7c0d72790feede86cf0f9082c298c

```rust:Rust
#[derive(Debug)]
struct Hoge<'a>(&'a mut i32);

fn main() {
    let mut n = 10_i32;
    
    let hoge = Hoge(&mut n);
    
    println!("{:?}", hoge);
    
    *hoge.0 = 5;
    
    println!("{:?}", hoge);
}
```
</details>