5
fn main() {
    let _ref_in_ref_out = |var: &i64| var;
}

This does not compile:

error: lifetime may not live long enough
 --> src/main.rs:2:39
  |
2 |     let _ref_in_ref_out = |var: &i64| var;
  |                                 -   - ^^^ returning this value requires that `'1` must outlive `'2`
  |                                 |   |
  |                                 |   return type of closure is &'2 i64
  |                                 let's call the lifetime of this reference `'1`

Apparently the compiler infers two different lifetimes (for the argument and the return type), instead of it being the same.

Is it possible to write a closure so that the input lifetime is the same as the output lifetime?

Something like

fn ref_in_ref_out<'a> (var: &'a i64) -> &'a i64  { var }

but as a closure

jm4ier
  • 237
  • 2
  • 7

2 Answers2

10

Lifetime elisions rules do not apply to closures, neither can you explicitly specify lifetimes for closures. There are several ways to make this code work, though.

The easiest solution is to simply omit the type annotations and let the compiler infer everything:

let ref_in_ref_out = |var| var;
let i: i64 = 42;
ref_in_ref_out(&i);

Alternatively, it's actually fine to specify the return type. This compiles:

let _ref_in_ref_out = |var| -> &i64 { var };

Yet another option for the case that your closure does not close over any local variables is to convert it to a function pointer, since lifetime elision rules apply to function pointers:

let ref_in_ref_out: fn(&i64) -> &i64 = |var| var;

And finally the most general solution is to use a helper function to apply a function trait bound to your closure:

fn constrain_closure<F: Fn(&i64) -> &i64>(f: F) -> F {
    f
}

let _ref_in_ref_out = constrain_closure(|var| var);
Sven Marnach
  • 574,206
  • 118
  • 941
  • 841
1

I've just found out a way to solve this issue, but It'd be great if there is an easier solution:

fn infer_lifetime<'a, T: 'a, F: Fn(&'a T) -> &'a T>(f: F) -> F {
    f
}

fn main() {
    let _ref_in_ref_out = infer_lifetime(|var: &i64| var);
}
jm4ier
  • 237
  • 2
  • 7
  • 2
    Note that this would also compile without the explicit lifetime paramter, but you'd get the more general bound `for<'a> Fn(&'a i64) -> &'a i64` for the closure. The code in this answer results in a closure that works for one specific, inferred lifetime. Relying on lifetime elision results in a closure that works for any lifetime `'a`, so the closure can be called with different lifetimes. – Sven Marnach Sep 11 '20 at 09:26