Const Generics: Compile-Time Generics

Snippet

Const Generics: Compile-Time Generics

Const generics allow types to be parameterized by constant values, not just types. This enables array-based data structures with compile-time known dimensions. The compiler can optimize better since array sizes are known at compile time, enabling stack allocation instead of heap.

snippet.rs
rust
struct Matrix<T, const N: usize, const M: usize> {
    data: [[T; M]; N],
}
 
impl<T, const N: usize, const M: usize> Matrix<T, N, M> {
    fn new(value: T) -> Self 
    where T: Default + Copy {
        Matrix { data: [[value; M]; N] }
    }
    
    fn get(&self, i: usize, j: usize) -> Option<&T> {
        if i < N && j < M {
            Some(&self.data[i][j])
        } else {
            None
        }
    }
}
 
fn smallest<T: PartialOrd + Copy, const N: usize>(arr: &[T; N]) -> T {
    let mut smallest = arr[0];
    let mut i = 1;
    while i < N {
        if arr[i] < smallest {
            smallest = arr[i];
        }
        i += 1;
    }
    smallest
}
 
fn main() {
    let m: Matrix<i32, 2, 3> = Matrix::new(0);
    if let Some(val) = m.get(1, 2) {
        println!("Value at [1,2]: {}", val);
    }
    
    let arr = [3, 1, 4, 1, 5];
    println!("Smallest: {}", smallest(&arr)); // 1
}

Breakdown

const N: usize, const M: usize

Const generics parameters for matrix dimensions

[[T; M]; N]

2D array with N rows of M-element arrays

let arr = [3, 1, 4, 1, 5];

Compile-time array size used with const generic function

smallest(&arr)

Array size inferred and passed as compile-time constant

Previous snippet Next snippet

More Intermediate Rust exercises →

From your library

Const Generics: Compile-Time Generics

Related