feat(content): add pattern matching content

content/2.basic/7.pattern-matching.md

@@ -0,0 +1,174 @@
+---
+title: 'Pattern Matching/Desestruct'
+description: 'Entendiendo Pattern Matching y Desestructuración en Rust: Exhaustividad y Seguridad'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: -700
+    y: 440
+  width: 320
+  externalLinks:
+    - name: 'Libro Oficial'
+      english: false
+      link: 'https://book.rustlang-es.org/ch06-02-match'
+    - name: 'Comprehensive Rust'
+      english: false
+      link: 'https://google.github.io/comprehensive-rust/es/pattern-matching/destructuring.html'
+---
+### Entendiendo Pattern Matching y Desestructuración en Rust: Exhaustividad y Seguridad
+
+Rust es un lenguaje de programación que combina eficiencia y seguridad sin sacrificar el control sobre los detalles de bajo nivel. Una de las características más poderosas de Rust es su sistema de pattern matching y desestructuración. Estas herramientas permiten escribir código más expresivo y manejable, garantizando al mismo tiempo la exhaustividad en el control de flujo. En este blog post, exploraremos cómo funcionan el pattern matching y la desestructuración en Rust, así como su exhaustividad y beneficios.
+
+#### ¿Qué es Pattern Matching?
+
+Pattern matching es una característica que permite comparar una estructura de datos contra varios patrones y, si hay una coincidencia, descomponer la estructura en sus componentes. Rust utiliza la palabra clave `match` para pattern matching, lo que hace que el código sea más legible y manejable.
+
+##### Ejemplo Básico
+
+```rust
+enum Color {
+    Red,
+    Green,
+    Blue,
+}
+
+fn main() {
+    let color = Color::Green;
+
+    match color {
+        Color::Red => println!("Color rojo"),
+        Color::Green => println!("Color verde"),
+        Color::Blue => println!("Color azul"),
+    }
+}
+```
+
+En este ejemplo, `match` se utiliza para determinar el valor de la variable `color` y ejecutar el código correspondiente a cada variante del enum `Color`.
+
+#### Exhaustividad en Pattern Matching
+
+Una de las características más importantes del pattern matching en Rust es su exhaustividad. Esto significa que todos los casos posibles deben ser manejados, lo que garantiza que no se pase por alto ningún caso. Si se olvida un caso, el compilador emitirá un error, asegurando que se aborden todas las posibilidades.
+
+##### Ejemplo de Exhaustividad
+
+```rust
+enum Animal {
+    Perro,
+    Gato,
+}
+
+fn main() {
+    let mascota = Animal::Perro;
+
+    match mascota {
+        Animal::Perro => println!("Es un perro"),
+        Animal::Gato => println!("Es un gato"),
+        // Falta un caso: Rust emitirá un error si se agrega una variante nueva sin manejarla
+    }
+}
+```
+
+En este ejemplo, si se añadiera una nueva variante al enum `Animal`, como `Animal::Pez`, el compilador emitiría un error indicando que el match no es exhaustivo, obligando al desarrollador a manejar el nuevo caso.
+
+#### Desestructuración
+
+La desestructuración permite dividir una estructura de datos en sus componentes individuales. Rust facilita la desestructuración de arrays, tuplas, structs y enums, lo cual es útil para trabajar con datos complejos.
+
+##### Desestructuración de Tuplas
+
+```rust
+fn main() {
+    let tupla = (1, "hola", 3.5);
+
+    let (a, b, c) = tupla;
+
+    println!("a: {}, b: {}, c: {}", a, b, c);
+}
+```
+
+En este ejemplo, la tupla `(1, "hola", 3.5)` se desestructura en las variables `a`, `b` y `c`.
+
+##### Desestructuración de Structs
+
+```rust
+struct Punto {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let punto = Punto { x: 5, y: 10 };
+
+    let Punto { x, y } = punto;
+
+    println!("x: {}, y: {}", x, y);
+}
+```
+
+Aquí, el struct `Punto` se desestructura en sus campos `x` e `y`.
+
+#### Uso Avanzado de Pattern Matching
+
+Pattern matching en Rust no se limita a estructuras de datos simples, sino que puede manejar patrones complejos, incluyendo guardas, valores anidados y opciones.
+
+##### Match con Guardas
+
+```rust
+fn main() {
+    let numero = Some(4);
+
+    match numero {
+        Some(x) if x < 5 => println!("Menos que 5: {}", x),
+        Some(x) => println!("Mayor o igual a 5: {}", x),
+        None => println!("Sin valor"),
+    }
+}
+```
+
+Las guardas (`if x < 5`) permiten añadir condiciones adicionales a los patrones.
+
+##### Patrones Anidados
+
+```rust
+enum Mensaje {
+    Saludo { id: i32, contenido: String },
+}
+
+fn main() {
+    let mensaje = Mensaje::Saludo {
+        id: 1,
+        contenido: String::from("Hola"),
+    };
+
+    match mensaje {
+        Mensaje::Saludo { id, contenido } => {
+            println!("ID: {}, Contenido: {}", id, contenido);
+        }
+    }
+}
+```
+
+Aquí se desestructura un enum con campos nombrados, extrayendo `id` y `contenido`.
+
+#### Pattern Matching en Funciones
+
+Pattern matching también se puede usar directamente en las firmas de las funciones para hacer el código más limpio.
+
+```rust
+fn procesar_punto(Punto { x, y }: Punto) {
+    println!("x: {}, y: {}", x, y);
+}
+
+fn main() {
+    let punto = Punto { x: 5, y: 10 };
+    procesar_punto(punto);
+}
+```
+
+En este ejemplo, el patrón se aplica directamente en los parámetros de la función `procesar_punto`.
+
+#### Conclusión
+
+El pattern matching y la desestructuración en Rust son herramientas poderosas que permiten manejar estructuras de datos complejas de manera más expresiva y eficiente. La exhaustividad del pattern matching asegura que todos los posibles casos se manejen adecuadamente, lo que contribuye a la seguridad y robustez del código. Comprender y utilizar estas características efectivamente puede mejorar significativamente la calidad y la mantenibilidad del código en Rust.