Option <String>からOption <＆str>への変換

Question 1

非常に頻繁に私は Option<String>計算からありますが、この値またはデフォルトのハードコードされた値のいずれかを使用したいと思います。

これは整数では簡単です。

let opt: Option<i32> = Some(3);
let value = opt.unwrap_or(0); // 0 being the default

しかし、aStringとaを使用すると&str、コンパイラは型の不一致について文句を言います。

let opt: Option<String> = Some("some value".to_owned());
let value = opt.unwrap_or("default string");

ここでの正確なエラーは次のとおりです。

error[E0308]: mismatched types
 --> src/main.rs:4:31
  |
4 |     let value = opt.unwrap_or("default string");
  |                               ^^^^^^^^^^^^^^^^
  |                               |
  |                               expected struct `std::string::String`, found reference
  |                               help: try using a conversion method: `"default string".to_string()`
  |
  = note: expected type `std::string::String`
             found type `&'static str`

1つのオプションは、rustcによって提案されているように、文字列スライスを所有されている文字列に変換することです。

let value = opt.unwrap_or("default string".to_string());

しかし、これにより割り当てが発生します。これは、次の呼び出しのように、結果をすぐに文字列スライスに変換する場合には望ましくありませんRegex::new()。

let rx: Regex = Regex::new(&opt.unwrap_or("default string".to_string()));

私はむしろ変換したい Option<String>Option<&str>この割り当てを回避するために、をにます。

これを書くための理想的な方法は何ですか？

Question 2

Rust 1.40の時点で、標準ライブラリはOption::as_derefこれを行う必要があります。

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_deref().unwrap_or("default string");
}

Question 3

あなたは使用することができますas_ref()し、map()変換することOption<String>にOption<&str>。

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map(|x| &**x).unwrap_or("default string");
}

まず、as_ref()暗黙的に参照を取るopt与え、&Option<String>（のでas_ref()とり&self、それは参照を受け、すなわち）、およびに変換しますOption<&String>。次に、を使用mapしてそれをに変換しOption<&str>ます。実行内容&**xは次のとおりです。右端*（最初に評価される）は単にを逆参照し&String、String左辺値を与えます。次に、左端が*実際にDerefトレイトを呼び出します。これString は Deref<Target=str>、を実装して、str左辺値を与えるためです。最後に、&はstr左辺値のアドレスを取り、を与え&strます。

を使用して1回の操作でmap_or組み合わせるmapとunwrap_or、これをもう少し単純化できます。

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", |x| &**x);
}

&**x魔法のように見える場合は、String::as_str代わりに次のように書くことができます。

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", String::as_str);
}

またはString::as_ref（プレリュードに AsRefある特性から）：

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", String::as_ref);
}

またはString::deref（Derefトレイトもインポートする必要がありますが）：

use std::ops::Deref;

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.as_ref().map_or("default string", String::deref);
}

これらのいずれかが機能するためにはOption<String>、Option<&str>またはラップさ&strれていないものが利用可能である必要がある限り、所有者を維持する必要があります。それが複雑すぎる場合は、を使用できますCow。

use std::borrow::Cow::{Borrowed, Owned};

fn main() {
    let opt: Option<String> = Some("some value".to_owned());
    let value = opt.map_or(Borrowed("default string"), |x| Owned(x));
}

Question 4

より良い方法は、これを一般的にT: Deref次のように実装することです。

use std::ops::Deref;

trait OptionDeref<T: Deref> {
    fn as_deref(&self) -> Option<&T::Target>;
}

impl<T: Deref> OptionDeref<T> for Option<T> {
    fn as_deref(&self) -> Option<&T::Target> {
        self.as_ref().map(Deref::deref)
    }
}

これは効果的に一般化しas_refます。

Question 5

私はVeedracの答えが大好きです（私はそれを使用しました）が、ある時点でそれが必要で、表現力豊かなものが必要な場合は、使用as_ref()しmapてString::as_strチェーンすることができます：

let opt: Option<String> = Some("some value".to_string());

assert_eq!(Some("some value"), opt.as_ref().map(String::as_str));

Question 6

これがあなたがそれをすることができる1つの方法です。オリジナルを維持する必要があることを覚えておいてくださいString。そうしないと、何に&strスライスされますか？

let opt = Some(String::from("test")); // kept around

let unwrapped: &str = match opt.as_ref() {
  Some(s) => s, // deref coercion
  None => "default",
};

ベビーサークル