@alina I lowkey believe rust is an "easy" language, that's largely "difficult" due to it's differences from convention, and it's largely strict and detailed design.

That is to say: it's an oddball, and forces you to pay attention to the *how* of what your interfacing with.

@alina i must concur!

I litterally recreationally look at the rust stdlib documentation and source code, it's just so fun!

I tend to dig into some of the more `unsafe` APIs because the problems and their solutions are very interesting to me.

An interesting API is `MaybeUninit<T>` a type that represents potentially unititalized memory, since the rust memory model largely doesn't allow for uninitalized memory without indirection.

The niche they use to store such memory is effectively padding bytes!

In enums with differently sized variants there is padding memory in each instance, this can be unitalized since it's never read. Same with alignment padding in structs.

Here's the real neat trick: `MaybeUninit<T>` is a *union* between `()` and `ManuallyDrop<T>`, so it's either all uninitalized, or a fully initalized `T`!

Unions aren't stateful like enums, whether it's initalized is tracked by the user, and it's interfaced with unsafe methods.

Still, it's a lovely design to an interesting problem!

Have fun!