Efficiently reusing unwrapped Option variable based on a condition in Rust

I have an Option variable pb in Rust that I need to use in multiple parts of my code. However, I don't want to repeat the unwrapping logic each time I access pb to obtain the unwrapped value, when I now once the variable progress_var_on is true, pb should have a value. Is there a clean and efficient way to unwrap pb once and use the unwrapped value throughout my code without cluttering it with repeated match statements?

Here is an example:

// ...

let pb = if progress_bar_on {
  // ...
  Some(tmp_pb)
} else {
  None
}

if progress_bar_on {
  pb.unwrap().update_var();
  pb.unwrap().set_val();
}

// more code
// ...

if progress_bar_on {
  pb.unwrap().set_val();
}

// more code
// ...

if progress_bar_on {
  pb.unwrap().update_var();
}

Something I just learn, and it feels cleaner is the next:

if let Some(pb) =
    progress_bar_on.then(|| pb.unwrap())
{
    pb.set_style(style_overall);
    pb.set_message("Copying files...");
    pb.set_length(src_n_files);
}

Is this the cleanest way? or there is a better way?
Any insights or suggestions would be highly appreciated. Thank you!

You're essentially converting the boolean progress_bar_on into an Option, so you should use the Option.

if let Some(pb) = pb {
    pb.update_var();
}

However, this is still not very clean and still has to do a check every time pb will be used. The robust way to is to make a trait.

trait ProgressBar: Default {
    fn update_var(&mut self);
    fn set_val(&mut self);
}

#[derive(Default)]
struct RealProgressBar {
    progress: u32,
}

impl ProgressBar for RealProgressBar {
    fn update_var(&mut self) {
        // Some real work
        self.progress += 1;
    }

    fn set_val(&mut self) {
        // Some real work
        self.progress = 0;
    }
}

#[derive(Default)]
struct DummyProgressBar;

// This does nothing when used as a progress bar
impl ProgressBar for DummyProgressBar {
    fn update_var(&mut self) {}
    fn set_val(&mut self) {}
}

// Public-facing function
pub fn do_operation(progress_bar_on: bool) {
    // Convert the runtime boolean into a compile-time trait impl
    if progress_bar_on {
        do_operation_progress::<RealProgressBar>()
    } else {
        do_operation_progress::<DummyProgressBar>()
    }
}

// Private function that has all the logic. It can unconditionally
// call methods on the progress bar.
fn do_operation_progress<P: ProgressBar>() {
    let mut pb = P::default();

    // some code

    pb.update_var();

    // some more code

    pb.set_val();
}