feat(content:traits): add index

content/5.traits/index.md

@@ -1,6 +1,6 @@
 ---
 title: 'Traits'
-description: ''
+description: 'Entendiendo los Traits en Rust: Contratos de Comportamiento y Modularidad'
 draft: true
 data:
   type: 'custom'
@@ -13,4 +13,150 @@ data:
   targetPosition: 
     smart-pointers: 'bottom'
 ---
-# Titulo
+# Entendiendo los Traits en Rust: Contratos de Comportamiento y Modularidad
+
+Los **traits** son una de las características más potentes de Rust y forman la base de la abstracción y la reutilización del código. A menudo se describen como contratos de comportamiento: definen lo que un tipo **puede hacer** o cómo debe comportarse en ciertas situaciones. A lo largo de este artículo, exploraremos los traits desde un punto de vista conceptual, cómo extienden tipos y permiten la programación genérica sin entrar en detalles sobre su implementación, que se cubrirán más adelante.  
+
+## ¿Qué es un trait en Rust?  
+
+Un trait es un conjunto de métodos que un tipo puede implementar. Piensa en los traits como una forma de decir: *"Si implementas este trait, debes cumplir con estas reglas o comportamientos."* Por ejemplo, un trait puede garantizar que un tipo pueda compararse, imprimirse o iterarse.  
+
+### Traits como contratos  
+
+Un trait actúa como un contrato que un tipo debe cumplir. Si un tipo implementa un trait, asegura a Rust (y a otros desarrolladores) que el tipo tiene cierto comportamiento. Por ejemplo, el trait `Display` garantiza que un tipo puede representarse como una cadena de texto formateada.  
+
+```rust
+use std::fmt;
+
+fn print_hello<T: fmt::Display>(item: T) {
+    println!("Hello, {}", item);
+}
+
+print_hello(42); // Funciona porque i32 implementa Display
+```
+
+---
+
+## Traits como comportamientos  
+
+Más allá de ser contratos, los traits pueden verse como una manera de dotar a los tipos de **comportamientos específicos**. Por ejemplo, cuando implementamos el trait `Iterator` para un tipo, le damos la capacidad de actuar como un iterador.  
+
+```rust
+pub trait MyTrait {
+    fn behavior(&self) -> String;
+}
+
+struct MyType;
+
+impl MyTrait for MyType {
+    fn behavior(&self) -> String {
+        "I behave!".to_string()
+    }
+}
+
+fn demonstrate<T: MyTrait>(item: T) {
+    println!("{}", item.behavior());
+}
+
+demonstrate(MyType); // Output: "I behave!"
+```
+
+## Traits y bounds genéricos  
+
+Los traits también se usan para imponer **condiciones** en tipos genéricos, conocidas como bounds. Estas condiciones especifican que un tipo debe implementar ciertos traits para que pueda usarse en una función, estructura o impl.  
+
+Por ejemplo, si queremos que una función sea capaz de imprimir cualquier cosa, podemos usar el bound `T: Display`:  
+
+```rust
+use std::fmt::Display;
+
+fn print_item<T: Display>(item: T) {
+    println!("Item: {}", item);
+}
+
+print_item(42);           // i32 implementa Display
+print_item("Hello Rust"); // &str implementa Display
+```
+
+Esto asegura que solo los tipos que implementan `Display` sean válidos como argumentos para `print_item`.  
+
+## Traits como modads (estructuras conceptuales)  
+
+En programación funcional, una mónada (monad) es un concepto que encapsula operaciones en un contexto computacional. Los traits en Rust comparten un paralelismo con este concepto porque encapsulan comportamientos y restricciones en torno a un tipo. Por ejemplo, el trait `Iterator` es una mónada práctica que define un conjunto de operaciones que pueden realizarse en iteradores:  
+
+```rust
+let numbers = vec![1, 2, 3];
+let doubled: Vec<_> = numbers.iter().map(|x| x * 2).collect();
+
+println!("{:?}", doubled); // Output: [2, 4, 6]
+```
+
+Aquí, el trait `Iterator` define el comportamiento de métodos como `.map()` y `.collect()`.  
+
+## Traits como extensión de tipos  
+
+Los traits también permiten extender tipos existentes sin modificarlos directamente. Esto es útil cuando queremos añadir comportamiento a tipos definidos en bibliotecas externas.  
+
+```rust
+trait Greeting {
+    fn say_hello(&self);
+}
+
+impl Greeting for i32 {
+    fn say_hello(&self) {
+        println!("Hello, I'm the number {}", self);
+    }
+}
+
+42.say_hello(); // Output: Hello, I'm the number 42
+```
+
+Con este enfoque, podemos enriquecer los tipos estándar o externos con funcionalidades específicas de nuestra aplicación.  
+
+## Traits como contratos para múltiples tipos  
+
+Los traits también permiten trabajar con múltiples tipos que comparten un comportamiento común. Esto fomenta la reutilización y la flexibilidad del código.  
+
+```rust
+trait Area {
+    fn area(&self) -> f64;
+}
+
+struct Circle { radius: f64 }
+struct Rectangle { width: f64, height: f64 }
+
+impl Area for Circle {
+    fn area(&self) -> f64 {
+        3.14 * self.radius * self.radius
+    }
+}
+
+impl Area for Rectangle {
+    fn area(&self) -> f64 {
+        self.width * self.height
+    }
+}
+
+fn print_area<T: Area>(shape: T) {
+    println!("The area is {}", shape.area());
+}
+
+print_area(Circle { radius: 3.0 });
+print_area(Rectangle { width: 4.0, height: 5.0 });
+```
+
+## Conceptos importantes  
+
+### Abstracción sin sacrificio de rendimiento  
+Rust utiliza el sistema de traits para implementar **monomorfización**. Esto significa que el compilador genera código específico para cada uso de un tipo genérico con un trait. Como resultado, obtienes la abstracción del comportamiento sin el coste adicional de un polimorfismo dinámico (como las clases en lenguajes orientados a objetos).  
+
+### Uso con cuidado  
+Aunque los traits son extremadamente útiles, abusar de ellos puede llevar a un código complejo y difícil de entender. Es importante usarlos para capturar comportamientos comunes y no simplemente para evitar escribir funciones duplicadas.  
+
+## Nota importante sobre los ejemplos  
+
+Los ejemplos mostrados aquí son introductorios y simplificados para ilustrar conceptos clave. En futuros artículos, exploraremos cómo declarar y utilizar traits en profundidad, incluyendo la implementación de traits estándar y la creación de nuestros propios traits personalizados.  
+
+## Conclusión  
+
+Los traits son una herramienta esencial en Rust, proporcionando una forma poderosa y flexible de definir comportamientos, imponer restricciones y extender tipos. Al entenderlos como contratos, comportamientos y abstracciones, podemos escribir código más claro, modular y eficiente. Rust nos da las herramientas necesarias para capturar estos conceptos de manera precisa y con un rendimiento sobresaliente. 🚀