Rustの構造体に文字列を持たせるいくつかの方法

# きっかけ

Rust Programming Language Forumにこんな質問が出ていました。

https://users.rust-lang.org/t/idiomatic-string-parmeter-types-str-vs-asref-str-vs-into-string/7934

> 構造体にStringを持たせられるようにStringを受け取りたいです。これを実現する方法はいくつかあります。
>
> - `&str`
> - `String`
> - `T: Into<String>`
> - `T: AsRef<str>`
>
> 例:
>
> ```rust
> pub struct Person {
>     name: String,
> }
>
> impl Person {
>     pub fn new(name: WhatTypeHere) -> Person {
>         Person { name: name.some_conversion() }
> }
> ```
>
> どれが一番Rustらしい書き方ですか？

単純に構造体に文字列を持たせる方法はいくつかあるのですが、実はその実装方法によって文字列のコピーやアロケーションの回数が異なります。

ここでは、上記の4つの場合と、コメント欄で提案されている`T: Into<Cow<'a, str>>`を使った方法をそれぞれ比較してみます。

# 質問者が提示する4つの方法

## `&str`

`&str`を使う実装というのは、2通り考えられます。

### パターン1

```rust
pub struct Person {
    name: String
}

impl Person {
    pub fn new(name: &str) -> Person {
        Person { name: name.to_string() }
    }
}
```

この方法では、文字列への参照を受取り、そこから文字列をコピーしてPersonに持たせます。
つまり、`Person::new()`を呼び出す度にアロケーションとコピーが発生します。

たとえ呼び出し側においてname変数が不要であっても、必ずその変数をコピーするということを意味します。

```rust
fn main() {
    let name: String = fetch_name();
    let person = Person::new(&name); // => nameの値をコピーする

    // これ以降はname変数は不要
}
```

### パターン2

では、アロケーションを避けるにはどうすれば良いでしょうか？
単純な方法としては、Person構造体に参照を直接持たせる方法が考えられます。

```rust
pub struct Person<'a> {
    name: &'a str
}

impl<'a> Person<'a> {
    pub fn new(name: &'a str) -> Person<'a> {
        Person { name }
    }
}
```

しかし、この方法はあまり使われません。
なぜなら、nameの寿命がPersonより短い時、ライフタイムチェッカーに引っかかってコンパイルできなくなるからです。

```rust
// これはコンパイルエラー

fn get_person() -> Person {
    let output: String = ExternalCommand::run();
    for line in output.lines() {
        if line.starts_with("name: ") {
            return Person::new(&line[6..]);
        }
    } // <- ここでlineの寿命が切れる

    ...(省略)
}
```

## `String`

それならば、参照の場合だけコピーして、不要なString変数を持っている時はコピーしなければ良い、という発想に至ります。

```rust
pub struct Person {
    name: String
}

impl Person {
    pub fn new(name: String) -> Person {
        Person { name }
    }
}
```

しかし多くの場合、文字列は`&str`型で保持しているのが普通です。
この方法では呼び出し側が明示的に`String`型に変換する必要があるため、Personを多く生成しようとするとコードが一気に煩雑になります。

```rust
fn main() {
    let sato = Person::new("sato".to_string());
    let suzuki = Person::new("suzuki".to_string());
    let tanaka = Person::new("tanaka".to_string());
}
```

また、Rustにおいては変数の型が`String`であるか`&str`であるか分かりにくいケースも存在しますが、この関数では呼び出し側が型変換に関するすべての責任を負わなければなりません。

## `T: Into<String>`

そこでGenericsの登場です。Genericsを上手く使って`String`型と`&str`型を両方受け取り、関数内で型変換を行います。

```rust
pub struct Person {
    name: String
}

impl Person {
    pub fn new(name: impl Into<String>) -> Person {
        Person { name: name.into() }
    }
}
```

これならば、呼び出し側が文字列の型をいちいち気にする必要はありません。

```rust
fn main() {
    let name = "sato";
    let person = Person::new(name);

    let name = "sato".to_string();
    let person = Person::new(name);
}
```

## `T: AsRef<str>`

`&str`のGenericsバージョンです。
この方法も毎回コピーが発生します。

```rust
pub struct Person {
    name: String
}

impl Person {
    pub fn new(name: impl AsRef<str>) -> Person {
        Person { name: name.as_ref().to_string() }
    }
}
```

`AsRef`トレイトについては[この記事](https://qiita.com/hibariya/items/b24f893f88d0dc931c61)が詳しいです。

# ちょっと待った！

一見すると、パフォーマンス面で優れているのは`String`と`T: Into<String>`を使った方法のように見えますが、実はさらにコピーを減らすことが出来ます。

具体的にどういったケースで無駄なコピーが発生しているかと言うと、引数がPersonオブジェクトよりも長い寿命を持っている場合です。
例えば、

```rust
fn main() {
    let person = Person::new("sato");
}
```

という文において、"sato"の型は`&'static str`です。つまりその寿命はプログラムが終了するまで生き続けており、わざわざコピーせずともその変数を参照すればよいということになります。

そのための方法が、今回の回答欄でも提案されている`Cow<&'static, str>`を使ったイディオムです。

```rust
pub struct Person {
    name: Cow<'static, str>
}

impl Person {
    pub fn new(name: impl Into<Cow<'static, str>>) -> Person {
        Person { name: name.into() }
    }
}
```

[Cow](https://doc.rust-lang.org/std/borrow/enum.Cow.html#method.into_owned)とは、参照型と所有型のいずれかを保持することが出来るオブジェクトです。
つまり、一つの変数でデータを参照することも、変数を所有することも出来ます。

上記のプログラムは、`Person::new()`メソッドに渡す変数の型によって以下のように異なる挙動を示します。

- `String` => 引数の所有権がmoveされ、Person構造体がその所有権を持つようになる（ゼロコピー）[^1]
- `&'static str`型（つまり文字列リテラル） => 引数を参照する（ゼロコピー）[^2]
- `&str`または`&String` => トレイト境界を満たしていないのでコンパイルエラー

[^1]: Cow<'static, str>::Ownedを生成(https://github.com/rust-lang/rust/blob/1.38.0/src/liballoc/string.rs#L2260-L2266)
[^2]: Cow<'static, str>::Borrowedを生成(https://github.com/rust-lang/rust/blob/1.38.0/src/liballoc/string.rs#L2252-L2258)

つまり、`Person::new()`メソッド内においては一度もコピーが発生しないことになります。

ただし、staticな寿命を持たない参照変数を渡す時は、呼び出し側が明示的にその変数をコピーする必要があります。

```rust
fn main() {
    let sato = Person::new("sato");  // <= 文字列を参照
    let suzuki = Person::new("suzuki".to_string());   // <= 文字列の所有権を移譲
    let person = get_person();
}

fn get_person() -> Person {
    let output: String = ExternalCommand::run();
    for line in output.lines() {
        if line.starts_with("name: ") {
            return Person::new(line[6..].to_string());  // <= 文字列を明示的にコピー
        }
    }  // <= ここでlineの寿命が切れるが、中身はコピーしているので問題なし

    ...(省略)
}
```

# 結局どれが良いのか

競プロなどPerformanceを第一に考える場面では、`Cow`を使うケースもあるかもしれません。
しかし実用上においては、`Cow`を使用した書き方はあまり好ましくないと思われます。

第一に、Cowは文字列を所有しているのか参照しているのかがコンパイル時に分からないため、スレッドなどで並行処理を行う際に余計なリスクが発生する場合があります。
場合によっては、全く意図しないタイミングで`Person`の`name`の値が書き換わったり、読み込みと書き込みが同時に行われることでもはや出力は予測できないものになることも考えられます。

第二に、設計の変更などでnameフィールドをmutableに変更したくなった場合、`Cow`を使った方法ではプログラム全体を大々的に書き換える必要が生じます。
文字列リテラルは`&'static str`なのであって`&'static mut str`ではありませんから、文字列リテラルを渡すときも結局コピーする必要が出てきます。
したがってプログラムの保守性という観点から見ても、`Cow`を使うのはあまり好ましい選択とは言えません。

第三に、呼び出し側が変数の寿命を意識する必要があるというデメリットにも関わらず、`Cow`を使うことによって得られるメリットはほんのわずかなPerformanceの向上だけです。
実用プログラミングにおいては開発効率や保守性などのほうが優先されますし、特にPerformanceというのは開発がある程度安定してから徐々に変更を加えていく程度で良いと考えています。

もちろんプログラムを書く目的にもよるので一概にそうとは言い切れませんが、少なくとも実用プログラミングにおいては、開発初期の段階で`String`または`T: Into<String>`の方法を利用し、設計が安定してmutableにする必要がなくなり、ほんの僅かでもPerformanceを向上させたい場合のみ、`Cow`を使うのが良いのではないでしょうか。