Const generics in Rust are a game-changer for creating efficient and flexible array abstractions. They let us parameterize types and functions with constant values, opening up new possibilities for zero-cost abstractions.

Let’s start with a simple example to see const generics in action:

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

impl<T, const N: usize> Array<T, N> {
    fn new(value: T) -> Self
    where
        T: Copy,
    {
        Self { data: [value; N] }
    }
}

fn main() {
    let arr = Array::<i32, 5>::new(42);
    println!("Array size: {}", std::mem::size_of_val(&arr));
}

In this example, we’ve created a generic Array struct that takes two type parameters: T for the element type and N for the array size. The N parameter is a const generic, allowing us to create arrays of any size at compile-time.

One of the coolest things about const generics is that they enable us to write functions that work with arrays of any size, without runtime overhead. Here’s an example:

fn sum<T, const N: usize>(arr: &[T; N]) -> T
where
    T: std::ops::Add<Output = T> + Default + Copy,
{
    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, and the compiler will generate optimized code for each specific array size used.

Const generics aren’t limited to just array sizes. We can use them for any compile-time constant values. This opens up possibilities for creating more expressive and type-safe APIs. For example, we could create a Matrix type that uses const generics for its dimensions:

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

impl<T, const ROWS: usize, const COLS: usize> Matrix<T, ROWS, COLS>
where
    T: Default + Copy,
{
    fn new() -> Self {
        Self {
            data: [[T::default(); COLS]; ROWS],
        }
    }
}

fn main() {
    let matrix: Matrix<f64, 3, 4> = Matrix::new();
    println!("Matrix size: {} bytes", std::mem::size_of_val(&matrix));
}

This Matrix type ensures that operations like matrix multiplication can be checked for compatibility at compile-time, preventing runtime errors.

Const generics also allow us to perform compile-time computations. We can use this to create more complex abstractions. Here’s an example of a compile-time computed Fibonacci sequence:

struct Fibonacci<const N: usize>;

impl<const N: usize> Fibonacci<N> {
    const VALUE: usize = Self::fibonacci();

    const fn fibonacci() -> usize {
        let mut a = 0;
        let mut b = 1;
        let mut i = 0;
        while i < N {
            let tmp = a;
            a = b;
            b = tmp + b;
            i += 1;
        }
        a
    }
}

fn main() {
    println!("10th Fibonacci number: {}", Fibonacci::<10>::VALUE);
}

This code calculates the Nth Fibonacci number at compile-time, with no runtime cost.

One area where const generics really shine is in creating safe abstractions for embedded systems programming. When working with hardware, it’s often necessary to work with specific memory layouts and sizes. Const generics allow us to create types that represent these hardware constraints accurately:

struct Register<T, const OFFSET: usize> {
    _marker: std::marker::PhantomData<T>,
}

impl<T, const OFFSET: usize> Register<T, OFFSET> {
    fn read(&self) -> T {
        unsafe { std::ptr::read_volatile((OFFSET as *const T).as_ref().unwrap()) }
    }

    fn write(&mut self, value: T) {
        unsafe { std::ptr::write_volatile(OFFSET as *mut T, value) }
    }
}

const TIMER_CONTROL: usize = 0x4000_0000;
const TIMER_VALUE: usize = 0x4000_0004;

type TimerControl = Register<u32, TIMER_CONTROL>;
type TimerValue = Register<u32, TIMER_VALUE>;

fn main() {
    let mut timer_control: TimerControl = Register { _marker: std::marker::PhantomData };
    let timer_value: TimerValue = Register { _marker: std::marker::PhantomData };

    timer_control.write(1); // Start the timer
    println!("Timer value: {}", timer_value.read());
}

This example shows how we can use const generics to create type-safe abstractions for memory-mapped hardware registers. The OFFSET const generic ensures that each register type is uniquely associated with its memory address.

Const generics also allow us to implement traits for arrays of any size. This can be particularly useful when working with cryptographic algorithms or other areas where fixed-size arrays are common:

trait ByteArray {
    fn to_hex(&self) -> String;
}

impl<const N: usize> ByteArray for [u8; N] {
    fn to_hex(&self) -> String {
        self.iter()
            .map(|b| format!("{:02x}", b))
            .collect()
    }
}

fn main() {
    let arr1: [u8; 4] = [0xDE, 0xAD, 0xBE, 0xEF];
    let arr2: [u8; 32] = [0; 32];

    println!("arr1 hex: {}", arr1.to_hex());
    println!("arr2 hex: {}", arr2.to_hex());
}

This implementation works for byte arrays of any size, eliminating the need for separate implementations for different array lengths.

Const generics can also be used to implement compile-time checked mathematics. Here’s an example of a type-safe angle implementation:

#[derive(Debug, Clone, Copy)]
struct Angle<const DEGREES: i32>;

impl<const DEGREES: i32> Angle<DEGREES> {
    const NORMALIZED: i32 = (DEGREES % 360 + 360) % 360;

    fn new() -> Self {
        Self
    }

    fn degrees(&self) -> i32 {
        Self::NORMALIZED
    }
}

fn main() {
    let a = Angle::<45>::new();
    let b = Angle::<730>::new();

    println!("a: {} degrees", a.degrees());
    println!("b: {} degrees", b.degrees());
}

In this example, the Angle type normalizes the degree value at compile-time, ensuring that all angle values are always between 0 and 359 degrees.

Const generics can be combined with other Rust features to create powerful abstractions. For example, we can use const generics with traits to create compile-time checked linear algebra operations:

trait Vector<T, const N: usize> {
    fn dot(&self, other: &Self) -> T;
}

impl<T, const N: usize> Vector<T, N> for [T; N]
where
    T: std::ops::Mul<Output = T> + std::ops::Add<Output = T> + Default + Copy,
{
    fn dot(&self, other: &Self) -> T {
        self.iter()
            .zip(other.iter())
            .map(|(&a, &b)| a * b)
            .fold(T::default(), |acc, x| acc + x)
    }
}

fn main() {
    let v1 = [1, 2, 3];
    let v2 = [4, 5, 6];
    println!("Dot product: {}", v1.dot(&v2));

    // This would cause a compile-time error:
    // let v3 = [1, 2, 3, 4];
    // println!("Dot product: {}", v1.dot(&v3));
}

This implementation ensures that dot products are only computed for vectors of the same length, catching potential errors at compile-time.

Const generics also enable us to create more efficient data structures. For example, we can implement a fixed-capacity vector that never allocates on the heap:

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

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

    fn push(&mut self, value: T) -> Result<(), &'static str> {
        if self.len < N {
            self.data[self.len] = value;
            self.len += 1;
            Ok(())
        } else {
            Err("StackVec is full")
        }
    }

    fn pop(&mut self) -> Option<T> {
        if self.len > 0 {
            self.len -= 1;
            Some(std::mem::replace(&mut self.data[self.len], unsafe { std::mem::MaybeUninit::uninit().assume_init() }))
        } else {
            None
        }
    }
}

fn main() {
    let mut vec: StackVec<i32, 5> = StackVec::new();
    
    for i in 0..5 {
        vec.push(i).unwrap();
    }
    
    while let Some(value) = vec.pop() {
        println!("Popped: {}", value);
    }
}

This StackVec type provides a vector-like interface but with a fixed capacity known at compile-time, making it suitable for use in no_std environments or when heap allocations need to be avoided.

Const generics can also be used to implement compile-time checked state machines. Here’s a simple example:

enum State {
    Start,
    Processing,
    End,
}

struct StateMachine<const CURRENT: State>;

impl StateMachine<{State::Start}> {
    fn start_processing(self) -> StateMachine<{State::Processing}> {
        println!("Starting processing");
        StateMachine
    }
}

impl StateMachine<{State::Processing}> {
    fn finish(self) -> StateMachine<{State::End}> {
        println!("Finishing processing");
        StateMachine
    }
}

impl StateMachine<{State::End}> {
    fn reset(self) -> StateMachine<{State::Start}> {
        println!("Resetting");
        StateMachine
    }
}

fn main() {
    let machine = StateMachine::<{State::Start}>;
    let machine = machine.start_processing();
    let machine = machine.finish();
    let _machine = machine.reset();

    // This would cause a compile-time error:
    // machine.start_processing();
}

In this example, the state machine’s current state is encoded in the type system, making it impossible to call methods that aren’t valid for the current state.

Const generics also allow us to create more expressive APIs for working with units of measurement:

#[derive(Debug, Clone, Copy)]
struct Length<const UNIT: u8, T>(T);

impl<const UNIT: u8, T> Length<UNIT, T>
where
    T: std::ops::Mul<Output = T> + Copy,
{
    fn to_meters(self) -> Length<0, T> {
        match UNIT {
            0 => Length(self.0), // Already meters
            1 => Length(self.0 * T::from(100)), // Centimeters to meters
            2 => Length(self.0 * T::from(1000)), // Millimeters to meters
            _ => panic!("Unknown unit"),
        }
    }
}

fn add_lengths<const UNIT: u8, T>(a: Length<UNIT, T>, b: Length<UNIT, T>) -> Length<UNIT, T>
where
    T: std::ops::Add<Output = T>,
{
    Length(a.0 + b.0)
}

fn main() {
    let len1 = Length::<1, f64>(150.0); // 150 cm
    let len2 = Length::<1, f64>(50.0);  // 50 cm
    
    let sum = add_lengths(len1, len2);
    println!("Sum: {:?}", sum.to_meters());
}

This system ensures that we only add lengths with the same units, preventing common errors in scientific and engineering calculations.

Const generics have opened up new possibilities for creating zero-cost abstractions in Rust. They allow us to write more generic, type-safe code without sacrificing performance. As we continue to explore and push the boundaries of what’s possible with const generics, we’ll undoubtedly discover even more powerful ways to leverage this feature in our Rust code.