Allow lifetime polymorphism in local bindings

[lambda-fairy]

The following example doesn't compile in current Rust:

fn main() {
    let id = |x: &i32| x;
    {
        let a: Box<i32> = Box::new(42);
        id(&a);
    }
    {
        let b: Box<i32> = Box::new(43);
        id(&b);
    }
}

This is because a and b have non-overlapping lifetimes, so id cannot be fixed to either of them.

The typical solution is to lift id into a fn, making the lifetime parameter polymorphic:

fn id<'a>(x: &'a i32) -> &'a i32 { x }
// ...

But then we lose the ability to close over the environment.

Ideally, I'd like the compiler to accept something like this:

let id = for<'a> |x: &'a i32| -> &'a i32 { x };

that is, a closure which is polymorphic over the lifetime rather than fixed to a particular one.

[eefriedman]

The following works on master:

fn main() {
    fn id_type<T: Fn(&i32) -> &i32>(t: T) -> T { t }
    let id = id_type(|x: &i32| x);
    {
        let a: Box<i32> = Box::new(42);
        id(&a);
    }
    {
        let b: Box<i32> = Box::new(43);
        id(&b);
    }
}

I see two issues: one, rustc is terrible at inferring lifetimes for closures (rust-lang/rust#28092 rust-lang/rust#26937 etc.). Two, it would be nice to have more direct syntax for explicitly specifying the lifetimes you want.