trait Tr {}
impl<'a> Tr for &'a u8 {}
trait Test {
fn f();
}
impl Test for u64
where
for<'a> &'a u8: Tr
{
fn f() {}
}
fn main() {
// confirm that the bound for<'a> &'a u8: Tr is satisfied.
u64::f()
}
But this doesn't compile, with the message error[E0599]: no function or associated item named ``f`` found for type ``u64`` in the current scope:
trait Tr {}
impl<'a> Tr for &'a u8 {}
trait Test {
fn f();
}
trait L<'a> {
type T;
}
impl<'a> L<'a> for u64 {
type T = &'a u8;
}
impl Test for u64
where
for<'a> <u64 as L<'a>>::T: Tr
{
fn f() {}
}
fn main() {
// this won't compile, apparently because for<'a> <u64 as L<'a>>::T: Tr is not
// satisfied.
u64::f()
}
This is hard to understand because it seems like the types <u64 as L<'a>>::T and &'a u8 are identical. Any suggestions?
That's really unfortunate. It seems that for every language I've used with a fancy type system, it's impossible to actually do any of the fancy stuff without slamming up against the system's limitations, whether those limitations are by design or are bugs.
I now have so many instances where I want to do something with lifetimes that seems natural to me, but it doesn't work, and so I have to throw away the lifetime approach and use closures instead.
Yeah, I hear you. This is actually one of my main concerns with Rust at the moment.
In the example code here, switching to L<'a, T> (instead of associated type) seems to work but you’d need to implement Tr for all types that you’d use as a bound on T in L<'a, T>. Needless to say, not great (and may not jive with your real code).