Consider implementing Deref on Yoke where possible

[Manishearth]

Currently, to access the yoked object, Yoke has a .get() method, and does not implement Deref.

In the general case this makes sense: if the yoked object is e.g. (String, &str, Cow<str>), the signature of Deref will just not work since the output object needs to be &'a (String, &'a str, Cow<'a, str>), and the signature of Deref admits precisely one Target type.

OTOH for "normal" dereffable yoked types like &T and Cow<T> where T: 'static we actually can expose Deref to produce an &T if we want.

The impl we want looks somewhat like this:

impl<Y, C> Deref for Yoke<Y, C>
   where Y: for<'a> Yokeable<'a>, 
               Y: Deref;
               for<'a> <Y as Yokeable<'a>>::Output: Deref,
                // given how Yokeable works, this implies that the target types are all the same:
               for<'a> <<Y as Yokeable<'a>>::Output as  Deref>::Target: 'static,
{
    type Target: <Y as Deref>::Target;
    fn deref(&self) -> &Self::Target {
        self.get().deref()
    }
}

the annoying bit is that self.get().deref() has the return type &<<Y as Yokeable<'a>>::Output as Deref>::Target which the compiler cannot prove is the same as &<Y as Deref>::Target. We know it is, but the compiler doesn't.

We could do an unsafe cast here, but I'm not actually 100% sure that that is safe here (or the precise bounds needed for safety) given the valid ways to implement Yokeable and Deref. I can think about it more and get a definitive answer here.

We could also expose an unsafe trait DerefYokeable: for<'a> Yokeable<'a> + Deref that we manually implement on some known dereffy types that have 'static contained values.

[Manishearth]

cc @sffc for thoughts

[sffc]

I think we should only implement Deref if it is free. We know from experience that .get() is not free, at least not for the Cow-like types we use a lot in ICU4X. I think we should understand that performance bottleneck better first.

However, I'm fine implementing Deref where possible if we can verify that it's not a performance footgun.

[Manishearth]

We know from experience that .get() is not free

I'm not actually convinced of this: I haven't seen this in play.

Note that .deref() on Cow is not free either, what we might be seeing is that cost.

[Manishearth]

In particular, for any type with a derived Yokeable, Yoke::get() is an inline function that calls an inline function whose body is simply returning its &T parameter or doing a transmute, either way it should be a free function from LLVM's POV.

OTOH Cow::deref() is a branch, and ZeroVec::deref() used to be a branch until #2599, which definitely happened after we did any benchmarking around this

[sffc]

Yep, I'm convinced.