Lifetime of format!() in match expression is too short - rust

Question

I am implementing a custom Display::fmt for my own struct which represent an interval.
struct Range<T> {
lower: Option<T>,
upper: Option<T>,
}
A range could be Range { lower: Some(1), upper: None }, which means it contains all integers from 1 up to infinity (or the limit of i32 I suppose).
I want to implement Display::fmt to use T's Display::fmt if the bound is not None and to display an empty string otherwise:
let range = Range { lower: Some(1), upper: None }
println!("{}", range); // Prints <1,>
let range = Range { lower: Some(1), upper: Some(10) }
println!("{}", range); // Prints <1,10>
let range = Range { lower: None, upper: Some(10) }
println!("{}", range); // Prints <,10>
I have started my implementation but have trouble with the match expression and the lifetime of the string produced by format!(). The problem with my implementation is that the string returned by format doesn't live long enough to be used further down.
fn main() {
let opt = Some(1);
let opt_display = match opt {
Some(x) => &format!("{}", x), // error: borrowed value does not live long enough
None => "",
};
println!("opt: {}", opt_display);
}
Why doesn't my approach work and what is a good solution to my problem?

Answer 1

I'm no expert on lifetimes, but I believe the problem here is that you are trying to return a &String from a String created by format! inside the match. Since the scope of the format is only inside the scope, the borrow checker complains.
To fix this you can use an owned string.
fn main() {
let opt = Some(1);
let opt_display = match opt {
Some(ref x) => format!("{}", x), // Allowed since opt_display now owns the string
None => "".into(),
};
// Another way to achieve the same thing.
//let opt_display = opt.map(|s| format!("{}", s)).unwrap_or("".into());
println!("opt: {}", opt_display);
}

Answer 2

When implementing Display, there's no need to return strings; you can just write!() into the provided formatter.
It would look like:
impl<T: Display> Display for Range<T> {
fn fmt(&self, fmt: &mut Formatter) -> Result<(), std::fmt::Error> {
write!(fmt, "<")?;
if let Some(v) = self.lower {
write!(fmt, "{}", v)?;
}
write!(fmt, ",")?;
if let Some(v) = self.upper {
write!(fmt, "{}", v)?;
}
write!(fmt, ">")
}
}
Playground

Answer 3

As Emilgardis has already explained, you are trying to return a reference to a value that will be dropped while the reference is still around. Congratulations, you just tried to create memory unsafety that would have caused a crash (or worse) in C or C++, but Rust prevented it!
One efficiency improvement you can make is to only allocate in one case:
fn main() {
let opt = Some(1);
let opt_display = opt.map(|s| format!("{}", s));
// Type not needed, only used to assert the type is what we expect
let opt_display_str: &str = opt_display.as_ref().map(String::as_str).unwrap_or("");
println!("opt: {}", opt_display_str);
}
You could also use a Cow, which allows either an owned or borrowed string. Note how similar it is to the other answer, but this doesn't allocate in the case of None:
use std::borrow::Cow;
fn main() {
let opt = Some(1);
let opt_display: Cow<str> = match opt {
Some(ref x) => format!("{}", x).into(),
None => "".into(),
};
println!("opt: {}", opt_display);
}
I want to implement Display::fmt
The best thing to do is probably to avoid any allocation then. You will be handed a formatter that you write! to, just call write! in each match arm. This might introduce a bit of duplication, but is probably more efficient. Without the formatter, it would look something like:
fn main() {
let opt = Some(1);
print!("opt: ");
if let Some(ref x) = opt {
print!("{}", x);
}
println!("");
}
Substitute write!(f, for print!( inside the formatter and return on error.