Const Generics in Rust: vs Type Generics Explained

TL;DR: Const generics allow types and functions to be generic over constant values (integers, booleans, chars) rather than only types. The most important use case is arrays: [T; N] where N is a const generic; this is how std implements traits uniformly for arrays of any length. You write struct Matrix<const ROWS: usize, const COLS: usize> and the compiler generates separate code for each distinct const value used.

What Are Const Generics?

Const generics are compile-time constant values used as type parameters; most commonly array sizes.

struct Matrix<const ROWS: usize, const COLS: usize> {
    data: [[f64; COLS]; ROWS],
}
 
impl<const ROWS: usize, const COLS: usize> Matrix<ROWS, COLS> {
    fn new() -> Self {
        Self { data: [[0.0; COLS]; ROWS] }
    }
 
    fn rows(&self) -> usize { ROWS }
    fn cols(&self) -> usize { COLS }
}
 
let m: Matrix<3, 4> = Matrix::new(); // 3×4 matrix, zero-cost abstraction

Matrix<3, 4> and Matrix<5, 5> are distinct types at compile time; the compiler generates optimized code for each.

How Does std Use Const Generics?

Since Rust 1.51, [T; N] implements std traits uniformly for any N using const generics.

Before const generics, the standard library manually implemented traits like Debug, Clone, and PartialEq for arrays up to length 32. After const generics, one impl covers all sizes:

// This is how std now works internally:
impl<T: Debug, const N: usize> Debug for [T; N] {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { ... }
}

This is why you can now use [u8; 64].clone() without worrying about whether 64 is in the "supported" list.

How Do You Write a Function With Const Generics?

Declare the const parameter with const N: usize in the generic list.

fn first_n<T: Copy, const N: usize>(slice: &[T]) -> Option<[T; N]> {
    if slice.len() < N {
        return None;
    }
    let mut arr = [slice[0]; N];
    arr.copy_from_slice(&slice[..N]);
    Some(arr)
}
 
let arr: Option<[i32; 3]> = first_n(&[1, 2, 3, 4, 5]);

The caller can specify N explicitly or let the compiler infer it from context.

Const Generics vs Type Generics vs Trait Bounds in 2026

Const generics, type generics, and trait bounds each solve a different parameterization problem; knowing when to use which is key to idiomatic Rust.

In 2026, stable const generics cover the vast majority of real-world needs; fixed-size arrays, stack-allocated buffers, and compile-time dimension checks. Reach for type generics when abstracting over types, trait bounds when abstracting over behavior, and const generics when you need a type that carries a compile-time integer. Avoid typenum for new code; const generics replace it on stable Rust.

What Are the Current Limitations?

Const generic expressions (arithmetic on const params) are partially supported; complex expressions require nightly.

// Stable: simple const params
struct Buffer<const N: usize>([u8; N]);
 
// Nightly only: arithmetic in const expressions
// struct Doubled<const N: usize>([u8; N * 2]);  // requires #![feature(generic_const_exprs)]

On stable Rust, const parameters must be simple identifiers; you cannot use N + 1 or N * 2 as a type-level expression. The generic_const_exprs feature is tracked for stabilization.

Frequently Asked Questions

Sources

• Rust Blog; Const Generics MVP
• Rust Reference; Const Generics
• Tracking issue: generic_const_exprs
• The Rust Book; Generic Data Types

Related Glossary Terms

• generic: Type generics, the more common form of parameterization
• associated-types: Another way to make traits flexible
• const-static: Compile-time constants (different from const generics)
• trait: Trait bounds are the companion tool to const generics
• impl-trait: Return-position impl Trait, another compile-time dispatch tool

Keep Reading

• Rust Generics and Traits: Const generics build on the generics system
• Rust vs Go in 2026: Where Rust's type system gives it a performance edge