How to hierarchically organize expensive and dependant calculations that evaluate lazily?

I would like to construct something along the lines of the code below, which is an attempt at describing multiple related values which are expensive to compute. The computations are deterministic and tied to the value of Root, although I'd prefer to compute them only when necessary.

struct Root {
    cheap: i32,
    expensive1: Option<Expensive1>,
}
impl Root {
    pub fn new() {
        Root {cheap: 0, expensive1: None}
    }
    pub fn get_expensive_1(&self) -> &Expensive1{
        if self.expensive1.is_none() {
            self.expensive1 = Expensive1 {
                value: 1,
                expensive1_1: None,
                expensive1_2: None,
            }
        };
        &self.expensive1
    }
}

struct Expensive1 {
    value: i32,
    expensive1_1: Option<Expensive1x1>,
    expensive1_2: Option<Expensive1x2>,
}
impl Expensive1 {
    pub fn get_expensive1_1() -> &Expensive1x1 {}
    pub fn get_expensive1_2() -> &Expensive1x2 {}
}

struct ExpensiveN {
    value: i32
}

It seems only Root should have a new method, as the other values should be reached by some path starting with a Root value. As such, was aiming for an API similar to the one below.

let root = Root::new();
let deep = root.get_expensive1().get_expensive1_1().get_expensive1_1_1().get_expensive_n();

I've been able to implement all the methods on their own, although I'm having a horrendous time with ownership when trying establish a hierarchichal relationship between values as described above. Each getter is trying to mutate data when it's not available while returning a reference to it.

I've been playing around with Rc, RefCell, Box, get_or_insert_with, and various combinations of &self/&mut self, yet haven't been able to crack this one. Most of the errors encountered were not being able to mutate unmutable references or trying to return values from the getters error[E0515]: cannot return reference to temporary value.

Any suggestions on how to implement this?

You should use a OnceCell from the once-cell crate (soon to be stabilized into the standard library in the 1.70 release). It uses interior mutability in a way that it can only be set once (which is good for lazy evaluation) but can provide references to its inner value once set.

Here's how that'd look on the first layer:

use once_cell::unsync::OnceCell;

struct Root {
    cheap: i32,
    expensive1: OnceCell<Expensive1>,
}

impl Root {
    pub fn new() -> Root {
        Root {
            cheap: 0,
            expensive1: OnceCell::new(),
        }
    }

    pub fn get_expensive_1(&self) -> &Expensive1 {
        self.expensive1.get_or_init(|| {
            // expensive evaluation
            Expensive1 {
                value: 1,
                expensive1_1: OnceCell::new(),
                expensive1_2: OnceCell::new(),
            }
        })
    }
}

More on the playground.