trait Watcher {
    // We can implement it once there and implement special case for fsevents / pool
    fn update_watches(&mut self, ops: Vec<WatchOp>) -> std::Result<(), UpdateWatchesError>;

    // We could implement it with no breaking change in the trait, but the implementation
    // in that case would be really strange, like in the PR above, when the method returns 
    // a Box<dyn PathsMut<'me>> - a confusing signature (IMO)
    fn paths_mut<'me>(&'me mut self) -> PathsMut<'me>;
}

/// Error provided by [`Watcher::update_watches`]
pub struct UpdateWatchesError {
    
    /// What the operation by what the index caused the error
    pub error_on: (usize, WatchOp),
    
    /// The error
    pub error: Error,

    /// What operations haven't been applied
    pub rest: Vec<WatchOp>,
}

pub enum WatchOp {
    Watch(PathBuf, RecursiveMode),
    Unwatch(PathBuf),
}

/// Just a helper to call update_watches
pub struct PathsMut<'a> {
    ops: Vec<WatchOp>,
    watches: &'a mut dyn Watcher,
}

impl<'a> PathsMut<'a> {
    pub fn new<W: Watcher + 'a>(watcher: &'a mut W) { ... }
    pub fn watch(path: PathBuf, recursive_mode: RecursiveMode) { ... }
    pub fn unwatch(path: PathBuf) { ... }
    pub fn commit(self) -> std::Result<(), UpdateWatchesError> { 
        self.watcher.update_watches(self.ops)
    }
}