Rust中无需指定泛型，引用带泛型Trait的动态变量可行吗？

能否在Rust中拥有一个变量，它持有实现了带泛型Trait的类型，却无需指定该泛型？在Java、JavaScript等语言中，我们可以仅基于实例实现的接口来处理实例，这是接口与多态的常见特性。

我想要实现一个网络爬虫，每个站点有不同的爬取策略，E是描述爬取队列条目的类型（不同站点类型不同）。为此我定义了CrawlResult<E>结构体、带泛型<E>的Site Trait，以及工厂函数make_site来创建实现Site的实例。处理Site的代码只需要不透明地传递E给同一实例的其他方法即可，但代码编译失败。

原代码 #

pub struct CrawlResult<E> {
    pub discovered_queue_entries: Vec<E>,
    pub result: Option<String>,
}

pub trait Site<E> {
    fn start_queue(&self) -> Vec<E>;
    fn crawl(&self, queue_entry: &E) -> CrawlResult<E>;
}

fn make_site<E>() -> Box<dyn Site<E>> {
    if rand::random() {
        Box::new(SiteA { add: 100 })
    } else {
        Box::new(SiteB { sub: 1 })
    }
}

fn main() {
    let site = make_site();

    process(&site);
}

编译错误信息 #

error[E0277]: the trait bound `SiteA: Site<E>` is not satisfied
   --> src/main.rs:103:9
    |
103 |         Box::new(SiteA { add: 100 })
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Site<E>` is not implemented for `SiteA`
    |
    = note: required for the cast from `Box<SiteA>` to `Box<(dyn Site<E> + 'static)>`
help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
    |
101 | fn make_site<E>() -> Box<dyn Site<E>> where SiteA: Site<E> {
    |                                       ++++++++++++++++++++

error[E0277]: the trait bound `SiteB: Site<E>` is not satisfied
   --> src/main.rs:105:9
    |
105 |         Box::new(SiteB { sub: 1 })
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Site<E>` is not implemented for `SiteB`
    |
    = note: required for the cast from `Box<SiteB>` to `Box<(dyn Site<E> + 'static)>`
help: consider introducing a `where` clause, but there might be an alternative better way to express this requirement
    |
101 | fn make_site<E>() -> Box<dyn Site<E>> where SiteB: Site<E> {
    |                                       ++++++++++++++++++++

error[E0277]: the trait bound `Box<dyn Site<_>>: Site<_>` is not satisfied
   --> src/main.rs:112:13
    |
112 |     process(&site);
    |             ^^^^^ the trait `Site<_>` is not implemented for `Box<dyn Site<_>>`
    |
    = help: the following other types implement trait `Site<E>`:
              <SiteA as Site<SiteAEntry>>
              <SiteB as Site<SiteBEntry>>
    = note: required for the cast from `&Box<dyn Site<_>>` to `&dyn Site<_>`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground` (bin "playground") due to 3 previous errors

解决方案：使用关联类型代替泛型参数 #

问题的核心是：你的Site Trait使用了泛型参数<E>，这意味着每个Site<E>都是不同的Trait类型（比如Site<SiteAEntry>和Site<SiteBEntry>是完全不同的Trait），无法统一成一个dyn Site对象。

改用关联类型可以让每个Site实现自行定义对应的队列条目类型，这样Trait本身不需要泛型参数，就能创建统一的Trait对象。

修改后的完整代码 #

use rand;

pub struct CrawlResult<E> {
    pub discovered_queue_entries: Vec<E>,
    pub result: Option<String>,
}

// 使用关联类型代替泛型参数
pub trait Site {
    type Entry; // 每个实现指定自己的队列条目类型

    fn start_queue(&self) -> Vec<Self::Entry>;
    fn crawl(&self, queue_entry: &Self::Entry) -> CrawlResult<Self::Entry>;
}

// 示例实现SiteA及其对应的Entry
struct SiteA {
    add: i32,
}

struct SiteAEntry {
    url: String,
}

impl Site for SiteA {
    type Entry = SiteAEntry;

    fn start_queue(&self) -> Vec<Self::Entry> {
        vec![SiteAEntry { url: "https://sitea.com/start".to_string() }]
    }

    fn crawl(&self, queue_entry: &Self::Entry) -> CrawlResult<Self::Entry> {
        CrawlResult {
            discovered_queue_entries: vec![SiteAEntry { url: format!("{}/page1", queue_entry.url) }],
            result: Some(format!("Fetched {} with add {}", queue_entry.url, self.add)),
        }
    }
}

// 示例实现SiteB及其对应的Entry
struct SiteB {
    sub: i32,
}

struct SiteBEntry {
    path: String,
}

impl Site for SiteB {
    type Entry = SiteBEntry;

    fn start_queue(&self) -> Vec<Self::Entry> {
        vec![SiteBEntry { path: "/start".to_string() }]
    }

    fn crawl(&self, queue_entry: &Self::Entry) -> CrawlResult<Self::Entry> {
        CrawlResult {
            discovered_queue_entries: vec![SiteBEntry { path: format!("{}/page2", queue_entry.path) }],
            result: Some(format!("Fetched {} with sub {}", queue_entry.path, self.sub)),
        }
    }
}

// 工厂函数返回统一的dyn Site对象
fn make_site() -> Box<dyn Site> {
    if rand::random() {
        Box::new(SiteA { add: 100 })
    } else {
        Box::new(SiteB { sub: 1 })
    }
}

// 处理Site的函数，不透明处理Entry类型
fn process(site: &dyn Site) {
    let mut queue = site.start_queue();
    while let Some(entry) = queue.pop() {
        let result = site.crawl(&entry);
        if let Some(content) = result.result {
            println!("{}", content);
        }
        queue.extend(result.discovered_queue_entries);
    }
}

fn main() {
    let site = make_site();
    process(&site);
}

关键说明 #

• 关联类型的作用：Site Trait中的type Entry是关联类型，每个实现必须指定自己的Entry类型，这样dyn Site就成为一个统一的Trait对象类型，不再依赖外部泛型参数。
• 对象安全：修改后的Site Trait是对象安全的，可以被转换成dyn Site trait对象，因为所有方法的签名都只依赖于关联类型，而不是外部泛型参数。
• 不透明处理Entry：process函数不需要知道Entry的具体类型，只需要将它从start_queue获取，再传递给crawl方法即可，完全符合你想要的不透明传递需求。

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