如何让String类型也能调用为&str实现的自定义trait方法？

你遇到的问题很常见：虽然String实现了Deref<Target = str>，但自定义trait的方法并不会自动通过Deref转换被调用——标准库的方法能直接用是因为它们是为str定义的，而Rust的方法调用解析逻辑对于自定义trait需要明确的实现。

下面提供两种优雅的解决方案：

方案一：直接为String实现你的Segmentation trait #

最简单的方式就是给String单独实现trait，逻辑和&str的实现几乎一致：

struct BreakGraphemes<'a> { slice: &'a str, }
impl<'a> Iterator for BreakGraphemes<'a> {
    type Item = &'a str;
    fn next(&mut self) -> Option<&'a str> {
        // 你的原有逻辑...
        let next_idx = self.slice.char_indices().next().map_or(0, |(i, _)| i + 1);
        if next_idx == 0 {
            None
        } else {
            let res = &self.slice[..next_idx];
            self.slice = &self.slice[next_idx..];
            Some(res)
        }
    }
}
trait Segmentation {
    fn break_graphemes(&self) -> BreakGraphemes;
}
impl Segmentation for &str {
    fn break_graphemes(&self) -> BreakGraphemes {
        BreakGraphemes { slice: self }
    }
}

// 新增String的实现
impl Segmentation for String {
    fn break_graphemes(&self) -> BreakGraphemes {
        BreakGraphemes { slice: self }
    }
}

fn main() {
    let s = String::from("Hello, ☝");
    for grapheme in s.break_graphemes() {
        println!("{}", grapheme.len());
    }
}

这样String就能直接调用break_graphemes方法了，逻辑和&str完全复用。

方案二：泛型实现，支持所有可Deref到str的类型 #

如果你希望你的trait能支持更多字符串相关类型（比如Cow<'_, str>、Box<str>等），可以用泛型为所有实现Deref<Target = str>的类型实现Segmentation：

use std::ops::Deref;

struct BreakGraphemes<'a> { slice: &'a str, }
impl<'a> Iterator for BreakGraphemes<'a> {
    type Item = &'a str;
    fn next(&mut self) -> Option<&'a str> {
        // 你的原有逻辑...
        let next_idx = self.slice.char_indices().next().map_or(0, |(i, _)| i + 1);
        if next_idx == 0 {
            None
        } else {
            let res = &self.slice[..next_idx];
            self.slice = &self.slice[next_idx..];
            Some(res)
        }
    }
}
trait Segmentation {
    fn break_graphemes(&self) -> BreakGraphemes;
}

// 泛型实现，覆盖所有能Deref到str的类型
impl<T: Deref<Target = str>> Segmentation for T {
    fn break_graphemes(&self) -> BreakGraphemes {
        BreakGraphemes { slice: self.deref() }
    }
}

fn main() {
    let s = String::from("Hello, ☝");
    for grapheme in s.break_graphemes() {
        println!("{}", grapheme.len());
    }

    // 同时支持&str
    let s_ref = "Hello, ☝";
    for grapheme in s_ref.break_graphemes() {
        println!("{}", grapheme.len());
    }

    // 也支持Box<str>
    let boxed_str: Box<str> = "Test".into();
    for grapheme in boxed_str.break_graphemes() {
        println!("{}", grapheme.len());
    }
}

这种方式一次实现就能支持所有符合条件的类型，扩展性更强。

为什么原来的代码不行？ #

当你调用s.break_graphemes()（s是String）时，Rust的方法解析逻辑会先检查String本身有没有这个方法，然后检查为String实现的所有trait中的方法。由于你只给&str实现了Segmentation，编译器找不到对应的实现——虽然String可以Deref到&str，但这个转换不会自动应用到trait方法的查找上（除非你显式写s.as_str().break_graphemes()，但这不够优雅）。

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