Calling a method of a struct that was specified as generic, in Rust

I'm new to Rust and I'm playing with the generics. The following code, inspired by the same approach in C++, does not compile. I've read about Rust generics multiple times in many places, but could not find relevant examples.

The code:

struct A<T> {
	t: T
}

impl<T> A<T> {
	fn f(&self) {
		self.t.g();
	}
}

struct MyType;

impl MyType {
	fn g(&self) {
		println!("bingo");
	}
}

fn main() {
	let mut a: A<MyType> = A {
		t: MyType
	};

	a.f();
}

The idea is simple: concrete class MyType does have method g. But something is wrong here...

5 | impl<T> A<T> {
  |      - method `g` not found for this type parameter
6 |     fn f(&self) {
7 |         self.t.g();
  |                ^ method not found in `T`

What is a critical thing I'm missing? Thanks.

Despite the apparent similarity, generics in Rust are quite different from templates in C++. It's more helpful to think of A<T> as a "function" that, given any concrete type T, will give you a concrete type A<T>. Most importantly, just like function arguments are constraint by types and the set of available operations you can do on them is bound to their type, type generics are constraint by trait implementations.

In this case, there is no constraint over type T (besides some implicit constraints that you have to opt-out, such as the size of T is known at compile time), which also means that you can't do anything specific with T: your core has to work with any type T. If you want values of type T to have a method g, then you must add that constraint. In Rust, these constraints are expressed with traits.

trait HasMethodG {
  fn g(&self);
}

struct A<T> {
    t: T
}

impl<T: HasMethodG> A<T> {
    fn f(&self) {
        self.t.g();
    }
}

Also note that, it's not enough for a type to "be compatible with" a certain trait (as it may be in other languages). In Rust, you have to explicitly tell that you want MyType to implement HasMethodG. This means that the following doesn't compile

struct MyType;

impl MyType {
    fn g(&self) {
        println!("bingo");
    }
}

but this does

struct MyType;

impl HasMethodG for MyType {
    fn g(&self) {
        println!("bingo");
    }
}

Your method only makes sense when T is MyType, so you should write it in a non-generic impl block.

impl A<MyType> {
    fn f(&self) {
        self.t.g();
    }
}

If you have multiple types with a g method that you want this to work with, you need to make g a trait method and bind the generic to a trait.

trait G {
    fn g(&self);
}

impl G for MyType {
    fn g(&self) {
        println!("bingo");
    }
}

impl<T: G> A<T> {
    fn f(&self) {
        self.t.g();
    }
}