Rust函数记忆化库memoize-inner使用指南

简介

memoize-inner是一个高性能的Rust函数记忆化库，通过缓存函数调用的结果来实现自动结果复用。该库特别适用于计算密集型函数，能够显著减少重复计算的开销。

主要特性

• 线程安全的缓存实现
• 支持自定义缓存策略
• 零成本抽象设计
• 简单易用的API

安装方法

在Cargo.toml中添加依赖：

[dependencies]
memoize-inner = "0.1"

基本使用方法

1. 基本记忆化

use memoize_inner::memoize;

#[memoize]
fn fibonacci(n: u64) -> u64 {
    if n <= 1 {
        return n;
    }
    fibonacci(n - 1) + fibonacci(n - 2)
}

fn main() {
    // 第一次计算会被缓存
    println!("{}", fibonacci(10)); // 计算并缓存
    println!("{}", fibonacci(10)); // 直接从缓存读取
}

2. 带参数的函数

use memoize_inner::memoize;

#[memoize]
fn expensive_calculation(x: i32, y: i32) -> i32 {
    println!("执行计算: {} + {}", x, y);
    x + y
}

fn main() {
    println!("{}", expensive_calculation(2, 3)); // 输出"执行计算: 2 + 3"并返回5
    println!("{}", expensive_calculation(2, 3)); // 直接返回5，不输出信息
}

3. 自定义缓存容量

use memoize_inner::memoize;

#[memoize(Capacity = 100)]
fn cached_function(input: String) -> usize {
    input.len()
}

fn main() {
    // 最多缓存100个不同的输入结果
    println!("{}", cached_function("hello".to_string()));
}

高级用法

自定义哈希实现

use memoize_inner::memoize;
use std::hash::{Hash, Hasher};

#[derive(Clone)]
struct CustomType {
    data: String,
}

impl Hash for CustomType {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.data.hash(state);
    }
}

#[memoize]
fn process_custom_type(ct: CustomType) -> String {
    format!("Processed: {}", ct.data)
}

异步函数记忆化

use memoize_inner::memoize;
use tokio::time::{sleep, Duration};

#[memoize]
async fn async_operation(key: String) -> String {
    sleep(Duration::from_secs(1)).await;
    format!("Result for {}", key)
}

#[tokio::main]
async fn main() {
    let result = async_operation("test".to_string()).await;
    println!("{}", result);
}

性能建议

1. 对于小规模计算，记忆化可能带来额外开销
2. 合理设置缓存容量以避免内存溢出
3. 对于纯函数使用记忆化效果最佳

注意事项

• 记忆化函数应该是纯函数（相同输入总是产生相同输出）
• 注意内存使用情况，特别是缓存大量数据时
• 对于可变引用参数需要特殊处理

这个库通过简单的属性宏实现了强大的记忆化功能，是优化重复计算的理想选择。

完整示例demo

// 完整示例：展示memoize-inner库的各种用法
use memoize_inner::memoize;
use std::hash::{Hash, Hasher};
use tokio::time::{sleep, Duration};

// 基本记忆化示例：斐波那契数列
#[memoize]
fn fibonacci(n: u64) -> u64 {
    if n <= 1 {
        return n;
    }
    fibonacci(n - 1) + fibonacci(n - 2)
}

// 带参数的函数记忆化
#[memoize]
fn expensive_calculation(x: i32, y: i32) -> i32 {
    println!("执行计算: {} + {}", x, y);
    x + y
}

// 自定义缓存容量
#[memoize(Capacity = 100)]
fn cached_function(input: String) -> usize {
    input.len()
}

// 自定义类型支持
#[derive(Clone)]
struct CustomType {
    data: String,
}

impl Hash for CustomType {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.data.hash(state);
    }
}

#[memoize]
fn process_custom_type(ct: CustomType) -> String {
    format!("Processed: {}", ct.data)
}

// 异步函数记忆化
#[memoize]
async fn async_operation(key: String) -> String {
    sleep(Duration::from_secs(1)).await;
    format!("Result for {}", key)
}

fn main() {
    // 基本记忆化演示
    println!("=== 基本记忆化演示 ===");
    println!("第一次计算fibonacci(10): {}", fibonacci(10));
    println!("第二次计算fibonacci(10): {}", fibonacci(10)); // 从缓存读取
    
    // 带参数的函数演示
    println!("\n=== 带参数的函数演示 ===");
    println!("第一次计算: {}", expensive_calculation(2, 3));
    println!("第二次计算: {}", expensive_calculation(2, 3)); // 从缓存读取
    
    // 自定义缓存容量演示
    println!("\n=== 自定义缓存容量演示 ===");
    println!("字符串长度: {}", cached_function("hello".to_string()));
    
    // 自定义类型演示
    println!("\n=== 自定义类型演示 ===");
    let custom = CustomType { data: "test".to_string() };
    println!("处理结果: {}", process_custom_type(custom.clone()));
    println!("再次处理: {}", process_custom_type(custom)); // 从缓存读取
}

// 异步函数演示需要单独运行
#[tokio::main]
async fn async_main() {
    println!("\n=== 异步函数演示 ===");
    let result = async_operation("test".to_string()).await;
    println!("异步操作结果: {}", result);
    let result2 = async_operation("test".to_string()).await; // 从缓存读取
    println!("再次异步操作: {}", result2);
}

这个完整示例展示了memoize-inner库的所有主要功能，包括基本记忆化、带参数函数、自定义缓存容量、自定义类型支持以及异步函数记忆化。每个功能都有相应的演示代码和注释说明。