lazy loading solution

playground.rs

struct Context {
    foo: String,
    bar: String
}

struct ContextBuilder {
    foo: Option<String>,
    bar: Option<String>
}

impl ContextBuilder {
    fn new() -> Self {
        ContextBuilder {
            foo: None,
            bar: None
        }
    }

    fn load_foo(mut self) -> Self {
        if self.foo.is_none() {
            let message = String::from("foo");
            self.foo = Some(message);
        }

        self
    }

    fn load_bar(mut self) -> Self {
        if self.bar.is_none() {
            let message = String::from("bar");
            self.bar = Some(message);
        }

        self
    }
    
    fn build_context(self) -> Context {
        let r = self.load_foo()
            .load_bar();
        
        Context {
            foo: r.foo.unwrap(),
            bar: r.bar.unwrap()
        }
    }
}

fn print(context: &Context) {
    let foo = &context.foo;
    let bar = &context.bar;

    println!("{}{}", foo, bar);
}

fn main() {
    let context = ContextBuilder::new()
        .build_context();

    print(&context);
}