Add inner (and maybe also into_inner) methods to Full.

[plugwash]

I was porting some code from the http 0.2 stack to the http 1 stack and for bodies stored in memory, I largely replaced the "Body" type by "Full"

However one wrinke I ran into was there does not seem to be a good way to turn a Full<Bytes> back into it's contents without using "await", this in turn ended up with marking several functions as async when they were not previously.

Is there any chance of adding Inner or Into-inner methods to Full to allow accessing the inner value?

[cratelyn]

hi @plugwash, thank you for filing an issue. i'm not convinced that it would be possible to provide interfaces for convert a "boxed" body back to the original type via and into_inner() method. if we examine the definition of BoxBody<D, E>...

/// A boxed [`Body`] trait object.
pub struct BoxBody<D, E> {
    inner: Pin<Box<dyn Body<Data = D, Error = E> + Send + Sync + 'static>>,
}

we can see that the inner type is no longer known. this is sometimes called "type erasure", to provide a search term that can be helpful for finding more information on this concept. another commonly-used library in the Rust ecosystem that relies upon this mechanism is anyhow, which provides facilities to box errors.

the catch, however, is that this erasure is a feature, rather than a bug. the explicit intent of interfaces that rely on type erasure (like BoxBody or anyhow::Error) is allowing code to use different types (such as Full<Bytes>) that implement a given interface (like Body) without needing to be generic across a type parameter.

so, we can't implement an into_inner() function because the original type is no longer visible to BoxBody, by design.

one alternative i checked out was the possibility of exposing something like Box::downcast(), allowing callers to provide a type parameter to specify what concrete type to attempt downcasting to. unfortunately, that type is bounded upon T: Any. we wouldn't be able to invoke that for the box body's inner Pin<Box<dyn Body<Data = D, Error = E> + Send + Sync + 'static>> field, and adding Any there would be a breaking change.

[seanmonstar]

You mention Full<B> in the description, but BoxBody in the title. Which one were you hoping for? If it's BoxBody, I completely agree with @cratelyn. If you did mean Full, we probably could add something there.

[cratelyn]

i'll second that, i wouldn't object to introducing the following to Full<D>:

impl<D> Full<D> {
    fn inner(&self) -> Option<&D> {
        // ...
    }

    fn into_inner(&self) -> Option<D> {
        // ...
    }
}

the need for Option<T>'s in those signatures feels slightly unfortunate, but seems reasonable enough to me. what do you think?

[plugwash]

You mention Full<B> in the description, but BoxBody in the title. Which one were you hoping for?

It was Full<B> I was looking for. Title was a mistake.

[cratelyn]

i've opened #155, which is marked as fixing this issue. i'll note that this only adds an Full::into_inner(), and does _notadd anFull::inner()` method.

this matches the style of [many interfaces][into-inner-docs] offered by various types provided in core and std such as Box<T>, Arc<T>, Mutex<T>, as well as [many interfaces][tokio-into-inner-docs] offered by various types in tokio such as BufWriter<T>, OnceCell<T>, and so forth.

while looking at other middleware types across the rust ecosystem however, i found that other types in std and tokio do not generally expose an inner(). idiomatically, once a chunk is placed into a Full<T> it should be thought of as a Body rather than a T. subjectively, i believe that inner() would make this a leaky abstraction, and break from these general conventions.