Tipos compuestos

	Tipos	Literales
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!("1st index: {}", t.0);
    println!("2nd index: {}", t.1);
}

Puntos clave:

Arrays:

Un valor del tipo array [T; N] contiene N (una constante en tiempo de compilación) elementos del mismo tipo T. Ten en cuenta que la longitud del array es parte de su tipo, lo que significa que [u8; 3] y [u8; 4] se consideran dos tipos diferentes.
Podemos usar literales para asignar valores a arrays.
En la función main, la instrucción de impresión solicita la implementación de depuración con el parámetro de formato ?: {} ofrece la salida predeterminada y {:?} ofrece la salida de depuración. También se podría haber usado {a} y {a:?} sin especificar el valor después de la cadena de formato.
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.
La tupla vacía () también se conoce como “tipo unitario”. Es a la vez un tipo y el único valor válido de ese tipo, es decir, tanto el tipo como su valor se expresan como (). Se usa para indicar, por ejemplo, que una función o expresión no tiene valor de retorno, como veremos en una diapositiva posterior.
- Podríamos pensar en ello como void, que quizá resulte familiar de otros lenguajes de programación.

Comprehensive Rust 🦀