Rustのイディオム

# この記事について
[Rust Design Patterns](https://github.com/rust-unofficial/patterns)で紹介されているRustでのプログラミングにおけるイディオムをまとめました。

# `format!`マクロを使用したstringの結合
所有権の制約によりRustでのstringの結合はとてもめんどくさいです。

```rust:concat_string.rs
let mut result = "Hello".to_owned();
let mut name = "World".to_owned();
result.push_str(name);
result.push('!');
```

`format!`マクロを使えばかんたんに結合できます。

```rust:concat_string2.rs
let mut name = "World".to_owned();
let mut result = format!("Hello {}!", name);
```

# `Default`トレイト
Rustの多くの型がその型独自のコンストラクタ（`new()`メソッド）を持っています。しかし、Rustは「`new()`メソッドを持つ型全てに渡って再帰的に適用可能」という抽象化を行っていません。
なので、`new()`を定義するときに全てのメンバの値を書いてやらなければいけません。

```rust:Hako.rs
struct Hako
{
    one : i32,
    two : i64,
    fone : f32,
    ftwo : f64,
}

impl Hako {
    fn new() -> Self
    {
         Hako {one : 0, two : 0, fone : 0.0, ftwo : 0.0}
    }
}
```

見ての通り`new`内で一つ一つ要素の初期値を指定するのはめんどくさいです。
そこで、`Default`トレイトを使います。

```rust:Hako.rs
#[derive(Default)]
struct Hako
{
    one : i32,
    two : i64,
    fone : f32,
    ftwo : f64,
}

fn main() -> ()
{
    let a : Hako = Default::default();
}
```

`#[derive(Default)]`を継承するだけで実装可能。rustのプリミティブ型ならすでに`Default`トレイトが実装されているので、`new()`のように要素の初期値を指定する必要はありません。
さらに、`Default`トレイトは再帰的に適用されるので自分で定義した構造体をメンバとして持つ構造体でも`Default`トレイトが実装されていれば`#[derive(Default)]`を継承するだけで実装可能です。

```rust:LHako.rs
#[derive(Default)]
struct Hako
{
    one : i32,
    two : i64,
    fone : f32,
    ftwo : f64,
}

#[derive(Default)]
struct LHako
{
    one : Hako,
    two : Hako,
}

fn main() -> ()
{
    let a : LHako = Default::default();
}
```

個人的には`new()`っていらなくね？と感じました。

# デストラクタで後始末
関数内で複数の返すところがあると、処理の流れがわかりにくい上に、同じような処理を繰り返す可能性が高いです。Javaなどではfinalizeブロック、メソッドこういった事を行うのですが、このような機能はRustにはありません。そのかわり、関数内でローカルの構造体とそのメソッドを定義する機能を提供しています。その機能を利用して、関数が抜けたときに実行される後始末処理を定義します。

```rust:finalize.rs
fn hoge() -> i32
{
    struct Final;
    impl Drop for Final
    {
         fn drop(&mut self)
         {
              println!("Bye Bye");
         }
    }
    let finalizer = Final;
    /*ここで処理を実行*/
    /*関数から抜けるとかならず"Bye Bye"してくれる*/
}
```

# Option型でイテレート
Option型は実は`IntoIterator`トレイトを実装しています。
このためSomeでラップするとイテレータに対して定義された関数が使えるようになります。

```rust:option-iter.rs
let hoge = Some("hoge");
let mut mojo = vec!["buzz", "fizz"];
mojo.extend(hoge);
for elem in mojo.iter().charin(hoge.iter())
{
    println!("{}", elem);
}
```

# 拡張性のためのプライベート
`pub`で修飾しないフェールドを用いて構造体を拡張しても、動作の安定性が失われないようにします。

```rust:priv-extend
mod a {
    // パブリックな構造体
    pub struct S {
        pub foo: i32,
        // プライベートなメンバ変数
        bar: i32,
    }
}

fn main(s: a::S) {
    // 公開されていない部分に関しては".."で初期化する
    let hoge = a::S { foo: _, ..};

    // 構造体Sにメンバが新しく追加されてもこの部分は修正しなくてもよい。
}
```

# コンストラクタ
Rustにはコンストラクタがありません。代わりに`new`メソッドを使ってオブジェクトを生成することが慣例になっています。

```rust:ctor.rs
pub struct Hoge {
    fuga : i32,
}

impl Hoge {
    pub fn new() -> Self
    {
       Hoge {fuga : 42,}
    }
}
```

# `mem::replace`によるenumの書き換え
Rustのenumを使っているときにenumのデータを書き換えたくなるときがあります。
ちょうど下のような感じです。

```rust:replace.rs
enum MyEnum
{
    A{ name : String},
    B{ name : String},
}

fn overwrite(e : &mut MyEnum) -> ()
{
    *e = match *e {
        A(ref mut name) => B {name : String::new("Bだぜ")},
        B(ref mut name) => A {name : String::new("Aだぜ")},
     }
}
```

しかし、これは以下のエラーによりコンパイルできません。

```
cannot move out of borrowed content
```

eはnameを参照しているからです。nameを変更するとeの参照先が消えるのでボローチェッカがキレます。
そこで、mem::replaceを使います。mem::replaceを使うとボローチェッカを怒らせることなく参照先を変更することができます。（これって安全な操作なのか？）

```rust:mem-replace.rs
enum MyEnum
{
    A{ name : String},
    B{ name : String},
}

fn overwrite(e : &mut MyEnum) -> ()
{
    *e = match *e {
        A(ref mut name) => B {name : mem::replace(name, String::new("Bだぜ"))},
        B(ref mut name) => A {name : mem::replace(name, String::new("Aだぜ"))},
     }
}
```

# クロージャに変数渡し
デフォルトではクロージャには借用か、ムーブで環境の変数を渡すことができます。しかし、参照やコピーで渡したいときがあります。そのような場合は、まず以下のように変数を`Rc`でラップし、クロージャをブロックの中に入れた上で、ブロック内部で各変数を再バインディングします。

```rust:pass_var.rs
let num1 = Rc::new(1);
let num2 = Rc::new(2);
let num3 = Rc::new(3);
let closure = {
    // num1はムーブ
    let num2 = num2.clone();  // num2はコピー
    let num3 = num3.as_ref();  // num3は借用
    move || {
        *num1 + *num2 + *num3;
    }
};

```

# 参考文献
* [Rust Design Patterns](https://github.com/rust-unofficial/patterns)    
ラストの非公式デザインパターン集    
* [Defaultトレイト](https://doc.rust-lang.org/std/default/trait.Default.html)    
Defaultトレイトの公式ドキュメント  
* [mem::replace関数](https://doc.rust-lang.org/std/mem/fn.replace.html)    
mem::replace関数の公式ドキュメント

# 救援要請
「Collections are smart pointers」イディオムがちょっと意味がわかりませんでした。
わかった人がいたらコメントで説明していただければ幸いです。