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.
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:
```rust
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.
Mientras que la condición especificada sea verdadera, el bucle `while` ejecutará repetidamente un bloque de código. La sintaxis es la siguiente:
```rust
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`.
El bucle `for` se utiliza para iterar sobre una colección de elementos. La sintaxis básica es la siguiente:
```rust
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`.
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:
```rust
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.
`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:
```rust
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`:
```rust
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`.
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.
