lightning-types: Rust高性能类型转换与自定义类型支持库

介绍

lightning-types 是一个 Rust 类型系统扩展库，专注于提供高性能的类型转换和自定义类型支持。它通过零成本抽象和编译时类型检查，为 Rust 开发者提供了更灵活的类型操作能力，同时保持 Rust 的安全性和性能优势。

主要特性：

• 高性能类型转换，避免运行时开销
• 自定义类型系统扩展
• 编译时类型检查
• 零成本抽象
• 与 Rust 原生类型无缝集成

安装

在 Cargo.toml 中添加依赖：

[dependencies]
lightning-types = "0.3"

完整示例代码

use lightning_types::{define_type, define_conversion, convert, As, Into, ensure_type, TypeCheck, optimize};

// 1. 基本类型转换示例
fn basic_conversion_example() {
    let x: i32 = 42;
    
    // 使用 convert! 宏
    let y: u64 = convert!(x as u64);
    println!("Basic conversion using macro: {}", y);
    
    // 使用 as_ 方法
    let z = x.as_::<u64>();
    println!("Basic conversion using as_: {}", z);
    
    // 使用 into_ 方法
    let w: u64 = x.into_();
    println!("Basic conversion using into_: {}", w);
}

// 2. 自定义类型示例
define_type! {
    #[derive(Debug, Clone, PartialEq)]
    pub struct UserId(u64);
}

impl UserId {
    pub fn new(id: u64) -> Self {
        Self(id)
    }
    
    pub fn get(&self) -> u64 {
        self.0
    }
}

fn custom_type_example() {
    let user1 = UserId::new(1001);
    let user2 = user1.clone();
    println!("Custom type example - User1: {:?}, User2: {:?}", user1, user2);
    assert_eq!(user1, user2);
}

// 3. 自定义类型转换示例
define_type! {
    #[derive(Debug)]
    pub struct Celsius(f64);
}

define_type! {
    #[derive(Debug)]
    pub struct Fahrenheit(f64);
}

define_conversion! {
    Celsius => Fahrenheit {
        |c: Celsius| Fahrenheit((c.0 * 9.0 / 5.0) + 32.0)
    }
    
    Fahrenheit => Celsius {
        |f: Fahrenheit| Celsius((f.0 - 32.0) * 5.0 / 9.0)
    }
}

fn temperature_conversion_example() {
    let boiling_c = Celsius(100.0);
    let boiling_f: Fahrenheit = convert!(boiling_c as Fahrenheit);
    println!("Water boils at {:.1}°F", boiling_f.0);
    
    let freezing_f = Fahrenheit(32.0);
    let freezing_c: Celsius = convert!(freezing_f as Celsius);
    println!("Water freezes at {:.1}°C", freezing_c.0);
}

// 4. 编译时类型检查示例
fn process_user_id<T: TypeCheck<UserId>>(id: T) {
    ensure_type!(T == UserId);
    println!("Processing valid user ID: {:?}", id);
}

fn type_check_example() {
    let valid_id = UserId::new(42);
    process_user_id(valid_id);  // 编译通过
    
    // 下面的代码会导致编译错误
    // let invalid_id = 42u64;
    // process_user_id(invalid_id);
}

// 5. 性能优化示例
#[optimize]
fn optimized_sum(values: &[i32]) -> i64 {
    values.iter().map(|&x| convert!(x as i64)).sum()
}

fn optimization_example() {
    let numbers = vec![1, 2, 3, 4, 5];
    let sum = optimized_sum(&numbers);
    println!("Optimized sum: {}", sum);
}

fn main() {
    println!("=== Basic Conversion Example ===");
    basic_conversion_example();
    
    println!("\n=== Custom Type Example ===");
    custom_type_example();
    
    println!("\n=== Temperature Conversion Example ===");
    temperature_conversion_example();
    
    println!("\n=== Type Check Example ===");
    type_check_example();
    
    println!("\n=== Optimization Example ===");
    optimization_example();
}

输出示例

运行上述代码将输出：

=== Basic Conversion Example ===
Basic conversion using macro: 42
Basic conversion using as_: 42
Basic conversion using into_: 42

=== Custom Type Example ===
Custom type example - User1: UserId(1001), User2: UserId(1001)

=== Temperature Conversion Example ===
Water boils at 212.0°F
Water freezes at 0.0°C

=== Type Check Example ===
Processing valid user ID: UserId(42)

=== Optimization Example ===
Optimized sum: 15

注意事项

1. 类型转换必须在编译时可知，无法处理动态类型转换
2. 自定义类型需要明确指定转换规则
3. 复杂的类型系统扩展可能会增加编译时间
4. 确保所有转换都是安全且合理的，避免精度丢失等问题
5. 合理使用优化注解，避免过度优化导致代码难以维护

lightning-types 为 Rust 开发者提供了更强大的类型系统操作能力，同时保持了 Rust 的核心优势。通过合理使用，可以在不牺牲性能的前提下，获得更灵活的类型处理能力。