Rust by Example

fn difference(container: &C) -> i32 {

container.last() - container.first()

}

fn main() {

let number_1 = 3;

let number_2 = 10;

let container = Container(number_1, number_2);

println!("Does container contain {} and {}: {}",

&number_1, &number_2,

container.contains(&number_1, &number_2));

println!("First number: {}", container.first());

println!("Last number: {}", container.last());

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

}

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

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Phantom type parameters

A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time.

Data types can use extra generic type parameters to act as markers or to perform type checking at compile time. These extra parameters hold no storage values, and have no runtime behavior.

In the following example, we combine std::marker::PhantomData with the phantom type parameter concept to create tuples containing different data types.

use std::marker::PhantomData;

// A phantom tuple struct which is generic over `A` with hidden parameter `B`.

#[derive(PartialEq)] // Allow equality test for this type.

struct PhantomTuple(A,PhantomData);

// A phantom type struct which is generic over `A` with hidden parameter `B`.

#[derive(PartialEq)] // Allow equality test for this type.

struct PhantomStruct { first: A, phantom: PhantomData }

// Note: Storage is allocated for generic type `A`, but not for `B`.

// Therefore, `B` cannot be used in computations.

fn main() {

// Here, `f32` and `f64` are the hidden parameters.

// PhantomTuple type specified as ``.

let _tuple1: PhantomTuple = PhantomTuple('Q', PhantomData);

// PhantomTuple type specified as ``.

let _tuple2: PhantomTuple = PhantomTuple('Q', PhantomData);

// Type specified as ``.

let _struct1: PhantomStruct = PhantomStruct {

first: 'Q',

phantom: PhantomData,

};

// Type specified as ``.

let _struct2: PhantomStruct = PhantomStruct {

first: 'Q',

phantom: PhantomData,

};

// Compile-time Error! Type mismatch so these cannot be compared:

//println!("_tuple1 == _tuple2 yields: {}",

// _tuple1 == _tuple2);

// Compile-time Error! Type mismatch so these cannot be compared:

//println!("_struct1 == _struct2 yields: {}",

// _struct1 == _struct2);

}