Merge pull request #18 from RustLangES/error_handling

Error handling

content/3.error-handling/1.option.md

@@ -6,112 +6,115 @@ data:
   type: 'custom'
   topicLevel: 'start'
   position:
-    x: -700
-    y: 320
+    x: 320
+    y: 580
   width: 320
   externalLinks:
     - name: 'Libro Oficial'
       english: false
-      link: 'https://book.rustlang-es.org/ch03-01-variables-and-mutability#shadowing'
+      link: 'https://book.rustlang-es.org/ch06-01-defining-an-enum'
     - name: 'Comprehensive Rust'
       english: false
-      link: 'https://google.github.io/comprehensive-rust/es/control-flow-basics/blocks-and-scopes.html?highlight=shado#%C3%81mbitos-y--shadowing'
+      link: 'https://google.github.io/comprehensive-rust/es/std-types/option.html'
+    - name: 'Documentacion Oficial'
+      english: true
+      link: 'https://doc.rust-lang.org/stable/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'
 ---
-# Option en Rust: Manejo Seguro de Valores Opcionales
+## Entendiendo el Tipo `Option` en Rust: Seguridad y Ausencia de Valores Nulos
+
+En Rust, el tipo `Option` es una herramienta fundamental que permite manejar de forma segura la ausencia de un valor sin recurrir al temido null. En lugar de utilizar valores nulos que pueden llevar a errores inesperados, Rust introduce `Option`, que garantiza que el manejo de valores opcionales sea explícito y seguro.
 
-## Introducción
-En Rust, el tipo Option es una característica clave para el manejo seguro de valores que pueden o no estar presentes. Option evita errores 
-comunes como los de referencias nulas, proporcionando una alternativa robusta y segura para representar valores opcionales. En este 
-artículo, exploraremos el uso y las ventajas del tipo Option en Rust.
+### ¿Qué es un `Option`?
 
-### Concepto de Option en Rust
-Option es una enumeración que puede contener un valor (Some(T)) o no (None). Este enfoque asegura que el programador maneje explícitamente 
-los casos donde un valor puede estar ausente, mejorando así la seguridad y la robustez del código.
+`Option` es un enum predefinido en Rust que puede tomar dos valores:
 
 ```rust
 enum Option<T> {
     Some(T),
     None,
 }
 ```
-### Definición y Uso Básico
 
-Option se define en la biblioteca estándar de Rust y se usa comúnmente en situaciones donde un valor puede o no estar presente. 
-Aquí tienes un ejemplo básico:
+- `Some(T)` indica que hay un valor presente.
+- `None` representa la ausencia de un valor.
 
-```rust
-fn find_index(arr: &[i32], target: i32) -> Option<usize> {
-    for (index, &item) in arr.iter().enumerate() {
-        if item == target {
-            return Some(index);
-        }
-    }
-    None
-}
-```
-En este ejemplo, la función find_index devuelve Some(index) si encuentra el target en el arreglo, y None si no lo encuentra.
+### Funciones Comunes para Trabajar con `Option`
 
-## Ejemplos de Uso de Option
+Rust ofrece múltiples funciones para manipular opciones de forma segura:
 
-### Acceso Seguro a Elementos
-Al acceder a elementos en estructuras de datos, Option asegura que manejemos adecuadamente los casos donde los elementos pueden no 
-existir.
+- **is_some() e is_none():** Verifican si un `Option` contiene un valor o no.
 
-```rust
-let arr = [1, 2, 3, 4, 5];
-let element = arr.get(2); // Devuelve Option<&i32>
+  ```rust
+  let maybe_value: Option<i32> = Some(5);
+  assert!(maybe_value.is_some());
 
-match element {
-    Some(value) => println!("Elemento en el índice 2: {}", value),
-    None => println!("No hay elemento en el índice 2"),
-}
-```
+  let no_value: Option<i32> = None;
+  assert!(no_value.is_none());
+  ```
 
-### Operaciones que Pueden Fallar
-Option se usa en funciones donde una operación puede no tener un resultado válido.
+- **unwrap() y expect():** Extraen el valor del `Option`, pero si es `None`, `unwrap()` causará un pánico. `expect()` permite proporcionar un mensaje de error personalizado.
 
-```rust
-fn divide(a: f64, b: f64) -> Option<f64> {
-    if b == 0.0 {
-        None
-    } else {
-        Some(a / b)
-    }
-}
-```
+  ```rust
+  let value = maybe_value.unwrap(); // Devuelve 5 o causa un pánico si es None.
+  ```
 
-### Uso de Métodos de Option
-Rust proporciona métodos útiles para trabajar con Option, como map, and_then, unwrap_or, entre otros.
+- **map():** Permite aplicar una función al valor dentro de un `Option`, devolviendo un nuevo `Option`.
 
-```rust
-let some_number = Some(10);
+  ```rust
+  let maybe_value: Option<i32> = Some(5);
+  let maybe_double = maybe_value.map(|x| x * 2);
+  assert_eq!(maybe_double, Some(10));
+  ```
 
-let new_number = some_number.map(|x| x + 1);
+- **and(), or() y xor():** Estas funciones permiten combinar opciones de manera segura.
 
-assert_eq!(new_number, Some(11));
-```
+  ```rust
+  let a: Option<i32> = Some(2);
+  let b: Option<i32> = Some(3);
+  let c: Option<i32> = None;
+
+  assert_eq!(a.and(b), Some(3)); // Devuelve Some(3)
+  assert_eq!(a.or(c), Some(2));  // Devuelve Some(2)
+  assert_eq!(c.or(a), Some(2));  // Devuelve Some(2)
+  ```
+
+### Pattern Matching con `Option`
 
-## Beneficios de Option
-1.**Seguridad en Tiempo de Compilación:**Option hace que los desarrolladores consideren y manejen explícitamente los casos donde un valor
-puede no estar presente, lo que resulta en un código más robusto.
-2.**Manejo Explícito de Casos de Ausencia:**Option hace que los desarrolladores consideren y manejen explícitamente los casos donde un 
-valor puede no estar presente, lo que resulta en un código más robusto.
-3.**Compatibilidad con Funciones de Alto Nivel:**Option se integra bien con funciones de alto nivel y características funcionales como 
-map, and_then, unwrap_or, etc., permitiendo transformaciones y manejos eficientes de valores opcionales.
+El pattern matching es una forma común de interactuar con `Option`. Permite realizar acciones diferentes según el estado de la opción (si es `Some` o `None`):
 
-## Conclusión
-El tipo Option en Rust es una herramienta poderosa para el manejo seguro de valores opcionales. Al eliminar la posibilidad de referencias nulas
-y forzar a los desarrolladores a manejar explícitamente los casos de ausencia de valores, Option contribuye significativamente a la 
-robustez y seguridad del código en Rust. Su uso extensivo en situaciones donde los valores pueden estar presentes o no, junto con sus 
-métodos y transformaciones funcionales, hacen de Option una parte esencial del ecosistema de Rust.
+```rust
+let maybe_number = Some(10);
 
+match maybe_number {
+    Some(value) => println!("El valor es: {}", value),
+    None => println!("No hay valor"),
+}
+```
 
+### Interactuar con Múltiples `Option`
 
+Cuando trabajas con múltiples `Option`, puedes combinarlas utilizando combinadores como `and_then()` o emplear pattern matching para manejar múltiples opciones simultáneamente:
 
+```rust
+let x: Option<i32> = Some(2);
+let y: Option<i32> = Some(3);
 
+let result = x.and_then(|x_val| {
+    y.map(|y_val| x_val + y_val)
+});
 
+assert_eq!(result, Some(5));
+```
 
+### Funcionamiento en Memoria
 
+Rust optimiza la representación en memoria de `Option`. Si `T` es un tipo que puede tener un valor que represente la ausencia de datos (por ejemplo, punteros o números enteros), Rust puede usar una optimización para no consumir espacio adicional para `Option<T>`. De este modo, `Option` es tan eficiente en memoria como el propio tipo base.
 
+### Conclusión
 
+`Option` es un poderoso reemplazo para los valores nulos, brindando seguridad y claridad al código. Al ser un enum, proporciona flexibilidad y un control robusto sobre situaciones donde un valor puede o no estar presente. Al utilizar funciones como `map()`, `unwrap()`, y combinadores, puedes manejar opciones de forma elegante y segura, mientras el pattern matching te permite gestionar fácilmente las variantes de `Option` según tus necesidades.
 
+Rust garantiza que al trabajar con `Option`, la ausencia de un valor siempre se trate de manera explícita, evitando así una de las fuentes más comunes de errores en otros lenguajes de programación.

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

@@ -0,0 +1,153 @@
+---
+title: 'Result'
+description: 'Result es una enumeración en Rust que se utiliza para representar valores que pueden fallar'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 320
+    y: 620
+  width: 320
+  sourcePosition:
+    error-handling: 'bottom'
+  externalLinks:
+    - name: 'Libro Oficial'
+      english: false
+      link: 'https://book.rustlang-es.org/ch06-01-defining-an-enum'
+    - 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/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'
+---
+## El Tipo `Result` en Rust: Manejo Seguro de Errores
+
+Uno de los principios fundamentales de Rust es la seguridad, tanto en la concurrencia como en el manejo de errores. En lugar de depender de excepciones como en otros lenguajes, Rust utiliza el tipo `Result` para manejar errores de forma explícita y segura. Este enfoque reduce la posibilidad de errores inesperados y garantiza que los desarrolladores gestionen los errores correctamente.
+
+### ¿Qué es un `Result`?
+
+`Result` es un enum predefinido en Rust que se utiliza para representar el resultado de operaciones que pueden fallar. Su definición es la siguiente:
+
+```rust
+enum Result<T, E> {
+    Ok(T),
+    Err(E),
+}
+```
+
+- `Ok(T)`: Indica que la operación fue exitosa y contiene un valor del tipo `T`.
+- `Err(E)`: Indica que la operación falló y contiene un valor del tipo `E`, que normalmente describe el error.
+
+### Funciones Comunes para Trabajar con `Result`
+
+Rust proporciona múltiples métodos para manipular y controlar el flujo de errores de manera explícita. Algunas de las funciones más comunes son:
+
+- **is_ok() e is_err():** Estas funciones permiten verificar si un `Result` contiene un valor exitoso o un error.
+
+  ```rust
+  let result: Result<i32, &str> = Ok(10);
+  assert!(result.is_ok());
+
+  let error: Result<i32, &str> = Err("Error!");
+  assert!(error.is_err());
+  ```
+
+- **unwrap() y expect():** Extraen el valor de un `Result`. Si es un `Ok`, devuelven el valor; si es un `Err`, `unwrap()` causa un pánico. `expect()` es similar, pero permite proporcionar un mensaje de error personalizado.
+
+  ```rust
+  let result: Result<i32, &str> = Ok(5);
+  let value = result.unwrap(); // Devuelve 5
+
+  let error: Result<i32, &str> = Err("Error!");
+  let value = error.expect("Algo salió mal"); // Causa un pánico con el mensaje proporcionado
+  ```
+
+- **map() y map_err():** `map()` permite aplicar una función al valor contenido en `Ok`, mientras que `map_err()` aplica una función al valor contenido en `Err`.
+
+  ```rust
+  let result: Result<i32, &str> = Ok(2);
+  let doubled = result.map(|x| x * 2);
+  assert_eq!(doubled, Ok(4));
+
+  let error: Result<i32, &str> = Err("Error!");
+  let new_error = error.map_err(|e| format!("Ocurrió: {}", e));
+  assert_eq!(new_error, Err("Ocurrió: Error!".to_string()));
+  ```
+
+- **and_then():** Permite encadenar operaciones que también devuelven `Result`, facilitando la propagación de errores.
+
+  ```rust
+  let result: Result<i32, &str> = Ok(2);
+  let chained_result = result.and_then(|x| Ok(x * 3));
+  assert_eq!(chained_result, Ok(6));
+  ```
+
+### Pattern Matching con `Result`
+
+El pattern matching es una técnica poderosa en Rust que se usa a menudo para manejar `Result`. Con `match`, puedes manejar tanto los casos exitosos como los errores de manera explícita:
+
+```rust
+let result: Result<i32, &str> = Ok(10);
+
+match result {
+    Ok(value) => println!("El valor es: {}", value),
+    Err(error) => println!("Error: {}", error),
+}
+```
+
+### Interactuar con Múltiples `Result`
+
+Cuando trabajas con múltiples resultados que pueden fallar, puedes combinarlos utilizando combinadores o emplear pattern matching para manejar las diversas posibilidades. Aquí un ejemplo sencillo usando `and_then()` para encadenar operaciones que pueden fallar:
+
+```rust
+let x: Result<i32, &str> = Ok(2);
+let y: Result<i32, &str> = Ok(3);
+
+let result = x.and_then(|x_val| {
+    y.map(|y_val| x_val + y_val)
+});
+
+assert_eq!(result, Ok(5));
+```
+
+### Funcionamiento en Memoria
+
+El tipo `Result`, al igual que `Option`, es representado de manera eficiente en memoria. Dado que `Result` es un enum, el compilador ajusta su representación en memoria según el tipo de datos que contiene. Al trabajar con un `Result`, Rust optimiza el almacenamiento para que no haya un sobrecoste significativo en comparación con otras representaciones de errores.
+
+Cuando se utiliza `Result`, el tamaño en memoria depende tanto del valor contenido en `Ok` como del valor contenido en `Err`. Si bien ambos pueden ser diferentes, el compilador se encarga de ajustar su representación para minimizar el espacio de almacenamiento.
+
+### Comparación con `Option`
+
+A diferencia de `Option`, que representa la presencia o ausencia de un valor, `Result` se utiliza principalmente para manejar operaciones que pueden fallar. Aunque ambos son enums, `Result` es más adecuado para representar errores porque incluye el valor `Err` que proporciona información adicional sobre qué salió mal.
+
+### Ejemplo Completo de Uso de `Result`
+
+Aquí un ejemplo práctico de cómo podrías utilizar `Result` para manejar una operación de apertura de archivos, que puede fallar si el archivo no existe:
+
+```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)?;
+    let mut contenido = String::new();
+    archivo.read_to_string(&mut contenido)?;
+    Ok(contenido)
+}
+
+fn main() {
+    match leer_archivo("archivo.txt") {
+        Ok(contenido) => println!("Contenido: {}", contenido),
+        Err(error) => println!("No se pudo leer el archivo: {}", error),
+    }
+}
+```
+
+### Conclusión
+
+El tipo `Result` es una herramienta poderosa para el manejo seguro de errores en Rust. Al ser un enum con las variantes `Ok` y `Err`, te obliga a manejar explícitamente los posibles fallos en las operaciones. Gracias a métodos como `map()`, `and_then()` y `unwrap()`, junto con el pattern matching, el manejo de errores en Rust es mucho más robusto y menos propenso a errores que en otros lenguajes. Además, al ser altamente eficiente en memoria, `Result` es una elección óptima para el manejo de errores en aplicaciones de alta performance.