一起聊聊在Rust中使用枚举表示状态_编程技术

许多具有系统编程背景的Rust初学者倾向于使用bool(甚至u8—8位无符号整数类型)来表示“状态”。

例如，如何使用bool来指示用户是否处于活动状态？

struct User {
    // ...
    active: bool,
}

一开始，这可能看起来不错，但是随着代码库的增长，会发现“active”不是二进制状态。用户可以处于许多不同的状态，用户可能被挂起或删除。但是，扩展User结构体可能会出现问题，因为代码的其他部分有可能依赖active是bool类型。

另一个问题是bool不是自文档化的。active = false是什么意思？用户是否处于非活动状态，或者用户被删除了，或者用户被挂起了？我们不知道！

或者，可以使用一个无符号整数来表示状态：

struct User {
    // ...
    status: u8,
}

这稍微好一点，因为我们现在可以使用不同的值来表示更多的状态：

const ACTIVE: u8 = 0;
const INACTIVE: u8 = 1;
const SUSPENDED: u8 = 2;
const DELETED: u8 = 3;

let user = User {
    // ...
    status: ACTIVE,
};

u8的一个常见用例是与C代码交互，在这种情况下，使用u8似乎是唯一的选择。我们还可以将u8包装在一个新类型中！

struct User {
    // ...
    status: UserStatus,
}

struct UserStatus(u8);

const ACTIVE: UserStatus = UserStatus(0);
const INACTIVE: UserStatus = UserStatus(1);
const SUSPENDED: UserStatus = UserStatus(2);
const DELETED: UserStatus = UserStatus(3);

let user = User {
    // ...
    status: ACTIVE,
};

这样我们就可以在UserStatus上定义方法：

impl UserStatus {
    fn is_active(&self) -> bool {
        self.0 == ACTIVE.0
    }
}

我们甚至还可以定义一个构造函数来验证输入：

impl UserStatus {
    fn new(status: u8) -> Result<Self, &'static str> {
        match status {
            ACTIVE.0 => Ok(ACTIVE),
            INACTIVE.0 => Ok(INACTIVE),
            SUSPENDED.0 => Ok(SUSPENDED),
            DELETED.0 => Ok(DELETED),
            _ => Err("Invalid status"),
        }
    }
}

使用枚举表示状态

枚举是为域内的状态建模的好方法。它们以一种非常简洁的方式表达你的意图。

#[derive(Debug)]
pub enum UserStatus {
    /// 用户是活跃的，可以完全访问他们的帐户和任何相关功能。
    Active,

    /// 用户的帐户处于非活动状态。该状态可由用户或管理员恢复为激活状态。
    Inactive,

     /// 该用户的帐户已被暂时暂停，可能是由于可疑活动或违反政策。
    /// 在此状态下，用户无法访问其帐户，并且可能需要管理员的干预才能恢复帐户。
    Suspended,

    /// 该用户的帐号已被永久删除，无法恢复。
    /// 与该帐户关联的所有数据都可能被删除，用户需要创建一个新帐户才能再次使用该服务。
    Deleted,
}

我们可以将这个枚举插入到User结构体中：

struct User {
    // ...
    status: UserStatus,
}

但这还不是全部。在Rust中，枚举比许多其他语言强大得多。例如，可以向枚举变量中添加数据：

#[derive(Debug)]
pub enum UserStatus {
    Active,
    Inactive,
    Suspended { until: DateTime<Utc> },
    Deleted { deleted_at: DateTime<Utc> },
}

我们还可以表示状态转换：

use chrono::{DateTime, Utc};

#[derive(Debug)]
pub enum UserStatus {
    Active,
    Inactive,
    Suspended { until: DateTime<Utc> },
    Deleted { deleted_at: DateTime<Utc> },
}

impl UserStatus {
    /// 暂停用户直到指定日期
    fn suspend(&mut self, until: DateTime<Utc>) {
        match self {
            UserStatus::Active => *self = UserStatus::Suspended { until },
            _ => {}
        }
    }

    /// 激活用户
    fn activate(&mut self) -> Result<(), &'static str> {
        match self {
            // A deleted user can't be activated!
            UserStatus::Deleted { .. } => return Err("can't activate a deleted user"),
            _ => *self = UserStatus::Active
        }
        Ok(())
    }

    /// 删除用户，这是一个永久的动作！
    fn delete(&mut self) {
        if let UserStatus::Deleted { .. } = self {
            // 已经删除，不要再设置deleted_at字段。
            return;
        }
        *self = UserStatus::Deleted {
            deleted_at: Utc::now(),
        }
    }

    fn is_active(&self) -> bool {
        matches!(self, UserStatus::Active)
    }

    fn is_suspended(&self) -> bool {
        matches!(self, UserStatus::Suspended { .. })
    }

    fn is_deleted(&self) -> bool {
        matches!(self, UserStatus::Deleted { .. })
    }
}

#[cfg(test)]
mod tests {
    use chrono::Duration;
    use super::*;

    #[test]
    fn test_user_status() -> Result<(), &'static str>{
        let mut status = UserStatus::Active;
        assert!(status.is_active());
        // 暂停到明天
        status.suspend(Utc::now() + Duration::days(1));
        assert!(status.is_suspended());
        status.activate()?;
        assert!(status.is_active());
        status.delete();
        assert!(status.is_deleted());
        Ok(())
    }

    #[test]
    fn test_user_status_transition() {
        let mut status = UserStatus::Active;
        assert!(status.is_active());
        status.delete();
        assert!(status.is_deleted());
        // 无法激活已删除的用户
        assert!(status.activate().is_err());
    }
}

看看我们仅仅用几行代码就涵盖了多少内容！我们可以放心地扩展应用程序，因为我们知道不会意外地删除用户两次或重新激活已删除的用户。非法的状态转换现在是不可能的！

使用枚举与C代码交互

C代码：

typedef struct {
    uint8_t status;
} User;

User *create_user(uint8_t status);

你可以写一个Rust枚举来表示状态：

#[repr(u8)]
#[derive(Debug, PartialEq)]
pub enum UserStatus {
    Active = 0,
    Inactive,
    Suspended,
    Deleted,
}

impl TryFrom<u8> for UserStatus {
    type Error = ();

    fn try_from(value: u8) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(UserStatus::Active),
            1 => Ok(UserStatus::Inactive),
            2 => Ok(UserStatus::Suspended),
            3 => Ok(UserStatus::Deleted),
            _ => Err(()),
        }
    }
}

注意到#[repr(u8)]属性了吗？它告诉编译器将此枚举表示为无符号8位整数。这对于与C代码的兼容性至关重要。

现在，让我们用一个安全的Rust包装器包装C函数：

extern "C" {
    fn create_user(status: u8) -> *mut User;
}

pub fn create_user_wrapper(status: UserStatus) -> Result<User, &'static str> {
    let user = unsafe { create_user(status as u8) };
    if user.is_null() {
        Err("Failed to create user")
    } else {
        Ok(unsafe { *Box::from_raw(user) })
    }
}

Rust代码现在使用丰富的enum类型与C代码通信。