let receiver: Receiver = ...;
let mut buf = [0; 1024]; // allocate a buf that is definitely too big
let bytes_received = reciever.recv(&mut buf);

这是我见过的一种比较常见的模式。要访问数据，我们可能会做如下操作

let data = buf[0..bytes_received];

这是一个很好的模式，但我的问题是我们总是将整个数组清零，即使我们不需要。这不是一个昂贵的操作，但总是忽略它似乎很奇怪。
我建议的另一个选择是

use std::mem::{MaybeUninit, transmute};

struct Receiver {
    // just for demonstration...
    data: &'static str, 
}

trait Receive {
    // this is the only required method, since `recv` can be derived from it
    fn recv_maybe_uninit(&mut self, buf: &mut [MaybeUninit<u8>]) -> &[u8];
    
    fn recv(&mut self, buf: &mut [u8]) -> usize {
        self.recv_maybe_uninit(unsafe { transmute(buf) }).len()
    }
}

impl Receive for Receiver {
    fn recv_maybe_uninit(&mut self, buf: &mut [MaybeUninit<u8>]) -> &[u8] {
        for (i, byte) in self.data.as_bytes().iter().enumerate() {
            buf[i] = MaybeUninit::<u8>::new(*byte);
            if i == buf.len() {
                return unsafe { transmute(buf) }
            }
        }
        unsafe { transmute(&buf[0..self.data.as_bytes().len()]) }
    }
}

fn main() {
    let mut receiver = Receiver {
        data: "Hello, world!",
    };
    let mut buf = [MaybeUninit::uninit(); 1024];
    let data = receiver.recv_maybe_uninit(&mut buf);

    println!("{:?}", std::str::from_utf8(data).unwrap());
}

如果recv_maybe_uninit是默认值，我们可以很容易地推导出recv！
也许更好的实现是让缓冲区实现一个trait，允许向其中写入u8...
不管怎么说，为什么不用这种风格呢？