struct Rocket;
struct Actix;

trait Retriever<'a, Back> {
    type Value;
    fn get(&'a self) -> Self::Value;
}

struct Generator<G> {
    gen: G,
}

impl<'a, G, T> Retriever<'a, Rocket> for Generator<G> where G: Fn() -> T {
    type Value = T;
    fn get(&'a self) -> T {
        (self.gen)()
    }
}

impl<'a, G, T> Retriever<'a, Actix> for Generator<G> where G: Fn() -> T {
    type Value = T;
    fn get(&'a self) -> T {
        (self.gen)()
    }
}

struct Reference<'borrow, T> {
    reference: &'borrow T,
}

impl<'a, 'borrow, T> Retriever<'a, Rocket> for Reference<'borrow, T> {
    type Value = &'borrow T;
    fn get(&'a self) -> &'borrow T {
        self.reference
    }
}

impl<'a, 'borrow, T> Retriever<'a, Actix> for Reference<'borrow, T> {
    type Value = &'borrow T;
    fn get(&'a self) -> &'borrow T {
        self.reference
    }
}

trait WithRetriever<'a, I, R, Back> {
    fn run<T: Retriever<'a, Back, Value=I>>(&self, retriever: &'a T) -> R;
}

impl<'a, I, R, F, Back> WithRetriever<'a, I, R, Back> for Box<F> where F: Fn(I) -> R {
    fn run<T: Retriever<'a, Back, Value=I>>(&self, retriever: &'a T) -> R {
        self(retriever.get())
    }
}

fn double(a: u32) -> u32 {
    a * 2
}

fn double_ref(a: &u32) -> u32 {
    a * 2
}

fn main() {
    let a = Generator { gen: || 42 };
    let b = Reference { reference: &13 };

    println!("{}", Retriever::<'_, Rocket>::get(&a));
    println!("{}", Retriever::<'_, Actix>::get(&b));

    let c = Box::new(double);
    println!("{}", WithRetriever::<'_, _, _, Rocket>::run(&c, &a));

    let a = Generator { gen: || &42 };
    let d = Box::new(double_ref);
    println!("{}", WithRetriever::<'_, _, _, Rocket>::run(&d, &a));
    println!("{}", WithRetriever::<'_, _, _, Rocket>::run(&d, &b));
}