Rust本地化处理库with_locals的使用：高效管理多语言和本地化资源的插件库

基本示例：返回/生成引用本地变量的format_args

use ::core::fmt::Display;
use ::with_locals::with;

#[with('local)]
fn hex(n: u32) -> &'local dyn Display
{
    &format_args!("{:#x}", n)
}

上面的代码会被转换为：

use ::core::fmt::Display;

fn with_hex<R, F>(n: u32, f: F) -> R
where           F : FnOnce(&'_     dyn Display) -> R,
 // for<'local> F : FnOnce(&'local dyn Display) -> R,
{
    f(&format_args!("{:#x}", n))
}

这里的f: F被称为"continuation"(延续)： 不是让函数返回/生成某个元素/对象，而是接收调用者想要对该元素执行的逻辑， 这样实际处理对象的是被调用者而不是调用者。

使用示例

with_hex(66, |s| {
    println!("{}", s);
})

嵌套使用示例

with_hex(1, |one| {
    with_hex(2, |two| {
        with_hex(3, |three| {
            // 嵌套层级过深...
        })
    })
})

使用#[with]宏可以简化：

#[with] let one = hex(1);
#[with] let two = hex(2); 
#[with] let three = hex(3);

完整示例代码

use ::core::fmt::Display;
use ::with_locals::with;

#[with('local)]
fn hex(n: u32) -> &'local dyn Display {
    &format_args!("{:#x}", n)
}

#[with]
fn hex_example() {
    let s: String = {
        println!("Hello, World!");
        #[with]
        let s_hex = hex(66);
        println!("s_hex = {}", s_hex); // 输出`s_hex = 0x42`
        let s = s_hex.to_string();
        assert_eq!(s, "0x42");
        s
    };
    assert_eq!(s, "0x42");
}

#[with]
fn main() {
    for n in 0.. {
        #[with]
        let s = hex(n);
        println!("{}", s);
        if n >= 5 {
            break;
        }
    };
}

特性方法示例

use ::with_locals::with;

trait ToStr {
    #[with('local)]
    fn to_str(self: &'_ Self) -> &'local str;
}

impl ToStr for u32 {
    #[with('local)]
    fn to_str(self: &'_ u32) -> &'local str {
        let mut x = *self;
        if x == 0 {
            return "0";
        }
        let mut buf = [b' '; 1 + 3 + 3 + 3]; // u32::MAX ~ 4_000_000_000
        let mut cursor = buf.len();
        while x > 0 {
            cursor -= 1;
            buf[cursor] = b'0' + (x % 10) as u8;
            x /= 10;
        }
        ::core::str::from_utf8(&buf[cursor..])
            .unwrap()
    }
}

#[with('special)]
fn main() {
    let s: &'special str = 42.to_str();
    assert_eq!(s, "42");
}

高级用法示例

use ::core::fmt::Display;
use ::with_locals::with;

#[with('local, continuation_name = return_)]
fn display_addr(addr: usize) -> &'local dyn Display {
    if addr == 0 {
        return_!(&"NULL");
    }
    with_hex(addr, |hex| {
        return_(&format_args!("0x{}", hex))
    })
}

#[with('local)]
fn hex(n: usize) -> &'local dyn Display {
    &format_args!("{:x}", n)
}

调试宏展开

在Cargo.toml中启用expand-macros特性：

[dependencies]
with_locals = { version = "...", features = ["expand-macros"] }

然后可以使用环境变量过滤特定展开：

WITH_LOCALS_DEBUG_FILTER=pattern cargo check

完整示例demo

以下是一个结合了上述特性的完整示例：

use ::core::fmt::Display;
use ::with_locals::with;

// 定义16进制格式化函数
#[with('local)]
fn hex(n: u32) -> &'local dyn Display {
    &format_args!("{:#x}", n)
}

// 定义数字转字符串特性
trait ToStr {
    #[with('local)]
    fn to_str(self: &'_ Self) -> &'local str;
}

impl ToStr for u32 {
    #[with('local)]
    fn to_str(self: &'_ u32) -> &'local str {
        let mut x = *self;
        if x == 0 {
            return "0";
        }
        let mut buf = [b' '; 10]; // 足够存储u32最大值
        let mut cursor = buf.len();
        while x > 0 {
            cursor -= 1;
            buf[cursor] = b'0' + (x % 10) as u8;
            x /= 10;
        }
        ::core::str::from_utf8(&buf[cursor..]).unwrap()
    }
}

#[with]
fn main() {
    // 使用hex函数
    #[with]
    let hex_value = hex(255);
    println!("Hex value: {}", hex_value); // 输出 Hex value: 0xff
    
    // 使用ToStr特性
    #[with]
    let str_value = 12345.to_str();
    println!("String value: {}", str_value); // 输出 String value: 12345
    
    // 组合使用
    #[with]
    let combined = hex(42);
    println!("Combined: {}", combined); // 输出 Combined: 0x2a
    
    // 嵌套使用
    #[with]
    let nested = {
        #[with]
        let a = hex(10);
        #[with]
        let b = hex(20);
        format!("{} + {} = {}", a, b, 10 + 20)
    };
    println!("Nested: {}", nested); // 输出 Nested: 0xa + 0x14 = 30
}