Rust by Example

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

Derive, struct, and TupleStructs

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:

// This construction would impose: `Self + RHS = Output`

// where RHS defaults to Self if not specified in the implementation.

pub trait Add {

type Output;

fn add(self, rhs: RHS) -> Self::Output;

}

// `Output` must be `T` so that `T + T = T`.

impl Add for T {

type Output = T;

...

}

The whole implementation:

use std::ops::Add;

use std::marker::PhantomData;

/// Create void enumerations to define unit types.

#[derive(Debug, Clone, Copy)]

enum Inch {}

#[derive(Debug, Clone, Copy)]

enum Mm {}

/// `Length` is a type with phantom type parameter `Unit`,

/// and is not generic over the length type (that is `f64`).

///

/// `f64` already implements the `Clone` and `Copy` traits.

#[derive(Debug, Clone, Copy)]

struct Length(f64, PhantomData);

/// The `Add` trait defines the behavior of the `+` operator.

impl Add for Length {

type Output = Length;

// add() returns a new `Length` struct containing the sum.

fn add(self, rhs: Length) -> Length {

// `+` calls the `Add` implementation for `f64`.

Length(self.0 + rhs.0, PhantomData)

}

}

fn main() {

// Specifies `one_foot` to have phantom type parameter `Inch`.

let one_foot: Length = Length(12.0, PhantomData);

// `one_meter` has phantom type parameter `Mm`.

let one_meter: Length = Length(1000.0, PhantomData);

// `+` calls the `add()` method we implemented for `Length`.

//

// Since `Length` implements `Copy`, `add()` does not consume

// `one_foot` and `one_meter` but copies them into `self` and `rhs`.

let two_feet = one_foot + one_foot;

let two_meters = one_meter + one_meter;

// Addition works.

println!("one foot + one_foot = {:?} in", two_feet.0);

println!("one meter + one_meter = {:?} mm", two_meters.0);

// Nonsensical operations fail as they should:

// Compile-time Error: type mismatch.

//let one_feter = one_foot + one_meter;

}