Tipos Compuestos - Tylung/rust-apuntes GitHub Wiki

En Rust existen 2 tipos compuestos, es decir tipos de datos que pueden llegar a tener otros tipos de datos dentro de si mismos

Tuplas

El tipo de dato tupla es la forma general de agrugar juntos un numero de valores con una variedad de tipos, las tiplas fienen una longitud fija, una vez declaradas no pueden crecer o disminuir en su tamaño, entonces se dice que son inmutables y no cambian.

Ejemplo de las tuplas:

fn main() {
    let tup: (i32, f64, u8) = (500, 6.4, 1);
}

Los elementos de las tuplas se separan con una coma, es opcional poner la anotacion de los tipos, pero se recomienda ponerla para saber con que tipo de datos estamos trabajando

En el ejemplo la variable tup esta vinculada a la tupla entera, para obtener los valores individuales de la tupla podemos desestructurar los valores de la siguiente manera

fn main() {
    let tup = (500, 6.4, 1);

    let (x, y, z) = tup;
    // O también podemos obtenerlo por su posicion o indice en la tupla
    let one = tup.2 // 0 -> 500, 1 -> 6.4, 2 -> 1

    println!("El valor de y es: {y}");
    println!("El tercer elemento es {one}")
}

Nota: La tupla sin ningun valor () tiene un nombre especial, es unit, representa un valor vacio, o un valor de retorno vacio, Las expresiones retornan implicitamente el valor unit si no retornan algun otro valor

Los arreglos o arrays

Otra forma de coleccionar valores en es en un arreglo, a diferencia de otros lenguajes, en los arreglos de rust, todos los elementos deben de tener el mismo tipo de dato y la longitud del arreglo es fija

Escribimos los valores de un arreglo entre corchetes y separados por una coma:

fn main() {
    let a = [1, 2, 3, 4, 5];
    let meses = ["Enero", "Febrero", "Marzo"]
    // Los arreglos son muy utiles con valores que usted sabe que no van a cambiar

    let b: [i32; 5] = [1, 2, 3, 4, 5];
    // puede indicar el tipo de dato del  arreglo y
    // la cantidad de elementos en unos corchetes por separado
    let c = [3; 5];
    // todos se inicializaran en 3 -> [3, 3, 3, 3, 3]
}

Para acceder a los elementos de un arreglo, se pone el indice del elemento al que se quiere acceder

fn main() {
    let a = [1, 2, 3, 4, 5];

    let primero = a[0];
    let segundo = a[1];
}

Si se trata de acceder a un elemento fuera de la longitud del arreglo el programa dara un error como este

thread 'main' panicked at 'index out of bounds: the len is 5 but the index is 10', src/main.rs:19:19
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Este error lo arroja porque Rust sigue el principio de memory safety, par tener el maximo control de la memoria, pero si se accede a un espacio de memoria invalido arroja un panic error y deja de ejecutar el programa. En otros lenguajes de bajo nivel esto no pasa y se accede a una memoria invalida, causando memory leaks