Преобразование из Option <String> в Option <& str>

Очень часто я получаю Option<String>вычисление и хочу использовать это значение или жестко заданное значение по умолчанию.

С целым числом это было бы тривиально:

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

Но с a Stringи 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`

Один из вариантов - преобразовать строковый фрагмент в принадлежащую String, как предлагает 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>чтобы избежать этого распределения.

Как это идоматически написать?

Начиная с 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");
}

Вы можете использовать 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объект, давая Stringlvalue. Затем крайний левый *фактически вызывает Derefтрейт, потому что String реализует Deref<Target=str> , давая нам strlvalue. Наконец, &принимает адрес strlvalue, давая нам &str.

Вы можете немного упростить это, используя 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));
}

Лучше всего реализовать это в общем для 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.

Несмотря на то, что я люблю ответ 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));

Вот один из способов сделать это. Имейте в виду, что вы должны сохранить оригинал String, иначе во что будет &strнарезаться?

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

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

детский манеж