Associated types

The use of “Associated types” improves the overall readability of code by moving inner types locally into a trait as output types. Syntax for the trait definition is as follows:

1. // `A` and `B` are defined in the trait via the `type` keyword.
2. // (Note: `type` in this context is different from `type` when used for
3. // aliases).
4. trait Contains {
5. type A;
6. type B;

8. // Updated syntax to refer to these new types generically.
9. fn contains(&self, &Self::A, &Self::B) -> bool;
10. }

Note that functions that use the trait Contains are no longer required to express A or B at all:

1. // Without using associated types
2. fn difference<A, B, C>(container: &C) -> i32 where
3. C: Contains<A, B> { ... }

5. // Using associated types
6. fn difference<C: Contains>(container: &C) -> i32 { ... }

Let’s rewrite the example from the previous section using associated types:

1. struct Container(i32, i32);

3. // A trait which checks if 2 items are stored inside of container.
4. // Also retrieves first or last value.
5. trait Contains {
6. // Define generic types here which methods will be able to utilize.
7. type A;
8. type B;

10. fn contains(&self, &Self::A, &Self::B) -> bool;
11. fn first(&self) -> i32;
12. fn last(&self) -> i32;
13. }

15. impl Contains for Container {
16. // Specify what types `A` and `B` are. If the `input` type
17. // is `Container(i32, i32)`, the `output` types are determined
18. // as `i32` and `i32`.
19. type A = i32;
20. type B = i32;

22. // `&Self::A` and `&Self::B` are also valid here.
23. fn contains(&self, number_1: &i32, number_2: &i32) -> bool {
24. (&self.0 == number_1) && (&self.1 == number_2)
25. }
26. // Grab the first number.
27. fn first(&self) -> i32 { self.0 }

29. // Grab the last number.
30. fn last(&self) -> i32 { self.1 }
31. }

33. fn difference<C: Contains>(container: &C) -> i32 {
34. container.last() - container.first()
35. }

37. fn main() {
38. let number_1 = 3;
39. let number_2 = 10;

41. let container = Container(number_1, number_2);

43. println!("Does container contain {} and {}: {}",
44. &number_1, &number_2,
45. container.contains(&number_1, &number_2));
46. println!("First number: {}", container.first());
47. println!("Last number: {}", container.last());

49. println!("The difference is: {}", difference(&container));
50. }