Idiomatic way to memoize or lazy evaluate using `Cell` and `RefCell` - rust

Question

The code below works. It evaluates x and ys lazily and caches into Foo::x: Cell, Foo::ys: RefCell respectively.
However, I feel there might be a better way to do it. I dislike I have to make a wrapper CacheVecGuard so that on the call site I can use self.borrow_ys() instead of the lengthy &self.ys.borrow().1.
How can I improve this piece of code?
Are there any canonical snippets to do lazy evaluation or memoization that is suitable in this case? (I am aware of lazy_static which doesn't fit)
use std::cell::{RefCell, Cell, Ref};
use std::ops::Deref;
struct CacheVecGuard<'a>(Ref<'a, (bool, Vec<f64>)>);
impl<'a> Deref for CacheVecGuard<'a> {
type Target = [f64];
fn deref(&self) -> &Self::Target {
&(self.0).1
}
}
fn pre_calculate_x(x: f64) -> f64 {
x
}
fn pre_calculate_ys(x: f64, ys: &mut [f64]) {
for i in 0..ys.len() {
ys[i] += 1.0;
}
}
struct Foo {
pub a: f64,
x: Cell<Option<f64>>,
ys: RefCell<(bool, Vec<f64>)>,
}
impl Foo {
pub fn new(a: f64) -> Self {
Self {
a,
x: Cell::new(None),
ys: RefCell::new((false, vec![0.0; 10])),
}
}
fn get_x(&self) -> f64 {
match self.x.get() {
None => {
let x = pre_calculate_x(self.a);
self.x.set(Some(x));
println!("Set x to {}", x);
x
}
Some(x) => x,
}
}
fn borrow_ys(&self) -> CacheVecGuard {
{
let (ref mut ready, ref mut ys) = *self.ys.borrow_mut();
if !*ready {
pre_calculate_ys(self.a, ys);
println!("Set ys to {:?}", ys);
*ready = true;
}
}
CacheVecGuard(self.ys.borrow())
}
fn clear_cache(&mut self) {
*(&mut self.ys.borrow_mut().0) = false;
self.x.set(None);
}
pub fn test(&self) -> f64 {
self.borrow_ys()[0] + self.get_x()
}
pub fn set_a(&mut self, a: f64) {
self.a = a;
self.clear_cache();
}
}
fn main() {
let mut foo = Foo::new(1.0);
println!("{}", foo.test());
foo.set_a(3.0);
println!("{}", foo.test());
}
It prints
Set ys to [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
Set x to 1
2
Set ys to [2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
Set x to 3
5
Playground

Answer 1

The fact that you need the ability to clear the cache means that you must have a guard. Otherwise, a call to set_a could invalidate a bare reference returned earlier by borrow_ys. The only way the compiler can verify that this doesn't happen is by returning a guard and borrowing from the guard instead.
If you can do away with the ability to clear the cache, you could use the LazyCell type from the lazycell crate instead.