Rust常量数组生成库auto-const-array使用指南

auto-const-array是一个Rust库，用于在编译时高效构建和操作静态数组。它提供了一种声明式的方式来生成常量数组，避免了运行时计算的开销。

主要特性

• 编译时数组生成
• 支持各种数组操作（映射、过滤、拼接等）
• 零运行时开销
• 类型安全的操作

安装

在Cargo.toml中添加依赖：

[dependencies]
auto-const-array = "0.3"

基本用法

1. 生成简单数组

use auto_const_array::auto_const_array;

// 生成0-9的数组
const ARRAY: [i32; 10] = auto_const_array![i => i as i32; 10];

assert_eq!(ARRAY, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);

2. 带条件的数组生成

use auto_const_array::auto_const_array;

// 生成0-9中偶数的平方
const EVEN_SQUARES: [i32; 5] = auto_const_array![i => {
    let x = i as i32 * 2;
    x * x
}; 5];

assert_eq!(EVEN_SQUARES, [0, 4, 16, 36, 64]);

3. 数组转换

use auto_const_array::{auto_const_array, ArrayOps};

const ORIGINAL: [i32; 5] = [1, 2, 3, 4, 5];

// 将数组中的每个元素乘以2
const DOUBLED: [i32; 5] = ORIGINAL.map_const(|x| x * 2);

assert_eq!(DOUBLED, [2, 4, 6, 8, 10]);

4. 数组过滤

use auto_const_array::{auto_const_array, ArrayOps};

const NUMBERS: [i32; 10] = auto_const_array![i => i as i32; 10];

// 过滤出大于5的元素
const FILTERED: [i32; 4] = NUMBERS.filter_const(|&x| x > 5);

assert_eq!(FILTERED, [6, 7, 8, 9]);

5. 数组拼接

use auto_const_array::{auto_const_array, ArrayOps};

const A: [i32; 3] = [1, 2, 3];
const B: [i32; 2] = [4, 5];

// 拼接两个数组
const COMBINED: [i32; 5] = A.concat_const(B);

assert_eq!(COMBINED, [1, 2, 3, 4, 5]);

高级用法

生成复杂结构数组

use auto_const_array::auto_const_array;

#[derive(Debug, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

const POINTS: [Point; 3] = auto_const_array![i => Point {
    x: i as i32 * 10,
    y: i as i32 * 20
}; 3];

assert_eq!(POINTS, [
    Point { x: 0, y: 0 },
    Point { x: 10, y: 20 },
    Point { x: 20, y: 40 }
]);

使用枚举

use auto_const_array::auto_const_array;

#[derive(Debug, PartialEq)]
enum Color {
    Red,
    Green,
    Blue,
}

const COLORS: [Color; 3] = auto_const_array![i => match i {
    0 => Color::Red,
    1 => Color::Green,
    2 => Color::Blue,
    _ => unreachable!()
}; 3];

assert_eq!(COLORS, [Color::Red, Color::Green, Color::Blue]);

性能考虑

由于所有操作都在编译时完成，生成的数组是真正的Rust常量，具有以下优势：

1. 零运行时初始化开销
2. 可以用于const上下文
3. 生成的代码与硬编码数组一样高效

限制

1. 数组长度必须在编译时已知
2. 生成逻辑必须是编译时可执行的（纯Rust常量表达式）
3. 目前不支持动态长度数组

auto-const-array是需要在编译时生成固定长度数组场景的理想选择，特别是当数组元素遵循某种可计算的模式时。

完整示例demo

// 完整示例展示auto-const-array的各种用法
use auto_const_array::{auto_const_array, ArrayOps};

// 1. 基本数组生成
const BASIC_ARRAY: [i32; 5] = auto_const_array![i => i as i32; 5];
println!("基本数组: {:?}", BASIC_ARRAY); // [0, 1, 2, 3, 4]

// 2. 带条件的数组生成
const CONDITIONAL_ARRAY: [i32; 5] = auto_const_array![i => {
    let val = i as i32;
    if val % 2 == 0 { val * 10 } else { val }
}; 5];
println!("条件数组: {:?}", CONDITIONAL_ARRAY); // [0, 1, 20, 3, 40]

// 3. 数组转换
const TRANSFORMED: [i32; 5] = BASIC_ARRAY.map_const(|x| x * 100);
println!("转换后的数组: {:?}", TRANSFORMED); // [0, 100, 200, 300, 400]

// 4. 数组过滤
const FILTERED: [i32; 2] = BASIC_ARRAY.filter_const(|&x| x > 2);
println!("过滤后的数组: {:?}", FILTERED); // [3, 4]

// 5. 数组拼接
const ARRAY_A: [i32; 2] = [10, 20];
const ARRAY_B: [i32; 3] = [30, 40, 50];
const CONCATENATED: [i32; 5] = ARRAY_A.concat_const(ARRAY_B);
println!("拼接后的数组: {:?}", CONCATENATED); // [10, 20, 30, 40, 50]

// 6. 复杂结构数组
#[derive(Debug)]
struct Person {
    id: u32,
    age: u8,
}

const PEOPLE: [Person; 3] = auto_const_array![i => Person {
    id: i as u32 * 100,
    age: (i as u8) + 20
}; 3];
println!("人员数组: {:?}", PEOPLE); // [Person { id: 0, age: 20 }, Person { id: 100, age: 21 }, Person { id: 200, age: 22 }]

// 7. 枚举数组
#[derive(Debug)]
enum Status {
    Active,
    Inactive,
    Pending,
}

const STATUSES: [Status; 3] = auto_const_array![i => match i {
    0 => Status::Active,
    1 => Status::Inactive,
    2 => Status::Pending,
    _ => unreachable!()
}; 3];
println!("状态数组: {:?}", STATUSES); // [Active, Inactive, Pending]

这个完整示例展示了auto-const-array库的主要功能，包括基本数组生成、条件生成、转换、过滤、拼接以及处理复杂结构和枚举类型。所有操作都在编译时完成，确保零运行时开销。