use std::collections::{HashMap};
use std::path::PathBuf;

type Predicate = Fn(PathBuf, PathBuf) -> bool;
type Callback = Fn(PathBuf, i32) -> ();

struct WatcherBuilder<'a> {
    callbacks: HashMap<&'static str, (&'a Predicate, &'a Callback)>,
}

impl<'a> WatcherBuilder<'a> {
    fn new() -> WatcherBuilder<'a> {
        return WatcherBuilder {
            callbacks: HashMap::new(),
        };
    }

    fn add_callback<P, C>(&mut self, predicate: &'a P, callback: &'a C) -> &mut Self
    where
        P: 'static + Fn(PathBuf, PathBuf) -> bool,
        C: 'static + Fn(PathBuf, i32) -> (),
    {
        self.callbacks.insert("a", (predicate, callback));

        return self;
    }
}

fn main() {
    let predicate = |path_1: PathBuf, path_2: PathBuf| path_1 == path_2;
    let callback = |path: PathBuf, diff: i32| println!("{} {}", 1, 2);

    let mut watcher = WatcherBuilder::new()
        .add_callback(&predicate, &callback);
}