Ứng Dụng Type-State Pattern Trong Rust Để Ép Ràng Buộc An Toàn Tại Compile-Time

1. Ba Trụ Cột Kỹ Thuật Của Type-State Pattern

• 🏷️ Zero-Sized Types (ZSTs): Sử dụng các struct trống (không chứa dữ liệu) làm Marker Types để đại diện cho từng trạng thái (ví dụ: Draft, Pending, Shipped). Chúng không tiêu tốn bất kỳ dung lượng bộ nhớ nào khi chương trình thực thi.
• 🧬 Generic Structs: Struct chính của bạn sẽ nhận trạng thái làm tham số Generic (ví dụ: Order<State>). Thông qua std::marker::PhantomData, struct này có thể "ghi nhớ" thông tin trạng thái ở cấp độ kiểu dữ liệu mà không cần phải lưu trữ ZST bên trong memory layout.
• 🔄 Move Semantics (Quyền Sở Hữu): Các phương thức thực hiện chuyển đổi trạng thái sẽ nhận tham số self theo giá trị thay vì tham chiếu &self. Hành động này lập tức "tiêu thụ" (consume) biến cũ. Nếu lập trình viên vô tình gọi lại biến ở trạng thái cũ, trình biên dịch Rust sẽ báo lỗi "use of moved value" ngay lập tức.

2. Mô Phỏng Quy Trình Xử Lý Đơn Hàng An Toàn

Thay vì dùng các biến boolean (như is_paid) hoặc Enum để kiểm tra trạng thái tại runtime, Type-State pattern giúp API của bạn không thể bị dùng sai.

use std::marker::PhantomData;

// Các trạng thái (Marker Types)
pub struct Draft;
pub struct Paid;
pub struct Shipped;

// Struct chứa dữ liệu dùng chung cho mọi trạng thái
pub struct Order<T> {
    id: u32,
    total: f64,
    _state: PhantomData<T>,
}

// Trạng thái 1: Đơn nháp CHỈ CÓ THỂ thực hiện thanh toán
impl Order<Draft> {
    pub fn new(id: u32, total: f64) -> Self {
        Self { id, total, _state: PhantomData }
    }

    pub fn pay(self) -> Order<Paid> {
        println!("Đơn hàng {} đã được thanh toán.", self.id);
        Order { id: self.id, total: self.total, _state: PhantomData }
    }
}

// Trạng thái 2: Đơn đã thanh toán CHỈ CÓ THỂ giao hàng
impl Order<Paid> {
    pub fn ship(self) -> Order<Shipped> {
        println!("Đơn hàng {} đang trên đường giao.", self.id);
        Order { id: self.id, total: self.total, _state: PhantomData }
    }
}

fn main() {
    let order = Order::new(101, 500.0);
    
    // Hợp lệ: Thanh toán đơn nháp
    let paid_order = order.pay();
    
    // ❌ LỖI BIÊN DỊCH: order đã bị "consume", không thể gọi order.pay() hoặc order.ship()
    // ❌ LỖI BIÊN DỊCH: paid_order không có hàm pay(), ngăn chặn thanh toán 2 lần!
    // let double_pay = paid_order.pay(); 
    
    // Hợp lệ: Giao đơn hàng đã thanh toán
    let shipped_order = paid_order.ship();
}

3. So Sánh Type-State Pattern Và Cấu Trúc Trạng Thái Truyền Thống

• 🛑 Phát Hiện Lỗi: Type-State Pattern bắt lỗi trực tiếp ngay tại thời điểm biên dịch (Compile-time), trong khi cấu trúc trạng thái truyền thống (dùng Enum hoặc Boolean) chỉ phát hiện lỗi khi ứng dụng đang thực thi (Runtime).
• ⚡ Chi Phí Hiệu Suất: Type-State Pattern đạt hiệu suất tối ưu nhờ trừu tượng hóa chi phí bằng 0 (Zero-cost abstraction), loại bỏ hoàn toàn các câu lệnh điều kiện if/match tốn tài nguyên CPU ở runtime.
• 🧠 Trải Nghiệm Phát Triển (DX): Type-State Pattern cung cấp gợi ý thông minh từ IDE (Rust Analyzer) chỉ hiển thị các phương thức hợp lệ với trạng thái hiện tại, thay vì phải tự đọc tài liệu như cách làm cũ.
• 📦 Cấu Trúc Mã Nguồn: Type-State Pattern buộc lập trình viên phải chia nhỏ logic thành các block impl riêng biệt, trong khi cấu trúc truyền thống dễ dồn mọi hàm vào chung một struct dẫn đến mã nguồn rối rắm và dễ sinh ra lỗi logic ngầm.

Thiết kế kiến trúc theo hướng này giúp triệt tiêu hoàn toàn các lỗi panic do sử dụng unwrap() bừa bãi hoặc các lỗi nghiệp vụ nghiêm trọng (như tiến hành đóng gói một đơn hàng chưa hề được thanh toán). Mã nguồn Rust của bạn lúc này không chỉ nhanh, an toàn mà còn đóng vai trò như một bộ tài liệu tự động, định hướng người dùng API đi đúng luồng logic nghiệp vụ mà không cần một dòng chú thích nào.