Rust中针对常量特化代码的更优实现方法是什么？

假设有如下循环，其中xs.len()数值极大且order <= 3：

pub fn cumulative_sum(xs: Vec<i64>, order: usize) {
  let mut res = Vec::with_capacity(xs.len());
  let mut moments = vec![0; order];
  for i in 0..xs.len() {
    res.push(moments[0]);
    for o in 0..order - 1 {
      moments[o] += moments[o + 1];
    }
    moments[order - 1] += xs[i];
  }
}

通过为order指定编译期常量进行代码特化，可将速度提升约2倍，但当前实现方式较为繁琐，具体代码如下：

trait CompileTimeOrder {
  const ORDER: usize;
}

macro_rules! impl_order {
  ($name: ident, $order: expr) => {
    struct $name;
    impl CompileTimeOrder for $name {
      const ORDER: usize = $order;
    }
  }
}

impl_order!(Order1, 1);
impl_order!(Order2, 2);
impl_order!(Order3, 3);

fn cumulative_sum_internal<O: CompileTimeOrder>(xs: Vec<i64>) {
  let order = O::ORDER;
   ... // 与之前相同的逻辑
}

pub fn cumulative_sum(xs: Vec<i64>, order: usize) {
  match order {
    1 => cumulative_sum_internal::<Order1>(xs),
    2 => cumulative_sum_internal::<Order2>(xs),
    3 => cumulative_sum_internal::<Order3>(xs),
    _ => panic!()
  }
}

请问是否存在更优的方式来针对特定order值进行代码特化？

方法1：用const generics直接替代 trait 特化 #

Rust 1.51+支持const generics，可直接将order作为编译期常量参数，无需额外定义trait和结构体：

pub fn cumulative_sum<const ORDER: usize>(xs: Vec<i64>) {
  let mut res = Vec::with_capacity(xs.len());
  // 用编译期确定大小的数组替代Vec，避免堆分配
  let mut moments = [0i64; ORDER];
  for i in 0..xs.len() {
    res.push(moments[0]);
    // 编译期展开内层逻辑，消除运行时边界检查
    match ORDER {
      1 => {} // 无内层循环
      2 => moments[0] += moments[1],
      3 => {
        moments[0] += moments[1];
        moments[1] += moments[2];
      }
      _ => unreachable!("order <=3"),
    }
    moments[ORDER - 1] += xs[i];
  }
}

// 保持对外动态参数接口
pub fn cumulative_sum_dynamic(xs: Vec<i64>, order: usize) {
  match order {
    1 => cumulative_sum::<1>(xs),
    2 => cumulative_sum::<2>(xs),
    3 => cumulative_sum::<3>(xs),
    _ => panic!("order must be 1,2,3"),
  }
}

这种方式直接把order固化在编译期，数组相比Vec减少了堆分配开销，match分支会被编译器完全优化，消除运行时判断。

方法2：宏批量生成特化实现 #

如果不想手动编写不同order的内层逻辑，可用宏批量生成独立的特化函数：

macro_rules! cumulative_sum_impl {
    ($($order:literal),*) => {
        $(
            pub fn cumulative_sum_$order(xs: Vec<i64>) {
                let mut res = Vec::with_capacity(xs.len());
                let mut moments = [0i64; $order];
                for i in 0..xs.len() {
                    res.push(moments[0]);
                    // 自动展开内层循环
                    $(
                        moments[$order - 1 - $_] += moments[$order - $_];
                    ) for $_ in 1..$order;
                    moments[$order - 1] += xs[i];
                }
            }
        )*
    };
}

// 生成order=1、2、3的实现
cumulative_sum_impl!(1,2,3);

pub fn cumulative_sum(xs: Vec<i64>, order: usize) {
    match order {
        1 => cumulative_sum_1(xs),
        2 => cumulative_sum_2(xs),
        3 => cumulative_sum_3(xs),
        _ => panic!(),
    }
}

宏会为每个指定的order生成独立函数，编译器可对每个函数做极致优化，完全消除循环的运行时开销。

方法3：直接暴露const泛型函数（编译期确定order场景） #

如果调用方能在编译期确定order值，可直接对外暴露const泛型函数，省去动态分支：

pub fn cumulative_sum<const ORDER: usize>(xs: Vec<i64>)
where
    [(); ORDER]:, // 约束ORDER为编译期常量
{
  let mut res = Vec::with_capacity(xs.len());
  let mut moments = [0i64; ORDER];
  for i in 0..xs.len() {
    res.push(moments[0]);
    // 编译期自动展开内层循环
    #[allow(unused_variables)]
    for o in 0..ORDER-1 {
        moments[o] += moments[o+1];
    }
    moments[ORDER-1] += xs[i];
  }
}

// 调用示例
// let xs = vec![1,2,3];
// cumulative_sum::<2>(xs);

这种方式无需动态分支，直接让调用方传递编译期常量，性能达到最优。

内容的提问来源于stack exchange，提问作者mwlon