如何为嵌入式设备应用将数据建模为Rust类型？

针对你描述的嵌入式应用场景，我们可以通过枚举+结构体的组合，利用Rust的类型系统精准覆盖所有状态场景，同时清晰记录失败信息和连续失败次数。以下是具体实现：

1. 定义错误类型 #

首先区分不同的失败原因，方便后续处理和展示：

#[derive(Debug, Clone, PartialEq)]
enum FetchError {
    WifiConnectionFailed,
    ApiRequestFailed,
    // 可根据实际需求扩展其他错误类型（如超时、数据解析错误等）
}

2. 设计数据状态枚举 #

DataState<T>枚举直接映射你描述的所有业务场景，确保每种状态都是合法且明确的：

enum DataState<T> {
    // 应用启动时的初始状态：无任何数据
    Uninitialized,
    // 从未成功获取过数据，且最后一次获取失败
    FailedToInitialize(FetchError),
    // 持有历史数据，本次API请求失败（已连上WiFi但请求出错）
    StaleWithError(T, FetchError),
    // 持有历史数据，本次未发起请求（WiFi连接失败）
    StaleNoRequest(T),
    // 持有最新获取的有效数据
    Fresh(T),
}

3. 封装数据与失败统计 #

Data<T>结构体将状态与连续失败次数绑定，统一管理单API的数据生命周期：

struct Data<T> {
    state: DataState<T>,
    consecutive_failures: u32,
}

impl<T: Clone> Data<T> {
    // 创建初始状态的Data实例
    pub fn new() -> Self {
        Self {
            state: DataState::Uninitialized,
            consecutive_failures: 0,
        }
    }

    // 处理数据获取成功的情况：更新为新鲜数据，重置失败次数
    pub fn on_success(&mut self, new_data: T) {
        self.state = DataState::Fresh(new_data);
        self.consecutive_failures = 0;
    }

    // 处理WiFi连接失败：未发起API请求的场景
    pub fn on_wifi_failure(&mut self) {
        self.consecutive_failures += 1;
        // 根据当前状态转换为对应失败状态
        self.state = match &self.state {
            DataState::Uninitialized => DataState::FailedToInitialize(FetchError::WifiConnectionFailed),
            DataState::FailedToInitialize(_) => DataState::FailedToInitialize(FetchError::WifiConnectionFailed),
            DataState::StaleWithError(data, _) => DataState::StaleNoRequest(data.clone()),
            DataState::StaleNoRequest(data) => DataState::StaleNoRequest(data.clone()),
            DataState::Fresh(data) => DataState::StaleNoRequest(data.clone()),
        };
    }

    // 处理API请求失败：已连上WiFi但请求出错的场景
    pub fn on_api_failure(&mut self, error: FetchError) {
        self.consecutive_failures += 1;
        self.state = match &self.state {
            DataState::Uninitialized => DataState::FailedToInitialize(error),
            DataState::FailedToInitialize(_) => DataState::FailedToInitialize(error),
            DataState::StaleWithError(data, _) => DataState::StaleWithError(data.clone(), error),
            DataState::StaleNoRequest(data) => DataState::StaleWithError(data.clone(), error),
            DataState::Fresh(data) => DataState::StaleWithError(data.clone(), error),
        };
    }

    // 获取当前可展示的数据（用于UI渲染）
    pub fn get_display_data(&self) -> Option<&T> {
        match &self.state {
            DataState::Uninitialized | DataState::FailedToInitialize(_) => None,
            DataState::StaleWithError(data, _) | DataState::StaleNoRequest(data) | DataState::Fresh(data) => Some(data),
        }
    }

    // 获取当前的错误信息（用于展示警告）
    pub fn get_error(&self) -> Option<&FetchError> {
        match &self.state {
            DataState::Uninitialized => None,
            DataState::FailedToInitialize(err) => Some(err),
            DataState::StaleWithError(_, err) => Some(err),
            DataState::StaleNoRequest(_) => Some(&FetchError::WifiConnectionFailed),
            DataState::Fresh(_) => None,
        }
    }
}

4. 应用全局状态 #

AppState结构体整合多个API的数据状态，方便统一管理：

// 示例API响应类型（根据实际业务定义）
struct SensorData {
    temperature: f32,
    humidity: u8,
}

struct SystemStatus {
    battery_level: u8,
    uptime_sec: u32,
}

struct AppState {
    sensor_data: Data<SensorData>,
    system_status: Data<SystemStatus>,
}

impl AppState {
    pub fn new() -> Self {
        Self {
            sensor_data: Data::new(),
            system_status: Data::new(),
        }
    }
}

使用示例 #

在应用循环中，你可以根据不同的结果调用对应方法更新状态：

fn main() {
    let mut app_state = AppState::new();

    // 模拟第一次获取数据：WiFi失败
    app_state.sensor_data.on_wifi_failure();
    println!("连续失败次数: {}", app_state.sensor_data.consecutive_failures); // 输出1
    println!("可展示数据: {:?}", app_state.sensor_data.get_display_data()); // 输出None

    // 模拟后续获取：成功获取传感器数据
    let new_sensor_data = SensorData { temperature: 25.5, humidity: 60 };
    app_state.sensor_data.on_success(new_sensor_data);
    println!("连续失败次数: {}", app_state.sensor_data.consecutive_failures); // 输出0
    println!("可展示数据: {:?}", app_state.sensor_data.get_display_data()); // 输出Some(SensorData { ... })

    // 模拟下一次循环：API请求失败
    app_state.sensor_data.on_api_failure(FetchError::ApiRequestFailed);
    println!("连续失败次数: {}", app_state.sensor_data.consecutive_failures); // 输出1
    println!("错误信息: {:?}", app_state.sensor_data.get_error()); // 输出Some(ApiRequestFailed)
}

这种建模方式的优势在于：

• 利用Rust的类型安全，避免非法状态组合（比如无数据却尝试展示旧数据的情况）
• 所有状态转换逻辑封装在Data<T>的方法中，业务代码无需关心状态细节
• 清晰区分不同失败场景，方便展示针对性的警告信息

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