Rust类型系统扩展库corepc-types的使用：增强Rust类型安全与数据验证功能

简介

corepc-types是一个Rust库，旨在扩展Rust的类型系统，提供更强大的类型安全和数据验证功能。它通过引入新的类型和特性，帮助开发者构建更健壮、更不容易出错的应用程序。

主要功能

1. 增强的类型安全性
2. 运行时数据验证
3. 自定义类型约束
4. 与Rust原生类型系统无缝集成

安装

在Cargo.toml中添加依赖：

[dependencies]
corepc-types = "0.1"

基本用法

1. 使用验证类型

use corepc_types::Validated;

// 定义一个必须满足条件的i32类型
type PositiveInteger = Validated<i32, |&x| x > 0>;

fn process_positive(num: PositiveInteger) {
    println!("Processing positive number: {}", num.get());
}

fn main() {
    // 创建验证过的值
    match PositiveInteger::new(42) {
        Ok(num) => process_positive(num),
        Err(e) => println!("Validation failed: {}", e),
    }
    
    // 这会失败
    match PositiveInteger::new(-5) {
        Ok(_) => unreachable!(),
        Err(e) => println!("Expected failure: {}", e),
    }
}

2. 自定义类型约束

use corepc_types::{TypeConstrained, ValidationError};

struct Email(String);

impl TypeConstrained for Email {
    fn validate(value: &String) -> Result<(), ValidationError> {
        if value.contains('@') {
            Ok(())
        } else {
            Err(ValidationError::new("Not a valid email address"))
        }
    }
}

fn send_email(to: Email) {
    println!("Sending email to: {}", to.0);
}

fn main() {
    let valid = Email::new("user@example.com".to_string()).unwrap();
    send_email(valid);
    
    let invalid = Email::new("not-an-email".to_string());
    assert!(invalid.is_err());
}

3. 组合验证器

use corepc_types::{Validated, Validator};

fn is_even(x: &i32) -> bool {
    x % 2 == 0
}

fn is_positive(x: &i32) -> bool {
    *x > 0
}

// 组合两个验证条件
type EvenPositiveInteger = Validated<i32, Validator![is_even, is_positive]>;

fn main() {
    let num = EvenPositiveInteger::new(42).unwrap();
    println!("Valid number: {}", num.get());
    
    // 这会失败，因为不满足两个条件
    assert!(EvenPositiveInteger::new(-2).is_err());
    assert!(EvenPositiveInteger::new(3).is_err());
}

高级用法

1. 自定义错误消息

use corepc_types::{Validated, ValidationError};

fn check_password(password: &str) -> Result<(), ValidationError> {
    if password.len() < 8 {
        return Err(ValidationError::new("Password must be at least 8 characters"));
    }
    if !password.chars().any(|c| c.is_ascii_digit()) {
        return Err(ValidationError::new("Password must contain at least one digit"));
    }
    Ok(())
}

type SecurePassword = Validated<String, check_password>;

fn main() {
    match SecurePassword::new("weak".to_string()) {
        Ok(_) => unreachable!(),
        Err(e) => println!("Password error: {}", e),
    }
}

2. 与Serde集成

use corepc_types::{Validated, serde_helpers};
use serde::{Deserialize, Serialize};

#[derive(Debug, Serialize, Deserialize)]
struct User {
    #[serde(with = "serde_helpers")]
    age: Validated<i32, |&x| x >= 18>,
    name: String,
}

fn main() {
    let json = r#"{"name": "Alice", "age": 25}"#;
    let user: User = serde_json::from_str(json).unwrap();
    println!("Valid user: {:?}", user);
    
    let invalid_json = r#"{"name": "Bob", "age": 16}"#;
    let result: Result<User, _> = serde_json::from_str(invalid_json);
    assert!(result.is_err());
}

最佳实践

1. 在API边界使用验证类型，确保无效数据不会进入系统
2. 为常见验证模式创建类型别名
3. 组合简单验证器构建复杂验证逻辑
4. 利用类型系统在编译时捕获更多错误

corepc-types通过增强Rust的类型系统，帮助开发者构建更安全、更可靠的应用程序，同时保持Rust的性能和零成本抽象优势。

完整示例Demo

下面是一个结合了多种功能的完整示例，展示如何使用corepc-types构建一个用户注册系统：

use corepc_types::{Validated, TypeConstrained, ValidationError, Validator, serde_helpers};
use serde::{Deserialize, Serialize};

// 1. 定义各种验证类型
// 验证用户名：3-20个字符，只能包含字母和数字
type Username = Validated<String, Validator![check_username]>;
fn check_username(name: &str) -> bool {
    (3..=20).contains(&name.len()) && name.chars().all(|c| c.is_ascii_alphanumeric())
}

// 2. 自定义密码类型
struct Password(String);
impl TypeConstrained for Password {
    fn validate(value: &String) -> Result<(), ValidationError> {
        if value.len() < 8 {
            return Err(ValidationError::new("密码长度至少8位"));
        }
        if !value.chars().any(|c| c.is_ascii_uppercase()) {
            return Err(ValidationError::new("密码必须包含至少一个大写字母"));
        }
        if !value.chars().any(|c| c.is_ascii_digit()) {
            return Err(ValidationError::new("密码必须包含至少一个数字"));
        }
        Ok(())
    }
}

// 3. 与Serde集成的用户年龄验证
#[derive(Debug, Serialize, Deserialize)]
struct UserAge(#[serde(with = "serde_helpers")] Validated<i32, |&x| (13..=120).contains(x)>);

// 4. 完整的用户结构体
#[derive(Debug)]
struct User {
    username: Username,
    password: Password,
    age: UserAge,
    email: Email,  // 使用之前定义的Email类型
}

fn main() {
    // 测试用户名验证
    match Username::new("user123".to_string()) {
        Ok(name) => println!("有效用户名: {}", name.get()),
        Err(e) => println!("用户名错误: {}", e),
    }

    // 测试密码验证
    match Password::new("Weak1".to_string()) {
        Ok(_) => unreachable!(),
        Err(e) => println!("密码错误: {}", e),
    }

    // 测试JSON反序列化
    let json_data = r#"{"username":"alice123","age":25}"#;
    match serde_json::from_str::<UserAge>(json_data) {
        Ok(age) => println!("有效年龄: {:?}", age),
        Err(e) => println!("年龄错误: {}", e),
    }
}

这个完整示例展示了：

1. 使用Validated创建自定义验证类型
2. 实现TypeConstrained trait进行复杂验证
3. 与Serde集成进行序列化/反序列化
4. 组合多种验证类型构建安全的用户系统

每个组件都经过严格验证，确保数据的完整性和安全性。