如何避免含泛型字段的结构体构造函数显式类型注解？

你的代码核心问题在于Foo结构体包含两个泛型参数B和T，但new函数仅能提供B的类型信息，编译器无法自动推导T，因此必须强制用户标注类型。以下是几种无需用户手动标注类型的重构方案：

方案一：移除冗余的T泛型，使用Deref trait约束 #

大多数情况下，你需要的Borrow行为可以通过Deref trait实现——String、&str、Arc<T>、Rc<T>等类型都默认实现了Deref，可以自动解引用到目标类型。重构后的代码如下：

use std::sync::Arc;

struct Foo<B> {
    borrow: B,
}

impl<B> Foo<B> {
    fn new(borrow: B) -> Self {
        Self { borrow }
    }
}

impl<B> Foo<B> 
where 
    B: std::ops::Deref,
    <B as std::ops::Deref>::Target: std::fmt::Display,
{
    fn print(&self) {
        println!("{}", &*self.borrow);
    }
}

fn main() {
    // 自有字符串，无需类型注解
    let f = Foo::new(String::from("hello"));
    f.print();

    // 字符串切片，无需类型注解
    let f = Foo::new("hello");
    f.print();

    // Arc包裹的字符串，无需类型注解
    let f = Foo::new(Arc::new(String::from("hello")));
    f.print();
}

说明： #

• 移除了PhantomData<T>和T泛型参数，结构体仅保留存储实际数据的B类型
• 通过Deref约束，确保B可以解引用到一个实现了Display的目标类型
• &*self.borrow是解引用操作的简写，等价于self.borrow.deref()，能统一获取目标类型的引用

方案二：使用AsRef trait（针对字符串场景优化） #

如果你的实际需求仅针对字符串类型（如示例中的String、&str、Arc<String>），可以直接使用AsRef<str>约束，代码更简洁：

use std::sync::Arc;

struct Foo<B> {
    borrow: B,
}

impl<B> Foo<B> {
    fn new(borrow: B) -> Self {
        Self { borrow }
    }
}

impl<B> Foo<B> where B: AsRef<str> {
    fn print(&self) {
        println!("{}", self.borrow.as_ref());
    }
}

fn main() {
    let f = Foo::new(String::from("hello"));
    f.print();

    let f = Foo::new("hello");
    f.print();

    let f = Foo::new(Arc::new(String::from("hello")));
    f.print();
}

说明： #

• AsRef<str>被String、&str、Arc<String>等类型广泛实现，能直接获取字符串切片引用
• 完全避免了泛型推导歧义，编译器可以直接确定目标类型

方案三：自定义默认Borrow trait（通用场景） #

如果你的需求是支持自定义的Borrow目标类型（而非依赖Deref或AsRef），可以定义一个带关联类型的trait来指定默认目标：

use std::sync::Arc;
use std::fmt::Display;

// 定义自定义trait，指定默认的borrow目标类型
trait DefaultBorrow {
    type Target: Display;
    fn default_borrow(&self) -> &Self::Target;
}

// 为String实现默认borrow到str
impl DefaultBorrow for String {
    type Target = str;
    fn default_borrow(&self) -> &str {
        self.as_str()
    }
}

// 为字符串切片实现默认borrow到自身
impl DefaultBorrow for &str {
    type Target = str;
    fn default_borrow(&self) -> &str {
        self
    }
}

// 为Arc<String>实现默认borrow到str
impl DefaultBorrow for Arc<String> {
    type Target = str;
    fn default_borrow(&self) -> &str {
        self.as_str()
    }
}

struct Foo<B> {
    borrow: B,
}

impl<B> Foo<B> {
    fn new(borrow: B) -> Self {
        Self { borrow }
    }
}

impl<B> Foo<B> where B: DefaultBorrow {
    fn print(&self) {
        println!("{}", self.borrow.default_borrow());
    }
}

fn main() {
    let f = Foo::new(String::from("hello"));
    f.print();

    let f = Foo::new("hello");
    f.print();

    let f = Foo::new(Arc::new(String::from("hello")));
    f.print();
}

说明： #

• 通过自定义trait为每种类型指定默认的borrow目标，完全消除泛型推导歧义
• 扩展性强，可以为任意类型添加自定义的默认borrow逻辑

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