The good old Vector<T, N> from C++.

For all the pain points C++ has, template metaprogramming was always so satisfying when you got it to work. Satisfying in "I feel really clever for solving this so generally and with no runtime overhead" way, but also being completely aware that another person reading the code and having to maintain it migh order a hit on me over darkweb.

Do you mean std::array<T,N>? ( https://en.cppreference.com/w/cpp/container/array )

Vector<T, N> an Matrix<T, N> is a fancy way to do small linear algebra types - like 2,3,4 vector and 3x3/4x4 matrix - you implement simple operations like add, multiply and dot products with loops and the compiler will unroll it and then you add some specific overloads for stuff like cross product, etc. Saves you having to reimplement it for every N. It's the simplest case of this kind of metaprogramming and feels good once you discover this kind of generalisation.

It still says

> This is gonna require some const generics stuff that isn't actually stabilized yet. This means, for the first time in my life, I'm going to have to use... Nightly Rust.

I heard somewhere that it's stable now.

Rust 1.51 stabilized a lot of const generics use-cases, but there are still some advanced parts which are only on Nightly. For example, doing math with const generics, like an array [String; WIDTH * HEIGHT], still requires nightly.

One of my favorite data structures in C++ is InlineVector<T,N>. If the number of elements is <= N then it all fits in the preallocated space.

This is great for keeping memory on the stack when N is small, yet allow heap memory overflow for larger N.

In Rust there is smallvec https://docs.rs/crate/smallvec/