How can I store the result of format_description::parse in a struct field?

[ReagentX]

I have a struct like:

struct Date<'a, T: Display> {
    format: String,
    formatter: Vec<FormatItem<'a>>,
    earliest: Option<T>,
    latest: Option<T>,
}

Given this struct, I want to store the result of format_description::parse in the formatted field so I do not have to recompute it every time I want to use it. After many failed attempts I got close:

fn new(method: AggregationMethod) -> Self {
    if let AggregationMethod::Date(format_string) = method {
        match parse(&format_string) {
            Ok(formatter) => {
                let parser: Date<'a, T> = Date {
                    format: format_string.to_owned(),
                    formatter,
                    earliest: None,
                    latest: None,
                };
                return parser;
            }
            Err(why) => panic!(why),
        }
    } else {
        todo!();
    };
}

For context, AggregationMethod::Date is an enum like Date(String). My goal is to make Date own all of this data, and it should die when Date dies.

The problem with my code above is that parse borrows parser.format and the result uses that borrow, so I cannot return parser here because the borrow dies at the return.

I thought that I might be able to construct the Date first (and convert formatter to a Option<Vec<FormatItem<'a>>>), then add the formatter later, but I ran into the same problem:

fn new(method: AggregationMethod) -> Self {
    if let AggregationMethod::Date(format_string) = method {
        let mut parser: Date<'a, T> = Date {
            format: format_string,
            formatter: None,
            earliest: None,
            latest: None,
        };
        match parse(&parser.format) {
            Ok(formatter) => {
                parser.formatter = Some(formatter);
                return parser;
            }
            Err(why) => panic!(why),
        }
    } else {
        panic!("Date aggregator constructed with non-date AggregationMethod!")
    };
}

If it is useful, here is the compiler output of this second block of code:

error[E0597]: `parser.format` does not live long enough
  --> src/util/aggregators/date.rs:25:25
   |
16 | impl<'a, T: Display> Aggregator<T> for Date<'a, T> {
   |      -- lifetime `'a` defined here
...
19 |             let mut parser: Date<'a, T> = Date {
   |                             ----------- type annotation requires that `parser.format` is borrowed for `'a`
...
25 |             match parse(&parser.format) {
   |                         ^^^^^^^^^^^^^^ borrowed value does not live long enough
...
32 |         } else {
   |         - `parser.format` dropped here while still borrowed

error[E0505]: cannot move out of `parser` because it is borrowed
  --> src/util/aggregators/date.rs:28:28
   |
16 | impl<'a, T: Display> Aggregator<T> for Date<'a, T> {
   |      -- lifetime `'a` defined here
...
19 |             let mut parser: Date<'a, T> = Date {
   |                             ----------- type annotation requires that `parser.format` is borrowed for `'a`
...
25 |             match parse(&parser.format) {
   |                         -------------- borrow of `parser.format` occurs here
...
28 |                     return parser;
   |                            ^^^^^^ move out of `parser` occurs here

[jhpratt]

Given that you mentioned you want the struct to own everything, this is not possible. Self-referential structs don't exist in Rust, and that's what would be required — the FormatItem::Literal variant would point to the contents of the format field.

I don't think this is the case given what you've stated, but if the format description is statically-known, you can use the time::macros::format_description macro.