I was writing some code where I was allocating groups of items into a single Vec. Specifically, I was building a computation graph. Feel free to skip, but for those interested in building some context around my question, here is the code that's building fully connected "dense" layer in a multi laye…

[image] mickvangelderen: EDIT: But how? Reserve some space out of paranoia re: set_len safety requirements and set the length even if it exceeds the number of elements present, taking care to never observe or drop the conjured ZSTs. Rust Playground A browser interface to the Rus…

I was exactly hoping to find other ideas so all takes are welcome! Use MaybeUninit<T>::write [image] quinedot: pub struct Spare<'a, T> { vec: NonNull<Vec<T>>, spare: &'a mut [MaybeUninit<T>], } If Spare::new constructs itself from NonNull<Vec<T>>, wouldn't it be a bit nicer to do tha…

[image] sharded-vec-writer Write parts of a Vec from different threads I believe this is solving the same issue (plus support for splitting the capacity into multiple chunks that can be distributed onto many diffrent threads). I have not yet tried it myself …

[image] mickvangelderen: If Spare::new constructs itself from NonNull<Vec<T>>, wouldn't it be a bit nicer to do that conversion on demand, assuming the compiler can optimizes things out mostly? I agree it's nicer to make the &mut [T] and &mut [MaybeUnint<T>] at the same time, but one of the r…

I'm not sure it's exactly a match, but this also seems to be the reason for the read_buf feature: BorrowedBuf in std::io - Rust There's equivalents in the async space that are getting figured out too.

Sorry for the long delay, I was on a road rip. The method of determining the len offset you shared is really neat, thanks! I have a follow up question about one of your latest samples where you modeled Spare as: pub struct Spare<'a, T> { len: &'a mut usize, spare: &'a mut [MaybeUninit<T>]…

[image] mickvangelderen: That type definition doesn't capture that when modifying len: &'a mut usize you MUST uphold the same safety requirements as Vec::set_len. I'm not sure that's even a problem but at first glance it seems like it to me, what do you think about this? Yeah, that is a requi…

Right, that makes sense. The same thing is true for the std's SetLenOnDrop I suppose. I'm not sure I see how to cause UB through &mut [MaybeUninit<T>] since you're not able to modify the original ptr/cap/len (and Vec::spare_capacity_mut existing), but your point still stands.

I wanted to try and write a const fn version of vec_len_offset. set_len is not const, so I figured we could try to use different values in the triplet and use capacity or len to inspect. The len implementation seems to currently only touch the len field so that seems ideal. /// Determines the offse…

[image] mickvangelderen: If the Vec::len implementation changes the above implementation may break/become UB. The UB concern is similar to how using set_len through a NonNull while the &mut _s are around is only sound so long as set_len doesn't "touch" the heap allocation, etc. I don't think …

[image] quinedot: I guess len could gain a debug library-UB check that breaks your build, like what I ran into with set_len. There's various possible things that one might want in len() that would actually depend on this. Like sometimes it would help for len() and/or capacity() to have a ass…

Safe API around splitting a `Vec<T>` into initialized elements and reserved capacity

help

mickvangelderen October 1, 2025, 11:27pm 23

Published under split-spare should anyone be interested.

Topic		Replies	Views
Reserve truly exact capacity for Vec	20	2341	July 17, 2024
`Vec::with_capacity` does not painc as the documentation says help	10	2048	May 19, 2022
How to cache a vector's capacity? help	60	2627	August 29, 2023
Guarantee that Vec::default() does not allocate? help	30	1486	November 20, 2022
Is `alloc` allowed to violate a methods safety requirements?	9	317	March 14, 2026

Safe API around splitting a `Vec<T>` into initialized elements and reserved capacity

Related topics