Derivar

El compilador es capaz de proporcionar implementaciones básicas para algunos rasgos a través del #[derive] atributo. Estos rasgos aún se pueden implementar manualmente si se requiere un comportamiento más complejo.

La siguiente es una lista de rasgos derivables:

  • Rasgos de comparación: Eq, PartialEq, Ord, PartialOrd.
  • Clone, para crear T a partir de &T mediante una copia.
  • Copiar, para dar un tipo 'copiar semántica' en lugar de 'mover semántica'.
  • Hash, para calcular un hash de &T.
  • Default, para crear una instancia vacía de un tipo de datos.
  • Debug, para formatear un valor usando el formateador {:?}.
// `Centimetros`, una estructura de tupla que se puede comparar
#[derive(PartialEq, PartialOrd)]
struct Centimetros(f64);

// `Pulgadas`, una estructura de tupla que se puede imprimir
#[derive(Debug)]
struct Pulgadas(i32);

impl Pulgadas {
    fn en_centimetros(&self) -> Centimetros {
        let &Pulgadas(inches) = self;

        Centimetros(inches as f64 * 2.54)
    }
}

// `Segundos`, una estructura de tupla sin atributos adicionales
struct Segundos(i32);

fn main() {
    let _un_segundo = Segundos(1);

    // Error: `Segundos` no se pueden imprimir; no implementa el rasgo `Debug`
    //println!("Un segundo se ve así: {:?}", _un_segundo);
    // TODO ^ Intenta descomentar esta línea

    // Error: `Segundos` no se pueden comparar; no implementa el rasgo `PartialEq`
    //let _esto_es_verdad = (_un_segundo == _un_segundo);
    // TODO ^ Intenta descomentar esta línea

    let pie = Pulgadas(12);

    println!("Un pie es igual a {:?}", pie);

    let metro = Centimetros(100.0);

    let cmp =
        if pie.en_centimetros() < metro {
            "más pequeño"
        } else {
            "más grande"
        };

    println!("Un pie es {} que un metro.", cmp);
}

Ve también

derive