Rust 中的每个泛型是否都必须实现某些特征才能拥有“方法”？

Question

I don't have control over A and B below, they come from a library. Both implement the hello method, and I'd like to create a function that acts on both, but I don't want to reuse code. On C++, it does not check if a template parameter implements any methods, it just checks if the type in the instantiation implements the method. Take a look:

pub struct A {
    x: u8,
}

impl A {
    pub fn new() -> A {
        A { x: 0 }
    }
    pub fn hello() {
        println!("hello")
    }
}

pub struct B {
    x: u8,
}

impl B {
    pub fn new() -> B {
        B { x: 1 }
    }
    pub fn hello() {
        println!("hello")
    }
}

pub fn say_hello<T>() {
    let t: T = T::new();
    t.hello();
}

fn main() {
    say_hello::<A>();
    say_hello::<B>();
}

This wont compile because it says T does not have the say_hello method. Since this is from a library, I cannot implement a trait for them. So there's nothing I can do here? I'll have to duplicate code?

Note that it can be known at compile time if both the intantiation types A and B have the hello method. C++ wouldn't care.

Answer 1

TLDR: yes.

C++'s templates are indeed differ from generic types (particularly in Rust). The first one works by substitution without digging into the type at time of item definition, but only at time of use . So in C++, I believe, it is possible to create a templated item that at the same time compiles and cannot have an instantiation because of conflicting requirements.

This is not the case for generic types in Rust, these are checked while you define a generic item, eg T in fn f<T>(..) {..} . So the compiler analyzes all of the usages of the type T and its instances so these are used properly.

So in general yes, you need to have a trait bound to use types' methods. As for your case this might be a preferred solution:

trait Hello {
    fn say_hello();
}

impl Hello for A {
    fn say_hello() {
        A::hello()
    }
}

impl Hello for B {
    fn say_hello() {
        B::hello()
    }
}

If you'd like to have a behavior similar to templates in C++ you may take a look at macros :

macro_rules! say_hello {
    ($t:ty) => {{
        <$t>::hello()
    }}
}

fn main() {
    say_hello!(A);
    say_hello!(B);
}