Rust类型名称美化库pretty-type-name的使用

pretty-type-name是一个提供更简洁类型名称输出的Rust库，它是std::any::type_name的简化版本。

示例

use pretty_type_name::pretty_type_name;

mod foo {
    pub mod bar {
        pub struct X<T>(T);
    }

    pub struct Y;
}

println!(pretty_type_name::<foo::bar::X<foo::Y>>());
// 输出 `X<Y>`

完整示例代码

// 引入pretty_type_name库
use pretty_type_name::pretty_type_name;

// 定义嵌套模块和结构体
mod outer {
    pub mod inner {
        pub struct Container<T, U> {
            pub first: T,
            pub second: U,
        }
        
        pub enum MyEnum {
            VariantA,
            VariantB(i32),
        }
    }
    
    pub struct MyStruct;
}

fn main() {
    // 打印复杂类型名称
    println!("{}", pretty_type_name::<outer::inner::Container<i32, f64>>());
    // 输出: Container<i32, f64>
    
    println!("{}", pretty_type_name::<outer::inner::MyEnum>());
    // 输出: MyEnum
    
    println!("{}", pretty_type_name::<Vec<outer::MyStruct>>());
    // 输出: Vec<MyStruct>
    
    println!("{}", pretty_type_name::<Option<Result<String, std::io::Error>>>());
    // 输出: Option<Result<String, Error>>
}

这个库的主要用途是在调试或日志记录时提供更简洁易读的类型名称输出，相比标准库的type_name函数，它会去掉冗长的模块路径前缀，只保留最简洁的类型名称表示方式。

要使用这个库，只需在Cargo.toml中添加依赖：

pretty-type-name = "1.0.1"

然后就可以像示例中那样使用pretty_type_name函数来获取简化后的类型名称了。

sinazl 1楼

Rust类型名称美化库pretty-type-name使用指南

pretty-type-name是一个Rust库，用于将复杂的类型名称转换为更清晰易读的格式，特别适合调试和日志输出场景。

主要特性

简化复杂类型名称
移除编译器生成的混淆信息
保留类型结构的同时提高可读性

安装

在Cargo.toml中添加依赖：

[dependencies]
pretty-type-name = "0.1"

基本用法

use pretty_type_name::pretty_type_name;

fn main() {
    let x = 42i32;
    println!("原始类型名: {}", std::any::type_name_of_val(&x));
    println!("美化后类型名: {}", pretty_type_name(&x));
}

输出示例：

原始类型名: i32
美化后类型名: i32

复杂类型示例

use std::collections::HashMap;

fn main() {
    let map: HashMap<String, Vec<Box<dyn std::fmt::Debug>>> = HashMap::new();
    
    println!("原始类型名: {}", std::any::type_name_of_val(&map));
    println!("美化后类型名: {}", pretty_type_name(&map));
}

输出对比：

原始类型名: std::collections::hash::map::HashMap<alloc::string::String, alloc::vec::Vec<alloc::boxed::Box<dyn core::fmt::Debug>>>
美化后类型名: HashMap<String, Vec<Box<dyn Debug>>>

自定义类型处理

struct MyStruct<T>(T);

fn main() {
    let x = MyStruct(42u64);
    println!("美化后类型名: {}", pretty_type_name(&x));
}

输出：

美化后类型名: MyStruct<u64>

高级用法 - 自定义美化规则

use pretty_type_name::{pretty_type_name, PrettyTypeName};

struct MyLongTypeName;

impl PrettyTypeName for MyLongTypeName {
    fn pretty_type_name() -> String {
        "ShortName".to_string()
    }
}

fn main() {
    let x = MyLongTypeName;
    println!("美化后类型名: {}", pretty_type_name(&x));
}

输出：

美化后类型名: ShortName

在错误处理中使用

fn process<T>(value: T) -> Result<(), String> {
    // 模拟错误
    Err(format!("处理类型 {} 时出错", pretty_type_name(&value)))
}

fn main() {
    let result = process(vec![1, 2, 3]);
    println!("{:?}", result);
}

输出：

Err("处理类型 Vec<i32> 时出错")

完整示例demo

下面是一个结合多种用法的完整示例：

use pretty_type_name::{pretty_type_name, PrettyTypeName};
use std::collections::HashMap;

// 自定义类型
struct MyContainer<T>(Vec<T>);

// 实现自定义美化规则
struct ServerResponse;

impl PrettyTypeName for ServerResponse {
    fn pretty_type_name() -> String {
        "Response".to_string()
    }
}

fn main() {
    // 基本类型示例
    let num = 42u64;
    println!("基本类型:");
    println!("原始: {}", std::any::type_name_of_val(&num));
    println!("美化: {}", pretty_type_name(&num));
    println!();

    // 复杂泛型示例
    let complex: HashMap<String, MyContainer<Box<dyn std::fmt::Debug>>> = HashMap::new();
    println!("复杂泛型类型:");
    println!("原始: {}", std::any::type_name_of_val(&complex));
    println!("美化: {}", pretty_type_name(&complex));
    println!();

    // 自定义类型示例
    let container = MyContainer(vec![1, 2, 3]);
    println!("自定义泛型类型:");
    println!("美化: {}", pretty_type_name(&container));
    println!();

    // 自定义美化规则示例
    let response = ServerResponse;
    println!("自定义美化规则:");
    println!("美化: {}", pretty_type_name(&response));
    println!();

    // 在错误处理中使用
    match process_data(container) {
        Ok(_) => println!("处理成功"),
        Err(e) => println!("错误: {}", e),
    }
}

fn process_data<T>(data: MyContainer<T>) -> Result<(), String> {
    // 模拟处理失败
    Err(format!("无法处理类型: {}", pretty_type_name(&data)))
}