How to provide a proper type for use of generic impl?

Question

I'm trying to build up my intuition for associated types in Rust. In my experiments I build this (nonsensical) combination of generics and impl.

struct MyStruct<T>{
    t:T
}

trait MyTrait {
    type T1;
    fn tt(x:Self::T1) -> MyStruct<Self::T1>;
}

impl<T> MyTrait for MyStruct<T> {
    type T1=T;
    fn tt(a:Self::T1) -> MyStruct<Self::T1> {
        MyStruct{t:a}
    }

}

It compiles, but the problem is that I can't use 'tt' function.

fn main() {
    let x = MyTrait::tt(1);
}

causing an error: cannot infer type.

I've tried my options to provide type hints for Rust, but more I try the less audible (for me) error messages become.

Can someone provide me with example of use MyTrait::tt function from above, or is this a dead end? If so, why?

Answer 1

The trouble with using something like MyTrait::tt(1) is that the actual type that implements MyTrait can't be deduced from the argument 1. You could, for example, implement MyTrait for String, but make T1 be i32. With that setup, MyTrait::tt(1) could refer to <String as MyTrait>::tt (using the fully qualified method call syntax). On the other hand, you could also implement MyTrait for i32 with T1 = i32. Then MyTrait::tt(1) could also refer to <i32 as MyTrait>::tt.

impl MyTrait for String {
    type T1 = i32;
    fn tt(x: i32) -> MyStruct<i32> {
        MyStruct { t: x }
    }
}

impl MyTrait for i32 {
    type T1 = i32;
    fn tt(x: i32) -> MyStruct<i32> {
        MyStruct { t: x }
    }
}

fn main() {
    let x = 47_i32;

    // let y = MyTrait::tt(x);
    // That could refer to either of the following
    let y = <String as MyTrait>::tt(x);
    let z = <i32 as MyTrait>::tt(x);

    // Of course, you don't need the fully qualified syntax
    // all the time.
    let y2 = String::tt(x);
    let z2 = i32::tt(x);
}

(playground)

This behavior might be improved with smarter trait solvers since in your particular case, the only applicable implementation is the one on MyStruct<i32>. But for now, I'd just use <MyStruct<i32> as MyTrait>::tt(1) or simply MyStruct::tt(1).

fn main() {
    let x = <MyStruct<i32> as MyTrait>::tt(1);
    let x = MyStruct::tt(1);
}

(playground)

To learn more about traits and fully qualified syntax take a look in The Book's chapter on advanced traits.