Const generics in Rust are a game-changer. They let us create more flexible and efficient code by parameterizing types with constant values. It’s like having a superpower for building adaptable, zero-cost abstractions.

I’ve been using const generics a lot lately, and I’m amazed at how they’ve transformed my approach to generic programming. Let me show you what I mean.

At its core, const generics allow us to use compile-time known constants as type parameters. This might sound a bit abstract, so let’s dive into an example:

struct Array<T, const N: usize> {
    data: [T; N]
}

fn main() {
    let arr: Array<i32, 5> = Array { data: [1, 2, 3, 4, 5] };
}

In this code, we’re creating an Array struct that’s generic over both the type T and the constant N. N represents the size of the array, and it’s known at compile time. This means we can create arrays of different sizes, all with type-level guarantees.

But const generics aren’t just for arrays. They open up a whole new world of possibilities. Imagine creating a Matrix type where the dimensions are part of the type itself:

struct Matrix<T, const ROWS: usize, const COLS: usize> {
    data: [[T; COLS]; ROWS]
}

fn main() {
    let mat: Matrix<f64, 3, 4> = Matrix { data: [[0.0; 4]; 3] };
}

This Matrix type knows its dimensions at compile time. We can use this information to perform compile-time checks and optimizations.

One of the coolest things about const generics is that they allow us to do type-level arithmetic. We can use these constants in expressions within types. Here’s an example:

struct Buffer<T, const N: usize> {
    data: [T; N],
    index: usize,
}

impl<T, const N: usize> Buffer<T, N> {
    fn push(&mut self, value: T) -> Result<(), ()> {
        if self.index < N {
            self.data[self.index] = value;
            self.index += 1;
            Ok(())
        } else {
            Err(())
        }
    }
}

In this Buffer type, we’re using N to define the size of our internal array. The push method uses this N to check if there’s space available. This is all checked at compile time, giving us both safety and performance.

Const generics also shine when it comes to creating more flexible APIs. Let’s say we want to create a function that works with arrays of any size:

fn sum<T, const N: usize>(arr: [T; N]) -> T
where
    T: std::ops::Add<Output = T> + Default,
{
    arr.iter().fold(T::default(), |acc, &x| acc + x)
}

fn main() {
    let arr1 = [1, 2, 3, 4, 5];
    let arr2 = [1, 2, 3];
    
    println!("Sum of arr1: {}", sum(arr1));
    println!("Sum of arr2: {}", sum(arr2));
}

This sum function works with arrays of any size, thanks to const generics. We don’t need separate functions for different array sizes, and we get compile-time guarantees that we’re using the function correctly.

But const generics aren’t just about convenience. They can significantly improve performance too. By knowing the size of data structures at compile time, the compiler can make better optimization decisions. This can lead to faster, more efficient code.

Let’s look at a more complex example. Imagine we’re building a fixed-size ring buffer:

struct RingBuffer<T, const N: usize> {
    data: [Option<T>; N],
    read_pos: usize,
    write_pos: usize,
}

impl<T, const N: usize> RingBuffer<T, N> {
    fn new() -> Self {
        Self {
            data: [None; N],
            read_pos: 0,
            write_pos: 0,
        }
    }

    fn push(&mut self, item: T) {
        self.data[self.write_pos] = Some(item);
        self.write_pos = (self.write_pos + 1) % N;
        if self.write_pos == self.read_pos {
            self.read_pos = (self.read_pos + 1) % N;
        }
    }

    fn pop(&mut self) -> Option<T> {
        if self.read_pos == self.write_pos && self.data[self.read_pos].is_none() {
            None
        } else {
            let item = self.data[self.read_pos].take();
            self.read_pos = (self.read_pos + 1) % N;
            item
        }
    }
}

This RingBuffer knows its size at compile time, allowing for efficient memory usage and bounds checking. We can create buffers of different sizes, all with the same implementation:

fn main() {
    let mut buf5: RingBuffer<i32, 5> = RingBuffer::new();
    let mut buf10: RingBuffer<i32, 10> = RingBuffer::new();

    for i in 0..7 {
        buf5.push(i);
        buf10.push(i);
    }

    while let Some(item) = buf5.pop() {
        println!("From buf5: {}", item);
    }

    while let Some(item) = buf10.pop() {
        println!("From buf10: {}", item);
    }
}

Const generics also allow us to implement traits conditionally based on the const parameter. This can lead to some really powerful abstractions. For example, we could implement a trait only for arrays of a certain size:

trait IsSquare {}

impl<T, const N: usize> IsSquare for [[T; N]; N] {}

fn process_square_matrix<T, const N: usize>(matrix: [[T; N]; N])
where
    [[T; N]; N]: IsSquare,
{
    // Process the square matrix
}

fn main() {
    let square = [[1, 2], [3, 4]];
    let non_square = [[1, 2, 3], [4, 5, 6]];

    process_square_matrix(square); // This works
    // process_square_matrix(non_square); // This would not compile
}

In this example, only square matrices (where rows equal columns) implement the IsSquare trait. The process_square_matrix function can then use this trait as a constraint, ensuring it only works with square matrices.

Const generics can also be used to implement compile-time checks for more complex invariants. For instance, we could create a type that represents a valid IPv4 address:

struct Ipv4Address<const A: u8, const B: u8, const C: u8, const D: u8>;

impl<const A: u8, const B: u8, const C: u8, const D: u8> Ipv4Address<A, B, C, D> {
    fn new() -> Self {
        Self
    }
}

fn main() {
    let _valid = Ipv4Address::<192, 168, 0, 1>::new();
    // let _invalid = Ipv4Address::<256, 0, 0, 0>::new(); // This would not compile
}

Here, we’re using const generics to ensure that each octet of the IP address is a valid u8 value. Any attempt to create an invalid IP address (like one with an octet value of 256) would result in a compile-time error.

Const generics can also be incredibly useful when working with embedded systems or other environments where resources are constrained. For example, we could create a stack-allocated vector with a compile-time known capacity:

struct StackVec<T, const N: usize> {
    data: [MaybeUninit<T>; N],
    len: usize,
}

impl<T, const N: usize> StackVec<T, N> {
    fn new() -> Self {
        Self {
            data: unsafe { MaybeUninit::uninit().assume_init() },
            len: 0,
        }
    }

    fn push(&mut self, value: T) -> Result<(), T> {
        if self.len < N {
            self.data[self.len].write(value);
            self.len += 1;
            Ok(())
        } else {
            Err(value)
        }
    }

    fn pop(&mut self) -> Option<T> {
        if self.len > 0 {
            self.len -= 1;
            Some(unsafe { self.data[self.len].assume_init_read() })
        } else {
            None
        }
    }
}

This StackVec type gives us vector-like functionality without any heap allocation. The capacity is known at compile time, allowing for efficient memory usage and bounds checking.

Const generics can also be used to create more efficient implementations for specific sizes. For example, we could specialize our matrix multiplication algorithm for 2x2 matrices:

trait MatMul<const N: usize, const M: usize, const P: usize> {
    fn mat_mul(self, other: [[f64; P]; M]) -> [[f64; P]; N];
}

impl<const N: usize, const M: usize, const P: usize> MatMul<N, M, P> for [[f64; M]; N] {
    fn mat_mul(self, other: [[f64; P]; M]) -> [[f64; P]; N] {
        let mut result = [[0.0; P]; N];
        for i in 0..N {
            for j in 0..P {
                for k in 0..M {
                    result[i][j] += self[i][k] * other[k][j];
                }
            }
        }
        result
    }
}

impl MatMul<2, 2, 2> for [[f64; 2]; 2] {
    fn mat_mul(self, other: [[f64; 2]; 2]) -> [[f64; 2]; 2] {
        [
            [
                self[0][0] * other[0][0] + self[0][1] * other[1][0],
                self[0][0] * other[0][1] + self[0][1] * other[1][1],
            ],
            [
                self[1][0] * other[0][0] + self[1][1] * other[1][0],
                self[1][0] * other[0][1] + self[1][1] * other[1][1],
            ],
        ]
    }
}

In this example, we have a general implementation of matrix multiplication for any size, but we’ve also provided a specialized implementation for 2x2 matrices. This specialized version avoids loops and can be more efficient.

Const generics are a powerful feature that can help us write more expressive, efficient, and safer code. They allow us to leverage Rust’s type system in new ways, creating abstractions that are both flexible and zero-cost. Whether you’re working on low-level systems programming, building high-performance libraries, or just want to write more robust Rust code, const generics are a tool you’ll want in your arsenal.

As we continue to explore and push the boundaries of what’s possible with const generics, I’m excited to see what new patterns and techniques will emerge. The ability to parameterize types with constant values opens up a whole new dimension of generic programming, and I believe we’ve only scratched the surface of what’s possible.

Remember, const generics are still a relatively new feature in Rust, and best practices are still evolving. As you start using them in your own code, don’t be afraid to experiment and push the boundaries. You might just discover the next big pattern or technique that changes how we think about generic programming in Rust.