Lazy readonly "property" in Rust - rust

Question

Given this struct in Rust:
struct OrderLine {
price: f32,
quantity: f32,
}
impl OrderLine {
fn total(&self) -> f32 {
println!("total has been computed"); // this is used in the test bellow
self.price * self.quantity
}
}
How can I:
Compute the total value only once per instance of this struct, even when this function is called multiple times (please, see the test bellow for an example of the expected behaviour). The total value must be lazy calculated. I don't want it to be pre-computed when the struct is initialized, for example in an OrderLine::new function.
Maintain consistency between total and the underlining values (price and quantity):
If we allow them to change, total must be recomputed the next time it gets called.
Or, if that is not possible or too difficult, make this struct immutable to prevent changes.
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_total_must_be_computed_only_once() {
let order_line = OrderLine {
price: 10.0,
quantity: 2.0,
};
println!("before calling total for the first time");
println!("{}", order_line.total());
println!("before calling total for the second time");
println!("{}", order_line.total());
// The actual output is:
// before calling total for the first time
// total has been computed
// 20
// before calling total for the second time
// total has been computed <- repeated
// 20
// The expected output is:
// before calling total for the first time
// total has been computed <- no repetition
// 20
// before calling total for the second time
// 20
}
}

Answer 1

An alternate approach is to use a OnceCell. The benefit of this (vs the Option approach) is that is does not require &mut self access:
// in the process of being added to the standard library, but not there yet
use once_cell::unsync::OnceCell;
pub struct OrderLine {
price: f32,
quantity: f32,
total: OnceCell<f32>,
}
impl OrderLine {
pub fn new(price: f32, quantity: f32) -> Self {
OrderLine {
price,
quantity,
total: OnceCell::new(),
}
}
pub fn total(&self) -> f32 {
// calculate the total if not already calculated
*self.total.get_or_init(|| {
println!("COMPUTED"); // this is used in the test bellow
self.price * self.quantity
})
}
pub fn set_price(&mut self, price: f32) {
self.price = price;
// clear the previous calculated total
self.total = OnceCell::new();
}
pub fn set_quantity(&mut self, quantity: f32) {
self.quantity = quantity;
// clear the previous calculated total
self.total = OnceCell::new();
}
}
playground

Answer 2

Here's one approach using an Option:
pub struct OrderLine {
price: f32,
quantity: f32,
total: Option<f32>,
}
impl OrderLine {
pub fn new(price: f32, quantity: f32) -> Self {
Self {
price,
quantity,
total: None,
}
}
pub fn total(&mut self) -> f32 {
*self.total.get_or_insert_with(|| {
let total = self.price * self.quantity;
println!("total has been computed"); // this is used in the test bellow
total
})
}
pub fn set_price(&mut self, price: f32) {
self.price = price;
self.total = None;
}
pub fn set_quantity(&mut self, quantity: f32) {
self.quantity = quantity;
self.total = None;
}
pub fn price(&self) -> f32 {
self.price
}
pub fn quantity(&self) -> f32 {
self.quantity
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_total_must_be_computed_only_once() {
let mut order_line = OrderLine::new(10.0, 2.0);
println!("before calling total for the first time");
println!("{}", order_line.total());
println!("before calling total for the second time");
println!("{}", order_line.total());
order_line.set_price(500.0);
println!("before calling total for the third time");
println!("{}", order_line.total());
}
}