Tuplas y arrays

Las tuplas y los arrays son los primeros tipos "compuestos" que hemos estudiado. Todos los elementos de un array tienen el mismo tipo, mientras que las tuplas admiten distintos tipos. Ambos tipos tienen un tamaño fijo durante el tiempo de compilación.

TiposLiterales
Arrays[T; N][20, 30, 40], [0; 3]
Tuplas(), (T,), (T1, T2), ...(), ('x',), ('x', 1.2), ...

Asignación y acceso a arrays:

fn main() {
    let mut a: [i8; 10] = [42; 10];
    a[5] = 0;
    println!("a: {a:?}");
}

Asignación y acceso a tuplas:

fn main() {
    let t: (i8, bool) = (7, true);
    println!("t.0: {}", t.0);
    println!("t.1: {}", t.1);
}
This slide should take about 10 minutes.

Puntos clave:

Arrays:

  • A value of the array type [T; N] holds N (a compile-time constant) elements of the same type T. Note that the length of the array is part of its type, which means that [u8; 3] and [u8; 4] are considered two different types. Slices, which have a size determined at runtime, are covered later.

  • Prueba a acceder a un array que esté fuera de los límites. Los accesos a los arrays se comprueban en el tiempo de ejecución. Rust suele optimizar estas comprobaciones y se pueden evitar utilizando Rust inseguro.

  • Podemos usar literales para asignar valores a arrays.

  • The println! macro asks for the debug implementation with the ? format parameter: {} gives the default output, {:?} gives the debug output. Types such as integers and strings implement the default output, but arrays only implement the debug output. This means that we must use debug output here.

  • Si se añade #, por ejemplo {a:#?}, se da formato al texto para facilitar la lectura.

Tuplas:

  • Al igual que los arrays, las tuplas tienen una longitud fija.

  • Las tuplas agrupan valores de diferentes tipos en un tipo compuesto.

  • Se puede acceder a los campos de una tupla por el punto y el índice del valor, por ejemplo, t.0, t.1.

  • The empty tuple () is also known as the "unit type". It is both a type, and the only valid value of that type --- that is to say both the type and its value are expressed as (). It is used to indicate, for example, that a function or expression has no return value, as we'll see in a future slide.

    • You can think of it as void that can be familiar to you from other programming languages.