The asker is building a zero-copy asynchronous parser in Rust. The idea is straightforward in concept: read bytes from an async reader into an internal buffer, parse them in place, and then yield references to the parsed data through a Stream. The critical constraint is "no cloning"—they want true zero-copy semantics where consumers borrow directly from the parser's internal buffer.

This is one of Rust's hardest problems at the intersection of three notoriously tricky areas: self-referential structs, pinning, and async iteration.

The fundamental tension is this: the standard Stream trait (from futures) defines poll_next to return Poll<Option<Self::Item>>, where Item is an associated type with no lifetime tied to self. This means you cannot return a reference that borrows from the stream's own internal buffer. The item must be owned or must borrow from something with an independent lifetime. This is the same limitation that prevents Iterator from yielding references to its own state—often called the "lending iterator" problem.

The asker mentions GATs (Generic Associated Types) as a potential solution. In theory, a lending stream trait could look like:

trait LendingStream {
    type Item<'a> where Self: 'a;
    fn poll_next(self: Pin<&mut Self>, cx: &mut Context)
        -> Poll<Option<Self::Item<'_>>>;
}

This would let Item borrow from self. However, there are significant practical obstacles:

• No ecosystem support. The futures and tokio-stream ecosystems are built around the non-lending Stream. Adaptors like .map(), .filter(), and StreamExt won't work with a custom lending trait.
• Pin projection complexity. The internal buffer must be pinned so that references into it remain valid across poll_next calls. Getting pin projections right—especially when the buffer might need to grow or shift data—is extremely error-prone.
• Invalidation on read. When new data is read into the buffer, previously yielded references could be invalidated if the buffer reallocates. You must guarantee that no outstanding borrows exist when the buffer is mutated, which the borrow checker enforces but makes the API awkward.

A pragmatic approach is to sidestep the lending problem entirely: use a shared buffer behind Bytes (from the bytes crate), which provides zero-copy slicing through reference counting. Each yielded chunk is a Bytes slice into the original allocation—owned, cheaply cloneable, and no lifetime entanglement. This is the pattern used by hyper, tonic, and most production Rust async I/O.

If true lending semantics are essential, the lending-stream or gat-lending-iterator crates offer experimental traits, but be prepared to write your own combinators.