Ask many permits at one time on an mpsc::channel

[Totodore]

I'm in a case where I need to serialize, then send multiple values across an mpsc::channel which is managed by another function.
The only solution I found is with the Permit API is to ask n permits and then give a Vec<Permit> to my function that handles the channel but it allocates a Vec so it is quite bad...

Otherwise my solution is to have a raw Semaphore field next to my channel to track sending permission.
Overall, would it be possible to have a reserve_many fn added to the mpsc::channel struct ?

Something like this :

pub struct ManyPermit<'a, T> {
	chan: &'a chan::Tx<T, Semaphore>,
	n: u32
}

pub fn try_reserve_many(&self, n: u32) -> Result<ManyPermit<'_, T>, TrySendError<()>> {
      match self.chan.semaphore().semaphore.try_acquire(n) {
          Ok(()) => {}
          Err(TryAcquireError::Closed) => return Err(TrySendError::Closed(())),
          Err(TryAcquireError::NoPermits) => return Err(TrySendError::Full(())),
      }

      Ok(ManyPermit { chan: &self.chan, n })
}

impl<T> ManyPermit<'_, T> {
    pub fn send(&mut self, value: T) {
		if self.n > 0 {
        	self.chan.send(value);
			self.n -= 1;
		}
    }
}

impl<T> Drop for ManyPermit<'_, T> {
    fn drop(&mut self) {
        use chan::Semaphore;

        let semaphore = self.chan.semaphore();

        // Add the remaining permits back to the semaphore
        semaphore.add_permits(self.n as usize);

        // If this is the last sender for this channel, wake the receiver so
        // that it can be notified that the channel is closed.
        if semaphore.is_closed() && semaphore.is_idle() {
            self.chan.wake_rx();
        }
    }
}