How to add lifetime bounds to the hrtb, and which ones? - rust

Question

I cannot use a concrete type for my struct generic parameter:
struct Foo<'a, T: 'a, K: 'a, F>
where
for<'r> F: Fn(&'r T) -> K,
{
t: &'a T,
k: K,
f: F,
}
impl<'a, T: 'a> Foo<'a, T, &'a T, for<'r> fn(&'r T) -> &'r T> {
//
}
I think I must add more information the the hrtb generic function, but I cannot figure out what:
error[E0308]: mismatched types
--> src/lib.rs:10:17
|
10 | impl<'a, T: 'a> Foo<'a, T, &'a T, for<'r> fn(&'r T) -> &'r T> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ lifetime mismatch
|
= note: expected associated type `<for<'r> fn(&'r T) -> &'r T as FnOnce<(&T,)>>::Output`
found associated type `<for<'r> fn(&'r T) -> &'r T as FnOnce<(&'r T,)>>::Output`
note: the required lifetime does not necessarily outlive the lifetime `'a` as defined here
--> src/lib.rs:10:6
|
10 | impl<'a, T: 'a> Foo<'a, T, &'a T, for<'r> fn(&'r T) -> &'r T> {
| ^^
note: the lifetime requirement is introduced here
--> src/lib.rs:3:29
|
3 | for<'r> F: Fn(&'r T) -> K,
| ^
What is frustrating is that if my function returns a reference, it works correctly:
struct Foo<'a, T: 'a, K: 'a, F>
where
for<'r> F: Fn(&'r T) -> &'r K,
{
t: &'a T,
k: K,
f: F,
}
impl<'a, T: 'a> Foo<'a, T, T, for<'r> fn(&'r T) -> &'r T> {
//
}
because then the type for K isn't tied to a specific lifetime. I wonder if I can do that somehow when I return K instead of & 'r K.

Answer 1

In your trait definiton you tell the compiler that F returns a K which outlives 'a (K: 'a in the generic).
So all you have to do is return something outliving the associated lifetime 'a from your impl:
struct Foo<'a, T: 'a, K: 'a, F>
where
for<'r> F: Fn(&'r T) -> K,
{
t: &'a T,
k: K,
f: F,
}
impl<'a, T: 'a> Foo<'a, T, &'a T, for<'r> fn(&'r T) -> &'a T> {
//
}
But it will probably be hard to generate something of lifetime 'a when all you get is something of lifetime 'r which does not have any bounds.
Maybe you don't want HRTBs after all:
struct Foo<'a, T: 'a, K: 'a, F>
where
F: Fn(&'a T) -> K,
{
t: &'a T,
k: K,
f: F,
}
impl<'a, T: 'a> Foo<'a, T, &'a T, fn(&'a T) -> &'a T> {
//
}