Testcase: unit clarification
- See also:

Testcase: unit clarification

A useful method of unit conversions can be examined by implementing Add with a phantom type parameter. The Add trait is examined below:

1. // This construction would impose: `Self + RHS = Output`
2. // where RHS defaults to Self if not specified in the implementation.
3. pub trait Add<RHS = Self> {
4. type Output;

6. fn add(self, rhs: RHS) -> Self::Output;
7. }

9. // `Output` must be `T<U>` so that `T<U> + T<U> = T<U>`.
10. impl<U> Add for T<U> {
11. type Output = T<U>;
12. ...
13. }

The whole implementation:

1. use std::ops::Add;
2. use std::marker::PhantomData;

4. /// Create void enumerations to define unit types.
5. #[derive(Debug, Clone, Copy)]
6. enum Inch {}
7. #[derive(Debug, Clone, Copy)]
8. enum Mm {}

10. /// `Length` is a type with phantom type parameter `Unit`,
11. /// and is not generic over the length type (that is `f64`).
12. ///
13. /// `f64` already implements the `Clone` and `Copy` traits.
14. #[derive(Debug, Clone, Copy)]
15. struct Length<Unit>(f64, PhantomData<Unit>);

17. /// The `Add` trait defines the behavior of the `+` operator.
18. impl<Unit> Add for Length<Unit> {
19. type Output = Length<Unit>;

21. // add() returns a new `Length` struct containing the sum.
22. fn add(self, rhs: Length<Unit>) -> Length<Unit> {
23. // `+` calls the `Add` implementation for `f64`.
24. Length(self.0 + rhs.0, PhantomData)
25. }
26. }

28. fn main() {
29. // Specifies `one_foot` to have phantom type parameter `Inch`.
30. let one_foot:  Length<Inch> = Length(12.0, PhantomData);
31. // `one_meter` has phantom type parameter `Mm`.
32. let one_meter: Length<Mm>   = Length(1000.0, PhantomData);

34. // `+` calls the `add()` method we implemented for `Length<Unit>`.
35. //
36. // Since `Length` implements `Copy`, `add()` does not consume
37. // `one_foot` and `one_meter` but copies them into `self` and `rhs`.
38. let two_feet = one_foot + one_foot;
39. let two_meters = one_meter + one_meter;

41. // Addition works.
42. println!("one foot + one_foot = {:?} in", two_feet.0);
43. println!("one meter + one_meter = {:?} mm", two_meters.0);

45. // Nonsensical operations fail as they should:
46. // Compile-time Error: type mismatch.
47. //let one_feter = one_foot + one_meter;
48. }

Testcase: unit clarification

Testcase: unit clarification

See also: