Rust 2026 经验谈 - const generics 与编译期计算

1
// 不可能：用 const fn 做泛型参数
2
struct Matrix<T, const M: usize, const N: usize, const INIT: fn() -> T>;
3
// error: `fn() -> T` is not a valid const parameter type
4

5
// 变通方案：用策略类型
6
struct Matrix<T, const M: usize, const N: usize, I: Init<T>> {
7
    data: [[T; N]; M],
8
    _init: std::marker::PhantomData<I>,
9
}
10

11
trait Init<T> {
12
    fn init() -> T;
13
}
14

15
struct ZeroInit;
16
impl Init<i32> for ZeroInit {
17
    fn init() -> i32 { 0 }
18
}
19

20
let m: Matrix<i32, 3, 3, ZeroInit> = Matrix::new();

1
struct Foo<T, const N: usize> {
2
    data: [T; N],
3
}
4

5
// 可以：N 是 const 参数，可以在类型位置使用
6
impl<T, const N: usize> Foo<T, N> {
7
    fn len(&self) -> usize { N }
8
}
9

10
// 不可以（稳定版）：在类型位置中使用 const 表达式
11
// impl<T, const N: usize> Foo<T, N> {
12
//     fn double_len(&self) -> usize { N * 2 }  // OK：值位置中 N * 2 可以
13
//     fn split(&self) -> &[T; N / 2] { ... }   // 错误：类型位置中不能用 N / 2
14
// }
15

16
// 变通方案：用另一个 const 参数
17
impl<T, const N: usize> Foo<T, N> {
18
    fn as_slice(&self) -> &[T] {
19
        &self.data
20
    }
21
}
22

23
// 需要双倍长度时，另定义一个泛型
24
struct DoubleLen<T, const N: usize, const DOUBLE: usize> {
25
    data: [T; DOUBLE],
26
}
27
// 注意：调用者需确保 DOUBLE == N * 2，编译器不会自动验证

1
// 可以：简单默认值
2
struct Vec2<T, const N: usize = 2> {
3
    data: [T; N],
4
}
5

6
// 可以：表达式默认值（Rust 1.59+ 支持）
7
struct Buffer<T, const N: usize = { 1024 * 1024 }> {
8
    data: [T; N],
9
}
10

11
// 更早版本的变通：用常量定义
12
// const MB: usize = 1024 * 1024;
13
// struct Buffer<T, const N: usize = MB> {
14
//     data: [T; N],
15
// }

1
// 1. 不支持 trait bound 中的 const fn 调用
2
// const fn max<T: Ord>(a: T, b: T) -> T {
3
//     if a < b { b } else { a }  // error: trait 方法调用在 const fn 中不支持
4
// }
5

6
// 变通：为具体类型实现
7
const fn max_u32(a: u32, b: u32) -> u32 {
8
    if a < b { b } else { a }  // OK：u32 的 < 是内建的
9
}
10

11
// 2. 不支持动态分发
12
// const fn via_dyn(x: &dyn ToString) -> String { ... }  // 错误
13

14
// 3. 不支持 panic（编译期 panic = 编译错误）
15
const fn div(a: u32, b: u32) -> u32 {
16
    if b == 0 { panic!("division by zero") }  // 编译期调用时 panic = 编译错误
17
    a / b
18
}
19

20
const RESULT: u32 = div(10, 0);  // 编译错误：evaluation of `div(10, 0)` failed
21

22
// 4. 不支持格式化
23
// const fn to_string(n: u32) -> String { format!("{}", n) }  // 错误

1
// Rust 1.46：const fn 支持 if/else 和 match
2
// Rust 1.57：const fn 支持循环（while/loop/for）
3
// Rust 1.61：const fn 支持从引用到引用的类型转换
4
// Rust 1.65：const fn 支持可变引用
5
// Rust 1.83：const fn 支持可变引用指向可变数据
6

7
// 利用这些特性，可以写更复杂的 const fn
8
const fn is_prime(n: u64) -> bool {
9
    if n < 2 { return false; }
10
    if n < 4 { return true; }
11
    if n % 2 == 0 { return false; }
12
    let mut i = 3;
13
    while i * i <= n {
14
        if n % i == 0 { return false; }
15
        i += 2;
16
    }
17
    true
18
}
19

20
const CHECK: bool = is_prime(97);  // 编译期验证 97 是质数
21
const _: () = assert!(CHECK);  // 编译期断言：如果 CHECK 为 false 则编译失败

1
fn sum<T, const N: usize>(arr: &[T; N]) -> T
2
where
3
    T: std::ops::Add<Output = T> + Default + Copy,
4
{
5
    let mut total = T::default();
6
    for &item in arr {
7
        total = total + item;
8
    }
9
    total
10
}
11

12
let arr = [1, 2, 3, 4, 5];
13
assert_eq!(sum(&arr), 15);
14

15
let arr2 = [1.0, 2.0, 3.0];
16
assert_eq!(sum(&arr2), 6.0);
17
// 无需为不同长度写不同函数

1
struct Peano<const N: usize>;
2

3
trait Nat {
4
    const VALUE: usize;
5
}
6

7
impl<const N: usize> Nat for Peano<N> {
8
    const VALUE: usize = N;
9
}
10

11
trait Add<Rhs> {
12
    type Output;
13
}
14

15
impl<const A: usize, const B: usize> Add<Peano<B>> for Peano<A> {
16
    type Output = Peano<{ A + B }>;
17
}
18

19
// 编译期验证：1 + 2 = 3
20
fn _verify_add()
21
where
22
    Peano<1>: Add<Peano<2>, Output = Peano<3>>,
23
{}

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

5
impl<T: Default + Copy, const R: usize, const C: usize> Matrix<T, R, C> {
6
    fn zero() -> Self {
7
        Matrix { data: [[T::default(); C]; R] }
8
    }
9

10
    fn get(&self, row: usize, col: usize) -> Option<&T> {
11
        if row < R && col < C {
12
            Some(&self.data[row][col])
13
        } else {
14
            None
15
        }
16
    }
17
}
18

19
// 矩阵乘法：A(M×K) × B(K×N) = C(M×N)
20
impl<T, const M: usize, const K: usize, const N: usize> Matrix<T, M, K>
21
where
22
    T: std::ops::Mul<Output = T> + std::ops::Add<Output = T> + Default + Copy,
23
{
24
    fn mul(&self, other: &Matrix<T, K, N>) -> Matrix<T, M, N> {
25
        let mut result = Matrix::<T, M, N>::zero();
26
        for i in 0..M {
27
            for j in 0..N {
28
                let mut sum = T::default();
29
                for k in 0..K {
30
                    sum = sum + self.data[i][k] * other.data[k][j];
31
                }
32
                result.data[i][j] = sum;
33
            }
34
        }
35
        result
36
    }
37
}
38

39
let a: Matrix<i32, 2, 3> = Matrix::zero();
40
let b: Matrix<i32, 3, 4> = Matrix::zero();
41
let c = a.mul(&b);  // 类型：Matrix<i32, 2, 4>
42
// 维度不匹配的乘法直接编译错误！
43
// let d: Matrix<i32, 2, 2> = Matrix::zero();
44
// a.mul(&d);  // error: expected `3`, found `2`

1
struct RingBuffer<T, const CAP: usize> {
2
    data: [std::mem::MaybeUninit<T>; CAP],
3
    head: usize,
4
    tail: usize,
5
    len: usize,
6
}
7

8
impl<T, const CAP: usize> RingBuffer<T, CAP> {
9
    fn new() -> Self {
10
        RingBuffer {
11
            data: [std::mem::MaybeUninit::uninit(); CAP],
12
            head: 0,
13
            tail: 0,
14
            len: 0,
15
        }
16
    }
17

18
    fn capacity(&self) -> usize { CAP }
19

20
    fn push(&mut self, val: T) -> Result<(), T> {
21
        if self.len == CAP {
22
            return Err(val);
23
        }
24
        self.data[self.tail].write(val);
25
        self.tail = (self.tail + 1) % CAP;
26
        self.len += 1;
27
        Ok(())
28
    }
29

30
    fn pop(&mut self) -> Option<T> {
31
        if self.len == 0 {
32
            return None;
33
        }
34
        let val = unsafe { self.data[self.head].assume_init_read() };
35
        self.head = (self.head + 1) % CAP;
36
        self.len -= 1;
37
        Some(val)
38
    }
39
}
40

41
// 编译期确定容量，无堆分配
42
let mut buf: RingBuffer<u8, 64> = RingBuffer::new();
43
assert_eq!(buf.capacity(), 64);

1
#[repr(C, align(16))]
2
struct SimdVec<T, const N: usize> {
3
    data: [T; N],
4
}
5

6
impl SimdVec<f32, 4> {
7
    fn dot(&self, other: &Self) -> f32 {
8
        self.data[0] * other.data[0]
9
            + self.data[1] * other.data[1]
10
            + self.data[2] * other.data[2]
11
            + self.data[3] * other.data[3]
12
    }
13
}
14

15
impl SimdVec<f32, 8> {
16
    fn dot(&self, other: &Self) -> f32 {
17
        let mut sum = 0.0;
18
        for i in 0..8 {
19
            sum += self.data[i] * other.data[i];
20
        }
21
        sum
22
    }
23
}

1
#![feature(generic_const_exprs)]
2

3
// 允许 const 表达式作为泛型参数
4
struct Array<T, const N: usize> {
5
    data: [T; N],
6
}
7

8
impl<T, const N: usize> Array<T, N> {
9
    // 错误：泛型表达式 {N * 2} 需要 generic_const_exprs
10
    // fn double(&self) -> Array<T, {N * 2}> {
11
    //     ...
12
    // }
13
}
14

15
// 变通方案：用多个 const 参数
16
struct DoubleArray<T, const N: usize, const M: usize> {
17
    data: [T; M],
18
}
19

20
// 使用时手动传入 M = N * 2
21
let arr: DoubleArray<i32, 3, 6> = DoubleArray { data: [0; 6] };

1
struct SortedArray<T, const N: usize> {
2
    data: [T; N],
3
}
4

5
impl<T: Ord + Copy, const N: usize> SortedArray<T, N> {
6
    fn new(data: [T; N]) -> Self {
7
        // 运行时验证——因为 const fn 中不能做 sort 验证
8
        let mut sorted = data;
9
        sorted.sort();
10
        SortedArray { data: sorted }
11
    }
12
}
13

14
// 编译期验证大小至少为 1（需要 Nightly generic_const_exprs）
15
// 稳定版变通：用 const 断言 + 运行时检查
16
impl<T, const N: usize> SortedArray<T, N> {
17
    fn first(&self) -> &T {
18
        const { assert!(N >= 1, "N must be at least 1"); }
19
        &self.data[0]
20
    }
21
}