Tuplas

Se puede ver este capítulo en Youtube en inglés

En Rust las tuplas usan (). Ya han aparecido muchas tuplas vacías ya que nada, en una función, realmente significa una tupla vacía:

fn do_something() {}

realmente es igual a:

fn do_something() -> () {}

Esta función no recibe ningún parámetro (recibe una tupla vacía) y no retorna ningún valor (una tupla vacía). Por eso, se han estado usando ya muchas tuplas en los ejemplos de capítulos anteriores. Cuando no se retorna ningún valor en una función, se está retornando una tupla vacía.

fn just_prints() {
    println!("Estoy imprimiendo"); // Al añadir un ;
    // como último dato antes de terminar la función
    // se está indicando que se debe retornar una tupla vacía
}

fn main() {}

Las tuplas pueden almacenar muchos tipos de elementos diferentes a la vez. Los elementos incluidos se indexan con números de 0 en adelante. Para acceder a ellos se utiliza el operador . en lugar de []. A continuación se incorporan datos de diferentes tipos en una única tupla:

fn main() {
    let random_tuple = ("Esto es un texto", 8, vec!['a'], 'b', [8, 9, 10], 7.7);
    println!(
        "El interior de la tupla contiene: Primer elemento: {:?}
Segundo elemento: {:?}
Tercer elemento: {:?}
Cuarto elemento: {:?}
Quinto elemento: {:?}
Sexto elemento: {:?}",
        random_tuple.0,
        random_tuple.1,
        random_tuple.2,
        random_tuple.3,
        random_tuple.4,
        random_tuple.5,
    )
}

Que imprime:

El interior de la tupla contiene: Primer elemento: "Esto es un texto"
Segundo elemento: 8
Tercer elemento: ['a']
Cuarto elemento: 'b'
Quinto elemento: [8, 9, 10]
Sexto elemento: 7.7

Esta tupla es de tipo (&str, i32, Vec<char>, char, [i32; 3], f64).

Se puede usar una tupla para crear múltiples variables. En el siguiente código:

fn main() {
    let str_vec = vec!["one", "two", "three"];
}

str_vec contiene tres elementos. ¿Cómo se pueden recuperar los tres valores de este vector en diferentes variables? Por ejemplo, con una tupla:

fn main() {
    let str_vec = vec!["one", "two", "three"];

    let (a, b, c) = (str_vec[0], str_vec[1], str_vec[2]); // las variables serán a, b, y c
    println!("{:?}", b);
}

El resultado del código anterior imprime "two", que es lo que contiene la variable b. A esta forma de extraer valores en variables se denomina desestructuramiento.

Si se necesita desestructurar un conjunto de elementos, pero no se quieren todos, se puede utilizar _.

fn main() {
    let str_vec = vec!["one", "two", "three"];

    let (_, _, variable) = (str_vec[0], str_vec[1], str_vec[2]);
}

El código anterior solo crea una variable denominada variable, pero no las crea para el resto de elementos.

Existen muchos más tipos colección y muchas formas adicionales de utilizar a los arrays, vectores y tuplas. Se enseñará más sobre ellos más adelante, pero primero, se enseñará la forma de controlar el flujo de ejecución de un programa.