fn put(mutex: &Mutex<EventBuffer<String>>, debouncer: &JoinHandle<()>, data: String) {
    mutex.lock().unwrap().put(data);
    debouncer.thread().unpark();

struct EventDebouncer<T> {
    mutex: Arc<Mutex<EventBuffer<T>>>,
    thread: JoinHandle<()>,

fn get(mutex: &Mutex<EventBuffer<String>>) -> State<String> {
    mutex.lock().unwrap().get()

impl<T: PartialEq> EventDebouncer<T> {
    fn new<F>(timeout: Duration, f: F) -> Self
    where
        F: Fn(T) -> (),
        F: Send + 'static,
        T: Send + 'static,
    {
        let mutex = Arc::new(Mutex::new(EventBuffer::new(timeout)));
        let mutex_clone = mutex.clone();
        let thread = thread::spawn(move || loop {
            let state = { mutex_clone.lock().unwrap().get() };
            match state {
                State::Empty => thread::park(),
                State::Wait(duration) => thread::sleep(duration),
                State::Ready(data) => f(data),
            }
        });
        Self { mutex, thread }
    }
    fn put(&self, data: T) {
        self.mutex.lock().unwrap().put(data);
        self.thread.thread().unpark();
    }

    let mutex = Arc::new(Mutex::new(EventBuffer::new(Duration::from_millis(timeout))));
    let mutex_clone = mutex.clone();
    let mut stdout = io::stdout();

    let debouncer = thread::spawn(move || loop {
        match get(&mutex_clone) {
            State::Empty => thread::park(),
            State::Wait(duration) => thread::sleep(duration),
            State::Ready(data) => {
                stdout.write_all(data.as_bytes()).ok();
            }
        }

    let debouncer = EventDebouncer::new(Duration::from_millis(timeout), move |data: String| {
        io::stdout().write_all(data.as_bytes()).ok();

        put(&mutex, &debouncer, buffer);

        debouncer.put(buffer);