/*
I want make_closure to create a boxed closure which can accept an  &i32
reference with any lifetime, convert it to a T, and perform further processing
on that T. It must be possible for T to be another &i32 with the same lifetime
as the input &i32, i.e., it must be possible for the "conversion" to be a
no-op.
*/

fn make_closure<'a, T>() -> Box<dyn Fn(&'a i32)>
where
    T: 'a + std::fmt::Debug + CreateFromI32Ref<'a>
{
    Box::new(move |i32_ref: &i32| {
        T::create_from_i32_ref(i32_ref).process()
    })
}

trait CreateFromI32Ref<'a>: Sized {
    fn create_from_i32_ref(i32_ref: &'a i32) -> Self;
    fn process(self) {
        println!("processing...")
    }
}

impl<'a> CreateFromI32Ref<'a> for i32 {
    fn create_from_i32_ref(i32_ref: &'a i32) -> i32 {
        *i32_ref
    }
}

impl<'a> CreateFromI32Ref<'a> for &'a i32 {
    fn create_from_i32_ref(i32_ref: &'a i32) -> &'a i32 {
        i32_ref
    }
}

/*
It seems self-evident that CreateFromI32Ref is implemented for all possible
`&'a i32` types, but the second make_closure fails to compile, with the error
"the trait `for<'a> CreateFromI32Ref<'a>` is not implemented for `&i32`"
*/

fn main() {
    make_closure::<i32>()(&100i32);
    make_closure::<&i32>()(&100i32);
}