#![feature(exit_status_error)]

#![feature(exit_status_error, binary_heap_retain)]

#[derive(PartialEq)]

const DELAY: Duration = Duration::from_millis(500);
#[derive(PartialEq, Eq)]

    let mut debouncer = Debouncer::new(Duration::from_millis(500));

    let mut debouncer = Debouncer::new();

        debouncer.new_events(inotify.read_events_blocking(&mut buffer)?.map(File::from));

        for event in inotify.read_events_blocking(&mut buffer)? {
            debouncer.put(File::from(event), DELAY)
        }

            debouncer.new_events(inotify.read_events(&mut buffer)?.map(File::from));

            for event in inotify.read_events(&mut buffer)? {
                debouncer.put(File::from(event), DELAY)
            }

use std::cmp::PartialEq;

use std::cmp::Ordering;
use std::collections::BinaryHeap;

#[derive(Debug)]

#[derive(Debug, PartialEq, Eq)]

    time: Instant,

    release_at: Instant,
}
impl<T: Eq> Ord for Event<T> {
    fn cmp(&self, other: &Self) -> Ordering {
        other.release_at.cmp(&self.release_at)
    }
}
impl<T: Eq> PartialOrd for Event<T> {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }

    delay: Duration,
    events: Vec<Event<T>>,

    events: BinaryHeap<Event<T>>,

impl<T: PartialEq> Debouncer<T> {
    pub fn new(delay: Duration) -> Debouncer<T> {

impl<T: Eq> Debouncer<T> {
    pub fn new() -> Debouncer<T> {

            delay,
            events: vec![],

            events: BinaryHeap::new(),

    pub fn new_events<I: Iterator<Item = T>>(&mut self, mut items: I) {

    pub fn put(&mut self, item: T, delay: Duration) {

        let cutoff = time - self.delay;
        while let Some(item) = items.next() {
            self.events.retain(|e| e.time < cutoff || e.item != item);
            self.events.push(Event { item, time });
        }

        self.events
            .retain(|e| e.release_at <= time || e.item != item);
        self.events.push(Event {
            item,
            release_at: time + delay,
        });

        let cutoff = time - self.delay;
        match self.events.get(0) {

        match self.events.peek() {

            Some(e) if e.time > cutoff => State::Wait(e.time - cutoff),
            Some(_) => State::Ready(self.events.remove(0).item),

            Some(e) if e.release_at > time => State::Wait(e.release_at - time),
            Some(_) => State::Ready(self.events.pop().unwrap().item),