El patrón ref

Cuando se realiza una coincidencia de patrones o desestructuración a través del vínculo let, la palabra clave ref se puede usar para tomar referencias a los campos de una estructura/tupla. El siguiente ejemplo muestra algunos casos en los que esto puede resultar útil:

#[derive(Clone, Copy)]
struct Punto { x: i32, y: i32 }

fn main() {
    let c = 'Q';

    // Un préstamo `ref` en el lado izquierdo de una asignación es equivalente a
    // un `&` prestado en el lado derecho.
    let ref ref_c1 = c;
    let ref_c2 = &c;

    println!("ref_c1 es igual a ref_c2: {}", *ref_c1 == *ref_c2);

    let punto = Punto { x: 0, y: 0 };

    // `ref` también es válido cuando se desestructura una estructura.
    let _copia_de_x = {
        // `ref_a_x` es una referencia al campo `x` de `punto`.
        let Punto { x: ref ref_a_x, y: _ } = punto;

        // Devuelve una copia del campo `x` de `punto`.
        *ref_a_x
    };

    // Una copia mutable de `punto`
    let mut punto_mutable = punto;

    {
        // `ref` se puede emparejar con `mut` para tomar referencias mutables.
        let Punto { x: _, y: ref mut ref_mut_a_y } = punto_mutable;

      // Muta el campo `y` de `punto_mutable` mediante una referencia mutable.
        *ref_mut_a_y = 1;
    }

    println!("punto es ({}, {})", punto.x, punto.y);
    println!("punto_mutable es ({}, {})", punto_mutable.x, punto_mutable.y);

    // Una tupla mutable que incluye un puntero
    let mut tupla_mutable = (Box::new(5u32), 3u32);
    
    {
        // Desestructura `tupla_mutable` para cambiar el valor de `ultimo`.
        let (_, ref mut ultimo) = tupla_mutable;
        *ultimo = 2u32;
    }
    
    println!("tupla es {:?}", tupla_mutable);
}