在学习 Rust 的过程中，实践是非常重要的一环。今天我们要通过一个有趣的练习来探讨 Rust 中的数据类型、控制流和函数设计。这个练习模拟了一个汽车装配线的生产效率计算问题。

问题背景

想象一下，你正在为一个汽车制造厂开发生产效率监控系统。这个工厂有一条装配线，可以根据不同的速度生产汽车。但实际情况是，当装配线运行速度越高时，故障率也会增加，从而影响整体效率。

我们的任务是计算在给定速度下，装配线的生产效率。

代码实现

首先，我们需要定义两个函数：

// This stub file contains items which aren't used yet; feel free to remove this module attribute
// to enable stricter warnings.
#![allow(unused)]

pub fn production_rate_per_hour(speed: u8) -> f64 {
    let base_rate = (speed as f64) * 221.0;
    match speed {
        0 => base_rate,
        1..=4 => base_rate,
        5..=8 => base_rate * 0.9,
        9..=10 => base_rate * 0.77,
        _ => 0.0,
    }
}

pub fn working_items_per_minute(speed: u8) -> u32 {
    (production_rate_per_hour(speed) / 60.0) as u32
}

代码解析

让我们逐步分析这段代码的关键部分：

1. 数据类型的选择

pub fn production_rate_per_hour(speed: u8) -> f64

这里我们使用 u8 作为速度参数的类型，因为速度是一个非负整数，且范围不会超过 255。返回值使用 f64 是因为需要处理小数计算。

2. 模式匹配的使用

match speed {
    0 => base_rate,
    1..=4 => base_rate,
    5..=8 => base_rate * 0.9,
    9..=10 => base_rate * 0.77,
    _ => 0.0,
}

我们使用 Rust 强大的模式匹配功能来处理不同的速度范围：

• 速度 0：生产率为 0
• 速度 1-4：正常效率（100%）
• 速度 5-8：效率降低 10%（90%）
• 速度 9-10：效率降低 23%（77%）
• 其他情况：无效输入，返回 0

3. 类型转换

let base_rate = (speed as f64) * 221.0;

这里我们使用 as 关键字将 u8 类型的速度转换为 f64 类型，以便进行浮点数运算。

4. 函数复用

pub fn working_items_per_minute(speed: u8) -> u32 {
    (production_rate_per_hour(speed) / 60.0) as u32
}

第二个函数直接复用了第一个函数的结果，通过除以 60 得到每分钟的生产数量，并转换为 u32 类型。

测试用例

为了确保我们的实现正确，我们编写了以下测试用例：

fn process_rate_per_hour(speed: u8, expected_rate: f64) {
    assert!((assembly_line::production_rate_per_hour(speed) - expected_rate).abs() < f64::EPSILON);
}

fn process_rate_per_minute(speed: u8, expected_rate: u32) {
    assert_eq!(
        assembly_line::working_items_per_minute(speed),
        expected_rate
    );
}

#[test]
fn production_rate_per_hour_at_speed_zero() {
    process_rate_per_hour(0, 0.0);
}

#[test]
fn production_rate_per_hour_at_speed_one() {
    process_rate_per_hour(1, 221.0);
}

#[test]
fn production_rate_per_hour_at_speed_four() {
    process_rate_per_hour(4, 884.0);
}

#[test]
fn production_rate_per_hour_at_speed_seven() {
    process_rate_per_hour(7, 1392.3);
}

#[test]
fn production_rate_per_hour_at_speed_nine() {
    process_rate_per_hour(9, 1531.53);
}

#[test]
fn production_rate_per_minute_at_speed_zero() {
    process_rate_per_minute(0, 0);
}

#[test]
fn production_rate_per_minute_at_speed_one() {
    process_rate_per_minute(1, 3);
}

#[test]
fn production_rate_per_minute_at_speed_five() {
    process_rate_per_minute(5, 16);
}

#[test]
fn production_rate_per_minute_at_speed_eight() {
    process_rate_per_minute(8, 26);
}

#[test]
fn production_rate_per_minute_at_speed_ten() {
    process_rate_per_minute(10, 28);
}

Rust 特性展示

这个练习展示了 Rust 的多个重要特性：

1. 类型安全：通过使用适当的数值类型（u8, f64, u32）确保数据的正确性
2. 模式匹配：使用 match 表达式处理不同的速度范围，比 if-else 更清晰
3. 表达式导向：Rust 中的 match 是表达式，可以直接返回值
4. 函数复用：一个函数可以有效地使用另一个函数的结果

实际应用场景

这种计算模式在实际开发中非常常见：

• 游戏开发中的等级系统计算
• 金融系统中的利率计算
• 物流系统中的效率优化计算
• 电商系统中的折扣计算

总结

通过这个简单的练习，我们不仅学会了如何使用 Rust 的基本语法，还体验了 Rust 在类型安全和表达力方面的优势。模式匹配让代码更加清晰易读，而类型系统帮助我们在编译时就能发现潜在的错误。

在后续的 Rust 练习中，我们将继续探索更多有趣和实用的语言特性。