feat: add error operator

Author: SergioRibera

content/3.error-handling/3.operator.md

@@ -0,0 +1,137 @@
+---
+title: 'Operador de Propagación (`?`)'
+description: 'Mejorando el manejo de errores con el Operador de Propagación (`?`)'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 255
+    y: 520
+  width: 320
+  externalLinks:
+    - name: 'Libro Oficial'
+      english: false
+      link: 'https://book.rustlang-es.org/ch06-01-defining-an-enum'
+    - name: 'Documentacion Oficial'
+      english: false
+      link: 'https://google.github.io/comprehensive-rust/es/std-types/option.html'
+    - name: 'Comprehensive Rust'
+      english: true
+      link: 'https://doc.rust-lang.org/std/option'
+    - name: '¿Cómo almacena Rust los enum en memoria?'
+      english: false
+      link: 'https://blog.rustlang-es.org/articles/como-almacena-rust-los-enum-en-memoria'
+---
+## Uso del Operador de Propagación (`?`) en Rust con `Option` y `Result`
+
+Rust ofrece un enfoque único y eficiente para manejar errores y valores opcionales mediante los tipos `Option` y `Result`. Para facilitar la propagación de errores y simplificar el código, Rust incluye un operador especial: el operador de propagación `?`. Este operador es increíblemente útil para trabajar con estos tipos, ya que permite simplificar la lógica de manejo de errores y evitar la necesidad de escribir código de control repetitivo.
+
+### ¿Qué es el operador `?`
+
+El operador de propagación `?` te permite escribir código más limpio y legible al manejar valores de `Option` o `Result`. En lugar de tener que utilizar explícitamente pattern matching o combinadores como `and_then` o `unwrap`, el operador `?` propaga automáticamente el error o la falta de un valor si ocurre, de modo que la ejecución del programa se detiene y el error se devuelve inmediatamente.
+
+### Usando `?` con `Result`
+
+El caso más común de uso del operador `?` es con el tipo `Result`. Cuando lo aplicas a un `Result`, si la operación devuelve un `Err`, el operador detiene la ejecución y propaga el error hacia arriba. Si el valor es un `Ok`, entonces el operador extrae el valor y continúa la ejecución.
+
+#### Ejemplo básico de uso con `Result`
+
+```rust
+use std::fs::File;
+use std::io::{self, Read};
+
+fn leer_archivo(path: &str) -> Result<String, io::Error> {
+    let mut archivo = File::open(path)?;  // Propaga el error si falla la apertura del archivo
+    let mut contenido = String::new();
+    archivo.read_to_string(&mut contenido)?;  // Propaga el error si falla la lectura
+    Ok(contenido)
+}
+
+fn main() {
+    match leer_archivo("archivo.txt") {
+        Ok(contenido) => println!("Contenido: {}", contenido),
+        Err(error) => println!("No se pudo leer el archivo: {}", error),
+    }
+}
+```
+
+En este ejemplo, en lugar de tener que manejar cada posible error con `match` o `unwrap`, el operador `?` simplifica el flujo al propagar automáticamente el error en caso de que ocurra, devolviendo un `Err` al llamador si alguna de las operaciones falla.
+
+#### Detalles importantes sobre `Result` y `?`
+
+- El operador `?` solo puede usarse dentro de funciones que devuelven un `Result`. Si lo usas en una función que no devuelve un `Result`, obtendrás un error de compilación.
+- Si usas el operador `?` en una función que devuelve otro tipo de error, puedes convertir el error con la función `From`.
+
+```rust
+fn abrir_archivo(path: &str) -> Result<File, String> {
+    let archivo = File::open(path).map_err(|_| "Error al abrir el archivo".to_string())?;
+    Ok(archivo)
+}
+```
+
+### Usando `?` con `Option`
+
+El operador `?` también funciona con el tipo `Option`. Cuando lo aplicas a un `Option`, si el valor es `None`, propaga el `None` hacia arriba y detiene la ejecución de la función. Si es `Some`, extrae el valor y continúa.
+
+#### Ejemplo básico de uso con `Option`
+
+```rust
+fn obtener_valor(data: Option<i32>) -> Option<i32> {
+    let valor = data?;  // Propaga None si el valor es None
+    Some(valor * 2)
+}
+
+fn main() {
+    let data = Some(10);
+    let resultado = obtener_valor(data);
+    println!("{:?}", resultado);  // Imprime: Some(20)
+
+    let none_data: Option<i32> = None;
+    let resultado_none = obtener_valor(none_data);
+    println!("{:?}", resultado_none);  // Imprime: None
+}
+```
+
+En este caso, si `data` es `None`, la función `obtener_valor` devuelve inmediatamente `None`, sin necesidad de realizar más comprobaciones. Si el valor es `Some`, el operador `?` extrae el valor y continúa con la operación.
+
+### Uso combinado con otros tipos
+
+El operador `?` puede ser utilizado junto con combinadores y otras técnicas de manejo de errores, permitiendo simplificar aún más el código. También puedes encadenar múltiples operaciones con `Result` o `Option` utilizando `?` para un flujo claro y conciso.
+
+#### Ejemplo con múltiples operaciones `Result`
+
+```rust
+use std::fs::File;
+use std::io::{self, Read, Write};
+
+fn copiar_contenido(origen: &str, destino: &str) -> Result<(), io::Error> {
+    let mut archivo_origen = File::open(origen)?;
+    let mut contenido = String::new();
+    archivo_origen.read_to_string(&mut contenido)?;
+
+    let mut archivo_destino = File::create(destino)?;
+    archivo_destino.write_all(contenido.as_bytes())?;
+
+    Ok(())
+}
+
+fn main() {
+    match copiar_contenido("origen.txt", "destino.txt") {
+        Ok(()) => println!("Contenido copiado con éxito"),
+        Err(error) => println!("Error al copiar el contenido: {}", error),
+    }
+}
+```
+
+En este ejemplo, se combinan varias operaciones que podrían fallar, como abrir, leer y escribir archivos. El operador `?` garantiza que cualquier error en estas operaciones se propague automáticamente hacia arriba, lo que simplifica enormemente la gestión del flujo de control.
+
+### Coste Computacional
+
+El uso del operador `?` no añade ningún coste significativo en términos de rendimiento. Al ser una herramienta que simplemente descompone enums (`Result` y `Option`) en su representación interna, permite que el código sea más conciso y fácil de seguir sin sacrificar eficiencia. Además, dado que el control de errores es explícito y seguro, Rust optimiza este tipo de operaciones de manera que el coste computacional es mínimo.
+
+### Conclusión
+
+El operador `?` en Rust es una herramienta poderosa para simplificar el manejo de errores y valores opcionales cuando trabajas con `Result` y `Option`. Al eliminar la necesidad de un control de errores manual en cada operación, permite que tu código sea más legible, menos propenso a errores y mucho más limpio. Al mismo tiempo, Rust asegura que este operador se implemente de manera eficiente, sin sacrificar rendimiento ni seguridad.
+
+Gracias a este operador, manejar errores en Rust se convierte en una tarea sencilla y controlada, sin recurrir a excepciones o técnicas que podrían generar comportamientos impredecibles.