Konvertieren von Option <String> in Option <& str>

Sehr oft habe ich eine Option<String>aus einer Berechnung erhalten und möchte entweder diesen Wert oder einen fest codierten Standardwert verwenden.

Dies wäre mit einer ganzen Zahl trivial:

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

Aber mit a Stringund a &strbeschwert sich der Compiler über nicht übereinstimmende Typen:

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

Der genaue Fehler hier ist:

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`

Eine Möglichkeit besteht darin, das String-Slice in einen eigenen String zu konvertieren, wie von rustc vorgeschlagen:

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

Dies führt jedoch zu einer Zuordnung, die unerwünscht ist, wenn ich das Ergebnis sofort wieder in einen String-Slice konvertieren möchte, wie in diesem Aufruf an Regex::new():

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

Ich würde das lieber konvertieren Option<String> , um ein Option<&str>diese Zuordnung zu vermeiden.

Was ist die idomatische Art, dies zu schreiben?

Ab Rust 1.40 muss die Standardbibliothek Folgendes Option::as_dereftun:

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

Sie können ein verwenden as_ref()und map()ein Option<String>in ein verwandeln 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");
}

Nehmen Sie zunächst as_ref()implizit eine Referenz auf opt, geben Sie eine &Option<String>(weil as_ref()nimmt &self, dh es erhält eine Referenz), und verwandeln Sie sie in eine Option<&String>. Dann mapkonvertieren wir es in ein Option<&str>. Hier ist was&**x tut: die rechte *(die zuerst ausgewertet wird) einfach dereferenziert die &Stringeinen geben Stringlvalue. Dann *ruft das am weitesten links stehende DerefMerkmal tatsächlich auf , weil es String implementiert wird Deref<Target=str> , was uns einen strWert gibt. Schließlich &nimmt das die Adresse des strWertes und gibt uns eine &str.

Sie können dies etwas weiter vereinfachen, indem Sie map_orkombinieren mapund unwrap_orin einer einzigen Operation verwenden:

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

Wenn &**xIhnen das zu magisch erscheint, können Sie String::as_strstattdessen schreiben :

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

oder String::as_ref(aus dem AsRefMerkmal, das im Vorspiel steht ):

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

oder String::deref(obwohl Sie das DerefMerkmal auch importieren müssen ):

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);
}

Damit beides funktioniert, müssen Sie einen Eigentümer Option<String>so lange behalten, wie das Option<&str>oder das Unverpackte &strverfügbar bleiben muss. Wenn das zu kompliziert ist, könnten Sie verwendenCow .

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));
}

Ein schöner Weg könnte sein, dies generisch zu implementieren für 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)
    }
}

was effektiv verallgemeinert as_ref.

Obwohl ich die Antwort von Veedrac liebe (ich habe sie verwendet), können Sie sie verwenden, wenn Sie sie nur an einer Stelle benötigen und etwas Ausdrucksstarkes möchten as_ref(), mapund String::as_strverketten:

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

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

Hier ist eine Möglichkeit, wie Sie es tun können. Beachten Sie, dass Sie haben das Original zu halten Stringum, sonst was wäre das &strein Stück sein , in?

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

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

Laufstall