如何使用特征默认方法中的BorrowMut超特征访问结构域？

Question

Consider the following Rust code

trait Trait {
    fn show_name(&self) {}
}

struct Foo {
    name: String,
    things_and_stuff: usize,
}

impl Trait for Foo {
    fn show_name(&self) {
        println!("{}", self.name);
    }
}

struct Bar {
    name: String,
    other_field: i32,
}

impl Trait for Bar {
    fn show_name(&self) {
        println!("{}", self.name);
    }
}

The two show_name functions have exactly the same code. It would be convenient if I could put that method as a default method on Trait , but that's not possible because traits cannot access struct fields.

We could declare a get_name(&self) -> &str method on Trait and implement it on Foo and Bar , but that doesn't fix the problem of having duplicated code because both implementations of get_name will be the same.

It would be nice to avoid the code duplication. Another question has already asked if field access is possible in traits, and the answer was basically "no". However, I found a comment in the rust-internals forum suggesting that it's already possible. Here's the code:

struct Fields {
    name: String,
}

trait Trait: BorrowMut<Fields> {
    // methods go here
}

impl<T> Trait for T where T: BorrowMut<Fields> {}

Presumably there's a way to make a type T be BorrowMut<Fields> and use that to allow Trait to access Fields 's fields, but so far I'm not sure how that would work.

How is the code snippet shown above supposed to solve the problem of getting field access in traits?

---

I know there are discussions of adding field access in traits to the language ( rust-internals , RFC , another RFC ), but I'd like to know what's possible now.

Answer 1

the answer was basically "no"

The answer actually says (emphasis mine):

A default implementation can only use methods that are defined on the trait or in a super trait .

That's what your snippet does:

trait Trait: BorrowMut<Fields>

---

To make it work, follow the advice from the post you are referencing:

all types which choose to implement BorrowMut<Foo>

Thus, you need to implement the trait for each of your types. I switched to Borrow because you don't need mutability here:

use std::borrow::Borrow;

struct Fields {
    name: String,
}

trait Trait: Borrow<Fields> {
    fn show_name(&self) {
        let fields: &Fields = self.borrow();
        println!("{}", fields.name);
    }
}

struct Foo {
    fields: Fields,
    things_and_stuff: usize,
}

impl Borrow<Fields> for Foo {
    fn borrow(&self) -> &Fields {
        &self.fields
    }
}

struct Bar {
    fields: Fields,
    other_field: i32,
}

impl Borrow<Fields> for Bar {
    fn borrow(&self) -> &Fields {
        &self.fields
    }
}

impl<T> Trait for T where T: Borrow<Fields> {}

I'm almost certain you won't like this solution because it

doesn't fix the problem of having duplicated code because both implementations [...] will be the same

You may prefer to write a macro if your goal is to reduce the number of duplicate characters in your code.

See also:

• I implemented a trait for another trait but cannot call methods from both traits
• Is it possible to access struct fields from within a trait?