Parámetros Phantom Type - Rust By Example
Description: Rust by Example (RBE) is a collection of runnable examples that illustrate various Rust concepts and standard libraries.

## Keyboard shortcuts

Press `←` or `→` to navigate between chapters

Press `S` or `/` to search in the book

Press `?` to show this help

Press `Esc` to hide this help

# Parámetros Phantom Type

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, B>(A, PhantomData<B>);

    // A phantom type struct which is generic over `A` with hidden parameter `B`.
    #[derive(PartialEq)] // Allow equality test for this type.
    struct PhantomStruct<A, B> { first: A, phantom: PhantomData<B> }

    // 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 `<char, f32>`.
        let _tuple1: PhantomTuple<char, f32> = PhantomTuple('Q', PhantomData);
        // PhantomTuple type specified as `<char, f64>`.
        let _tuple2: PhantomTuple<char, f64> = PhantomTuple('Q', PhantomData);

        // Type specified as `<char, f32>`.
        let _struct1: PhantomStruct<char, f32> = PhantomStruct {
            first: 'Q',
            phantom: PhantomData,
        };
        // Type specified as `<char, f64>`.
        let _struct2: PhantomStruct<char, f64> = 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);
    }

### Ver también

Derive, struct, and tuple.