feat: add custom error

Author: SergioRibera

content/3.error-handling/2.result.md

@@ -13,12 +13,12 @@ data:
     - 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: false
+      link: 'https://google.github.io/comprehensive-rust/es/std-types/result.html'
+    - name: 'Documentacion Oficial'
       english: true
-      link: 'https://doc.rust-lang.org/std/option'
+      link: 'https://doc.rust-lang.org/stable/std/result'
     - 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'

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

@@ -0,0 +1,179 @@
+---
+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'
+---
+## Creando Tus Propios Errores en Rust: Buenas Prácticas y Herramientas
+
+El manejo de errores en Rust es fundamental para construir aplicaciones seguras y eficientes. Aunque `Result<T, E>` y `Option<T>` cubren la mayoría de los casos, cuando desarrollas bibliotecas o aplicaciones más complejas, es común que necesites crear tus propios errores personalizados. En este post, te guiaré por las mejores prácticas para crear tus propios errores en Rust, destacando el uso de enumeradores, las limitaciones de `Box<dyn Error>`, y cómo mejorar tu código con crates como `thiserror`, `anyhow` y `eyre`.
+
+### ¿Por qué crear tus propios errores?
+
+Rust fomenta el manejo explícito de errores mediante el uso de `Result` y `Option`. En muchos casos, el error que quieres propagar no está cubierto por los tipos estándar como `std::io::Error` o `std::fmt::Error`, por lo que crear tus propios tipos de error te permite:
+
+1. **Especificar el contexto exacto del fallo**.
+2. **Incluir variantes para distintos tipos de errores**.
+3. **Proporcionar mejores mensajes de error**.
+4. **Asegurarte de que el manejo de errores sea parte de la lógica del flujo de tu aplicación**.
+
+### Creando Errores con `enum`
+
+El enfoque recomendado para crear errores personalizados en Rust es usar un `enum`. Un `enum` puede representar diferentes variantes de error que pueden ocurrir en tu programa o biblioteca. Esto te permite manejar distintos tipos de errores de forma estructurada, con la ventaja de que el compilador te obliga a tratar todos los casos.
+
+Aquí tienes un ejemplo básico:
+
+```rust
+use std::fmt;
+
+#[derive(Debug)]
+enum MyError {
+    NotFound,
+    InvalidInput(String),
+    IoError(std::io::Error),
+}
+
+impl fmt::Display for MyError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            MyError::NotFound => write!(f, "Recurso no encontrado"),
+            MyError::InvalidInput(msg) => write!(f, "Entrada inválida: {}", msg),
+            MyError::IoError(e) => write!(f, "Error de IO: {}", e),
+        }
+    }
+}
+
+impl std::error::Error for MyError {}
+
+fn main() -> Result<(), MyError> {
+    // Simulamos un error
+    Err(MyError::NotFound)
+}
+```
+
+En este ejemplo:
+
+- `MyError` puede representar diferentes errores (`NotFound`, `InvalidInput` y `IoError`).
+- Implementamos `Display` para personalizar el mensaje de error y `std::error::Error` para integrarnos con el sistema de errores de Rust.
+
+### Por Qué Evitar `Box<dyn Error>`
+
+Una alternativa común es usar `Box<dyn std::error::Error>` para empaquetar errores. Esto permite la creación de errores dinámicos en tiempo de ejecución. Sin embargo, **esto no es recomendado**, ya que sacrifica el control estático que proporciona el sistema de tipos. Además, el uso de `Box<dyn Error>` tiene un coste en rendimiento, ya que introduce asignaciones en el heap y elimina la capacidad de optimización en tiempo de compilación.
+
+Por ejemplo:
+
+```rust
+fn error_con_box() -> Result<(), Box<dyn std::error::Error>> {
+    let io_error = std::fs::File::open("archivo_inexistente.txt")?;
+    Ok(())
+}
+```
+
+Aunque `Box<dyn Error>` es flexible, oculta la verdadera naturaleza de los errores que pueden ocurrir, lo que complica el manejo en el código llamador.
+
+### Mejorando el Manejo de Errores con `thiserror`
+
+Para evitar el tedio de implementar manualmente `Display`, `From`, y otras interfaces para tus errores, puedes usar el crate [`thiserror`](https://docs.rs/thiserror/latest/thiserror/). `thiserror` simplifica la creación de errores personalizados al generar automáticamente el código boilerplate, manteniendo tu código más limpio.
+
+Aquí tienes el mismo ejemplo anterior usando `thiserror`:
+
+```rust
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+enum MyError {
+    #[error("Recurso no encontrado")]
+    NotFound,
+
+    #[error("Entrada inválida: {0}")]
+    InvalidInput(String),
+
+    #[error(transparent)]
+    IoError(#[from] std::io::Error),
+}
+
+fn main() -> Result<(), MyError> {
+    // Simulamos un error
+    Err(MyError::NotFound)
+}
+```
+
+### Ventajas de `thiserror`:
+
+1. **Menos boilerplate:** No necesitas escribir manualmente implementaciones de `Display` o `From`.
+2. **Uso de atributos:** Puedes usar atributos para personalizar los mensajes de error y para manejar automáticamente la conversión de errores (como `#[from]`).
+3. **Mejor mantenimiento:** Al eliminar el código repetitivo, tu código se vuelve más legible y fácil de mantener.
+
+### Uso de `anyhow` y `eyre` para Errores Genéricos
+
+Si necesitas manejar errores de manera más flexible y no te importa tanto el tipo específico del error (por ejemplo, en aplicaciones CLI o proyectos rápidos), puedes usar el crate [`anyhow`](https://docs.rs/anyhow/latest/anyhow/) o su contraparte personalizable [`eyre`](https://docs.rs/color-eyre/latest/color-eyre/). Estos crates proporcionan tipos de error genéricos y facilitan el manejo de errores de una manera más sencilla, pero sin perder información útil.
+
+#### Ejemplo con `anyhow`:
+
+```rust
+use anyhow::{Result, Context};
+
+fn funcion_con_error() -> Result<()> {
+    let _file = std::fs::File::open("archivo.txt")
+        .with_context(|| "No se pudo abrir el archivo")?;
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    funcion_con_error()?;
+    Ok(())
+}
+```
+
+En este ejemplo:
+
+- `anyhow::Result` es un alias conveniente para `Result<T, anyhow::Error>`.
+- `with_context()` proporciona mensajes de error adicionales, lo que facilita el diagnóstico de fallos.
+
+#### Ejemplo con `eyre` y Errores Coloreados
+
+`eyre` permite un manejo de errores similar a `anyhow`, pero con la capacidad de agregar "reportes" de errores enriquecidos y con colores, ideales para la salida de errores en la terminal:
+
+```rust
+use color_eyre::eyre::Result;
+
+fn main() -> Result<()> {
+    color_eyre::install()?; // Habilita los reportes coloreados
+
+    let _file = std::fs::File::open("archivo.txt")?;
+    Ok(())
+}
+```
+
+### Comparativa de Opciones
+
+| **Método**                 | **Ventajas**                                   | **Desventajas**                            |
+|----------------------------|------------------------------------------------|--------------------------------------------|
+| **Enum manual**            | Control preciso, tipado estático               | Mucho código repetitivo                    |
+| **`Box<dyn Error>`**       | Flexibilidad para manejar cualquier error      | Oculta la naturaleza del error, más lento  |
+| **`thiserror`**            | Fácil de usar, sin boilerplate, mantiene tipos | Menos flexible que `Box<dyn Error>`        |
+| **`anyhow`**               | Simplicidad en el manejo de errores genéricos  | Pierdes detalles sobre el tipo de error    |
+| **`eyre`**                 | Reportes detallados y coloreados               | Similar a `anyhow` en términos de flexibilidad |
+
+### Conclusión
+
+Crear tus propios errores en Rust es una parte crucial de escribir código seguro y robusto. Usar `enum` te proporciona el máximo control sobre el manejo de errores, mientras que herramientas como `thiserror` y `anyhow` te permiten reducir el código repetitivo y mejorar la legibilidad. Dependiendo del contexto de tu aplicación, puedes elegir entre un enfoque más tipado o uno más flexible. En cualquier caso, Rust proporciona las herramientas necesarias para garantizar que los errores sean manejados de manera segura y eficiente.