So I’ve been writing an allocator. A difficult task and in Rust it is currently a dream to write.
The patterns I’m on about are small quick scopes to get a mutable reference and store or read data.
pub fn some_func(&mut self, s: &[u8]) {
// Mutable borrow 1 and write
{
let writable = &mut self.buf[..8];
writable[..8].copy_from_slice();
}
// Mutable borrow 2 and write
{
let writable = &mut self.buf[8..16];
writable[8..16].copy_from_slice();
}
// And so on . . .
}
No other language feels like this. No other language is so precise on reads and writes always taking a length or the length can be obtained from the type (such as a slice).
Writing to different parts of a buffer and selecting parts of like this feels amazing. For writing an allocator i can just make array’s and then write any bytes to them and just read them back and cast them about.
So much better than just using raw pointers, and safer as sizes are usually know with slices.
Anyway i just love Rust and this was an excuse to share my love of Rust <3
If possible, I’m sure this community would love reading a blog post about exactly this.
Myself, I’m in uni and don’t really have time to make new projects in rust and would greatly appreciate to read what you have to say about this :)
Here is an update. I focused on the Node which is the smallest element of the buffer, it is what contains any meta data and the data payload. The code is heavily reduced but what is shared is pretty much verbatim maybe some minor edits
Update on the Node for my allocator
I find it really charming how i can sort of see what you’re doing even though I’m a complete beginner in this language and we’re talking about allocators :^).
That said, the update is greatly appreciated.
Ah, got it—let me clarify a bit.
Right now, I’m working with arrays and slicing them into smaller segments for indexing. Technically, I could rely on bit manipulation to generate much of this, but I’ve chosen to lean into Rust’s type system for that extra layer of expressive control.
In Rust, a slice is essentially a fat pointer: it includes both a memory address and a length. Because the slice type encapsulates both, I don’t need to manually track sizes or offsets. Plus, in debug builds, Rust automatically panics if I try to access an out-of-bounds index, which helps catch issues early. And I can use methods like
getorget_mutfor safe, optional access—either retrieving a value or returning None.Ultimately, Rust’s type system saves me from fiddling with raw bit arithmetic and length bookkeeping. It handles validation elegantly, letting me focus on logic instead of low-level guards.
PS: Although it isn’t finished just yet, I’m linking this
Nodeup with aBufandSlabstruct currently. If i remember when I’ve completed the design and I’m happy to freely distribute the code, I’ll make a paste bin and post it here for you. Always happy to help if I can :)That clears it up, thank you very much :)