Thread supervisor with restarts

main.rs

#[derive(Debug, Clone, Copy)]
enum ThreadState {
    Unstarted,
    Panicked,
    Success,
}

fn main () {
    let x = Arc::new(Mutex::new(ThreadState::Unstarted));

    let run = |f: fn() -> ()| {
        let x2 = Arc::clone(&x);
        let x3 = Arc::clone(&x);
        thread::spawn(move || {
            panic::set_hook(Box::new(move |_| {
                *x2.lock().unwrap() = ThreadState::Panicked;
            }));

            f();

            *x3.lock().unwrap() = ThreadState::Success;
        });
    };

    let do_work = || {
        sleep(Duration::from_secs(3));
        if *[true, false].choose(&mut thread_rng()).unwrap() {
            panic!("Oops");
        } else {
            println!("Success");
        }
    };
    run(do_work);

    loop {
        let value = {
            *x.lock().unwrap()
        };
        match value {
            ThreadState::Panicked => {
                println!("Thread panicked. Restarting...");
                *x.lock().unwrap() = ThreadState::Unstarted;
                run(do_work);
            }
            ThreadState::Success => {
                println!("Supervision done. Exiting...");
                break;
            }
            _ => {
                println!("Waiting...");
            }
        }
        sleep(Duration::from_secs(1));
    }
}