Erroneous code example:
```compile_fail,E0223
-trait MyTrait {type X; }
+trait Trait { type X; }
fn main() {
- let foo: MyTrait::X;
+ let foo: Trait::X;
}
```
-The problem here is that we're attempting to take the type of X from MyTrait.
-Unfortunately, the type of X is not defined, because it's only made concrete in
-implementations of the trait. A working version of this code might look like:
+The problem here is that we're attempting to take the associated type of `X`
+from `Trait`. Unfortunately, the type of `X` is not defined, because it's only
+made concrete in implementations of the trait. A working version of this code
+might look like:
```
-trait MyTrait {type X; }
-struct MyStruct;
+trait Trait { type X; }
-impl MyTrait for MyStruct {
+struct Struct;
+impl Trait for Struct {
type X = u32;
}
fn main() {
- let foo: <MyStruct as MyTrait>::X;
+ let foo: <Struct as Trait>::X;
}
```
-This syntax specifies that we want the X type from MyTrait, as made concrete in
-MyStruct. The reason that we cannot simply use `MyStruct::X` is that MyStruct
-might implement two different traits with identically-named associated types.
-This syntax allows disambiguation between the two.
+This syntax specifies that we want the associated type `X` from `Struct`'s
+implementation of `Trait`.
+
+Due to internal limitations of the current compiler implementation we cannot
+simply use `Struct::X`.