Rust是否有将副作用编码为纯值的数据类型？如何实现类似Scala IO功能？

方法一：使用成熟异步运行时（Tokio） #

Rust生态没有内置的Cats Effect式IO类型，但可以通过异步运行时（如Tokio）实现类似的副作用编码与执行逻辑，这也是实际项目中的常用方案：

首先在Cargo.toml中添加依赖：

[dependencies]
tokio = { version = "1.35", features = ["macros", "rt-multi-thread"] }

对应代码实现：

use tokio;

#[tokio::main]
async fn main() {
    // 封装打印操作的异步任务，对应Scala中的IO.println
    let print_first = async { println!("hey!") };
    let print_second = async { println!("hey!") };

    // 按顺序执行两个任务，对应Scala的for推导式逻辑
    print_first.await;
    print_second.await;
}

方法二：手动实现简易IO类型（函数式练习场景） #

如果想更贴近Cats Effect IO将副作用封装为纯值的核心思想，可以手动实现一个极简版IO类型，帮助理解函数式编程中副作用管理的原理：

// 定义IO类型，本质是封装了一个产生副作用的闭包
struct IO<T>(Box<dyn FnOnce() -> T>);

impl<T> IO<T> {
    // 创建IO实例，将副作用逻辑包裹为纯值
    fn new<F: FnOnce() -> T + 'static>(f: F) -> Self {
        IO(Box::new(f))
    }

    // 执行IO，触发副作用（对应Scala的unsafeRunSync）
    fn unsafe_run_sync(self) -> T {
        (self.0)()
    }

    // 实现flat_map，支持链式调用（对应Scala for推导式的绑定逻辑）
    fn flat_map<U, F: FnOnce(T) -> IO<U> + 'static>(self, f: F) -> IO<U> {
        IO(Box::new(move || f(self.unsafe_run_sync()).unsafe_run_sync()))
    }
}

// 封装println为IO操作
fn io_println(s: &str) -> IO<()> {
    let s = s.to_string();
    IO::new(move || println!("{}", s))
}

fn main() {
    // 构建程序逻辑，对应Scala的for表达式
    let program = io_println("hey!")
        .flat_map(|_| io_println("hey!"));

    // 执行程序，触发副作用
    program.unsafe_run_sync();
}

补充说明 #

• 手动实现的IO类型完全遵循纯函数式思想：副作用仅在调用unsafe_run_sync时才会执行，在此之前它只是一个普通的纯值。
• 实际项目中更推荐使用Tokio这类成熟库，它支持异步调度、多线程、IO多路复用等生产级特性，而手动实现版本更适合用于函数式编程的学习与练习。

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