Rust Basics

Tipos Genéricos

Crea una estructura donde uno de sus valores pueda ser de cualquier tipo.

struct Wrapper<T> {
    value: T,
}

impl<T> Wrapper<T> {
    pub fn new(value: T) -> Self {
        Wrapper { value }
    }
}

Wrapper::new(42).value
Wrapper::new("Foo").value, "Foo"

Option, Some y None

El tipo Option significa que el valor puede ser del tipo Some (hay algo) o None (nada):

pub enum Option<T> {
    None,
    Some(T),
}

Puedes usar funciones como is_some() o is_none() para comprobar el valor de la opción.

Macros

Las macros son más poderosas que las funciones porque se expanden para producir más código que el que has escrito manualmente. Por ejemplo, una firma de función debe declarar el número y el tipo de parámetros que tiene la función. Las macros, por otro lado, pueden tomar un número variable de parámetros: podemos llamar a println!("hello") con un argumento o println!("hello {}", name) con dos argumentos. Además, las macros se expanden antes de que el compilador interprete el significado del código, por lo que una macro puede, por ejemplo, implementar un rasgo en un tipo dado. Una función no puede hacerlo, porque se llama en tiempo de ejecución y un rasgo debe implementarse en tiempo de compilación.

macro_rules! my_macro {
    () => {
        println!("Check out my macro!");
    };
    ($val:expr) => {
        println!("Look at this other macro: {}", $val);
    }
}
fn main() {
    my_macro!();
    my_macro!(7777);
}

// Export a macro from a module
mod macros {
    #[macro_export]
    macro_rules! my_macro {
        () => {
            println!("Check out my macro!");
        };
    }
}

Iterar

// Iterate through a vector
let my_fav_fruits = vec!["banana", "raspberry"];
let mut my_iterable_fav_fruits = my_fav_fruits.iter();
assert_eq!(my_iterable_fav_fruits.next(), Some(&"banana"));
assert_eq!(my_iterable_fav_fruits.next(), Some(&"raspberry"));
assert_eq!(my_iterable_fav_fruits.next(), None); // When it's over, it's none
 
// One line iteration with action
my_fav_fruits.iter().map(|x| capitalize_first(x)).collect()

// Hashmap iteration
for (key, hashvalue) in &*map {
for key in map.keys() {
for value in map.values() {

Caja Recursiva

enum List {
    Cons(i32, List),
    Nil,
}

let list = Cons(1, Cons(2, Cons(3, Nil)));

Condicionales

if

let n = 5;
if n < 0 {
    print!("{} is negative", n);
} else if n > 0 {
    print!("{} is positive", n);
} else {
    print!("{} is zero", n);
}

match

El operador match en Rust es una forma de comparar un valor con una serie de patrones y ejecutar código en función de qué patrón coincida. Es similar a un switch en otros lenguajes de programación, pero con algunas diferencias clave.

La sintaxis básica de match es la siguiente:

match valor {
    patrón1 => {
        // código a ejecutar si el valor coincide con el patrón1
    },
    patrón2 => {
        // código a ejecutar si el valor coincide con el patrón2
    },
    _ => {
        // código a ejecutar si el valor no coincide con ninguno de los patrones anteriores
    }
}

Cada patrón puede ser una constante, una variable o una expresión más compleja. El guión bajo _ se utiliza como un comodín para capturar cualquier valor que no coincida con los patrones anteriores.

El operador match es muy útil para manejar diferentes casos en una función, especialmente cuando se trabaja con tipos de datos enumerados o estructuras de datos complejas.

match number {
    // Match a single value
    1 => println!("One!"),
    // Match several values
    2 | 3 | 5 | 7 | 11 => println!("This is a prime"),
    // TODO ^ Try adding 13 to the list of prime values
    // Match an inclusive range
    13..=19 => println!("A teen"),
    // Handle the rest of cases
    _ => println!("Ain't special"),
}

let boolean = true;
// Match is an expression too
let binary = match boolean {
    // The arms of a match must cover all the possible values
    false => 0,
    true => 1,
    // TODO ^ Try commenting out one of these arms
};

bucle (infinito)

loop {
    count += 1;
    if count == 3 {
        println!("three");
        continue;
    }
    println!("{}", count);
    if count == 5 {
        println!("OK, that's enough");
        break;
    }
}

while

Mientras que la condición especificada sea verdadera, el bucle while ejecutará repetidamente un bloque de código. La sintaxis es la siguiente:

while condición {
    // Código a ejecutar mientras la condición sea verdadera
}

La condición puede ser cualquier expresión booleana. Si la condición es verdadera, el código dentro del bloque se ejecutará. Si la condición es falsa, el bucle se detendrá y la ejecución continuará con el código que sigue al bloque while.

let mut n = 1;
while n < 101 {
    if n % 15 == 0 {
        println!("fizzbuzz");
    } else if n % 5 == 0 {
        println!("buzz");
    } else {
        println!("{}", n);
    }
    n += 1;
}

for

El bucle for se utiliza para iterar sobre una colección de elementos. La sintaxis básica es la siguiente:

for variable in coleccion {
    // Código a ejecutar en cada iteración
}

Donde variable es una variable que se actualizará en cada iteración con el valor del siguiente elemento de la coleccion. El código dentro del bloque de for se ejecutará una vez por cada elemento de la coleccion.

for n in 1..101 {
    if n % 15 == 0 {
        println!("fizzbuzz");
    } else {
        println!("{}", n);
    }
}

// Use "..=" to make inclusive both ends
for n in 1..=100 {
    if n % 15 == 0 {
        println!("fizzbuzz");
    } else if n % 3 == 0 {
        println!("fizz");
    } else if n % 5 == 0 {
        println!("buzz");
    } else {
        println!("{}", n);
    }
}

// ITERATIONS

let names = vec!["Bob", "Frank", "Ferris"];
//iter - Doesn't consume the collection
for name in names.iter() {
    match name {
        &"Ferris" => println!("There is a rustacean among us!"),
        _ => println!("Hello {}", name),
    }
}
//into_iter - COnsumes the collection
for name in names.into_iter() {
    match name {
        "Ferris" => println!("There is a rustacean among us!"),
        _ => println!("Hello {}", name),
    }
}
//iter_mut - This mutably borrows each element of the collection
for name in names.iter_mut() {
    *name = match name {
        &mut "Ferris" => "There is a rustacean among us!",
        _ => "Hello",
    }
}

if let

Si bien if let se puede usar para hacer coincidir patrones, su uso principal es verificar si una variable es Some(valor) y, si es así, desempaquetar el valor y ejecutar el bloque de código. Si la variable es None, el bloque de código no se ejecutará.

La sintaxis es la siguiente:

if let Some(valor) = variable {
    // Código a ejecutar si la variable es Some(valor)
} else {
    // Código a ejecutar si la variable es None
}

También se puede usar if let con Result<T, E> para manejar errores de manera más concisa.

let optional_word = Some(String::from("rustlings"));
if let word = optional_word {
    println!("The word is: {}", word);
} else {
    println!("The optional word doesn't contain anything");
}

while let

Mientras que

while let es una forma abreviada de escribir un bucle while que desempaqueta los valores de un patrón. Es útil cuando se trabaja con iteradores y se desea desempaquetar los valores de forma segura sin tener que preocuparse por los valores None.

Por ejemplo, el siguiente código utiliza un bucle while para desempaquetar los valores de un iterador:

let mut iter = vec![1, 2, 3].into_iter();

loop {
    match iter.next() {
        Some(x) => println!("{}", x),
        None => break,
    }
}

Este código se puede simplificar utilizando while let:

let mut iter = vec![1, 2, 3].into_iter();

while let Some(x) = iter.next() {
    println!("{}", x);
}

En este ejemplo, el bucle while let desempaqueta los valores de iter en la variable x hasta que iter se agota y devuelve None.

let mut optional = Some(0);
// This reads: "while `let` destructures `optional` into
// `Some(i)`, evaluate the block (`{}`). Else `break`.
while let Some(i) = optional {
    if i > 9 {
        println!("Greater than 9, quit!");
        optional = None;
    } else {
        println!("`i` is `{:?}`. Try again.", i);
        optional = Some(i + 1);
    }
    // ^ Less rightward drift and doesn't require
    // explicitly handling the failing case.
}

Traits

Crear un nuevo método para un tipo

trait AppendBar {
    fn append_bar(self) -> Self;
}

impl AppendBar for String {
    fn append_bar(self) -> Self{
        format!("{}Bar", self)
    }
}

let s = String::from("Foo");
let s = s.append_bar();
println!("s: {}", s);

Pruebas

#[cfg(test)]
mod tests {
    #[test]
    fn you_can_assert() {
        assert!(true);
        assert_eq!(true, true);
        assert_ne!(true, false);
    }
}

Hilos

Arc

Un Arc puede usar Clone para crear más referencias sobre el objeto para pasarlas a los hilos. Cuando el último puntero de referencia a un valor está fuera de alcance, la variable se elimina.

use std::sync::Arc;
let apple = Arc::new("the same apple");
for _ in 0..10 {
    let apple = Arc::clone(&apple);
    thread::spawn(move || {
        println!("{:?}", apple);
    });
}

Hilos

En este caso pasaremos al hilo una variable que podrá modificar.

fn main() {
    let status = Arc::new(Mutex::new(JobStatus { jobs_completed: 0 }));
    let status_shared = Arc::clone(&status);
    thread::spawn(move || {
        for _ in 0..10 {
            thread::sleep(Duration::from_millis(250));
            let mut status = status_shared.lock().unwrap();
            status.jobs_completed += 1;
        }
    });
    while status.lock().unwrap().jobs_completed < 10 {
        println!("waiting... ");
        thread::sleep(Duration::from_millis(500));
    }
}