Cache results in computational graph

/* Implementation of a computational graph with
 * caching and reused computation.
 *         - -
 *       /     \
 * a - b - c    \
 * | \    \  \   |
 *  \  d - e  |  |
 *   \      \ |  |
 *     - - - f - g
 */


#[derive(Debug)]
pub struct ResultsA{}

#[derive(Debug)]
pub struct ResultsB{}

#[derive(Debug)]
pub struct ResultsC{}

#[derive(Debug)]
pub struct ResultsD{}

#[derive(Debug)]
pub struct ResultsE{}

#[derive(Debug)]
pub struct ResultsF{}

#[derive(Debug)]
pub struct ResultsG{}


fn a() -> ResultsA {
    ResultsA {}
}

fn b(_a:&ResultsA) -> ResultsB {
    ResultsB {}
}

fn d(_a:&ResultsA) -> ResultsD {
    ResultsD {}
}

fn c(_b:&ResultsB) -> ResultsC {
    ResultsC {}
}

fn e(_b:&ResultsB, _d:&ResultsD) -> ResultsE {
    ResultsE {}
}

fn f(_c:&ResultsC, _e:&ResultsE) -> ResultsF {
    ResultsF {}
}

fn g(_b:&ResultsB, _f:&ResultsF) -> ResultsG {
    ResultsG {}
}


pub fn direct_compute() -> ResultsG {
    g(&b(&a()), &f(&c(&b(&a())), &e(&b(&a()), &d(&a()))))

}

struct Cache {
    a:Option<ResultsA>,
    b:Option<ResultsB>,
    c:Option<ResultsC>,
    d:Option<ResultsD>,
    e:Option<ResultsE>,
    f:Option<ResultsF>,
}


impl Cache {
    fn new() -> Cache{
        Cache {a:None, b:None, c:None, d:None, e:None, f:None}
    }
}


pub fn cached_compute() -> ResultsG {
    let mut cache = Cache::new();

    let _a = a();

    cache.a = Some(_a);

    let _b = b(cache.a.as_ref().unwrap());
    let _d = d(cache.a.as_ref().unwrap());

    cache.b = Some(_b);
    cache.d = Some(_d);

    let _c = c(cache.b.as_ref().unwrap());
    let _e = e(cache.b.as_ref().unwrap(), cache.d.as_ref().unwrap());

    cache.c = Some(_c);
    cache.e = Some(_e);

    let _f = f(cache.c.as_ref().unwrap(), cache.e.as_ref().unwrap());

    cache.f = Some(_f);

    g(cache.b.as_ref().unwrap(), cache.f.as_ref().unwrap())
}


fn main() {
    println!("{:?}", direct_compute());
    println!("{:?}", cached_compute());
}