impl<'a> From<&'a CommonMetrics> for HandlerMetricsImpl<'a> {
    fn from(metrics: &'a CommonMetrics) -> HandlerMetricsImpl<'a> {
        HandlerMetricsImpl{cm: metrics}
    }
}

// impl From<&CommonMetrics> for HandlerMetricsImpl2 {
//     fn from(metrics: &CommonMetrics) -> HandlerMetricsImpl2 {
//         HandlerMetricsImpl2
//     }
// }

trait CommonMetrics {}
struct CommonMetricsImpl;
impl CommonMetrics for CommonMetricsImpl {}

trait Dispatcher<Metrics> {
    fn dispatch(&self, metrics: Metrics, val: u64);
}
struct DispatcherImpl<Metrics>(Box<dyn Handler<Metrics>>);
impl<Metrics1> Dispatcher<Metrics1> for DispatcherImpl<Metrics1> where Metrics1: CommonMetrics
{
    fn dispatch(&self, metrics: Metrics1, val: u64) {
        // match val {
        //     0 => self.0.handle(metrics),
        //     _ => self.1.handle(metrics),
        // }
        self.0.handle(metrics); // This doesn't work, why? type inference issue?
    }
}

trait HandlerMetrics {}
struct HandlerMetricsImpl<'a> {
    cm: &'a CommonMetrics,
}

impl<'a> HandlerMetrics for HandlerMetricsImpl<'a> {}

trait Handler<Metrics> {
    fn handle(&self, metrics: Metrics);
}
struct HandlerImpl;
impl<Metrics2> Handler<Metrics2> for HandlerImpl where Metrics2: HandlerMetrics
{
    fn handle(&self, metrics: Metrics2) {}
}

// trait HandlerMetrics2 {}
// struct HandlerMetricsImpl2;
// impl HandlerMetrics2 for HandlerMetricsImpl2 {}

// trait Handler2<Metrics> {
//     fn handle(&self, metrics: Metrics);
// }
// struct HandlerImpl2;
// impl<Metrics2> Handler2<Metrics2> for HandlerImpl2 where Metrics2: HandlerMetrics2
// {
//     fn handle(&self, metrics: Metrics2) {}
// }

// fn main() {
//     let handler = HandlerImpl;
//     handler.handle(HandlerMetricsImpl); // This works
    //
    // let handler = Box::new(HandlerImpl);
    // let handler2 = Box::new(HandlerImpl2);
    // let dispatcher: Dispatcher<_: ?Sized> = DispatcherImpl(handler, handler2);
// }