feat(content:traits): add definition

content/5.traits/definition.md

@@ -0,0 +1,218 @@
+---
+title: 'Definiendo un Trait'
+description: 'Definiendo Traits en Rust: La Base de la Abstracción y el Comportamiento'
+draft: true
+data:
+  type: 'custom'
+  topicLevel: 'start'
+  position:
+    x: 200
+    y: 900
+  sourcePosition:
+    cargo: 'top'
+  targetPosition: 
+    smart-pointers: 'bottom'
+---
+# Definiendo Traits en Rust: La Base de la Abstracción y el Comportamiento
+
+En el artículo anterior, exploramos qué son los traits en Rust a nivel conceptual. Ahora vamos un paso más allá y nos enfocamos en **cómo definir y usar traits**. Veremos cómo incluir tipos y constantes dentro de ellos, cómo permitir que los traits se autoimplementen para ciertos tipos, y cómo separar lógicas en traits para lograr un diseño más modular.  
+
+## ¿Qué es un trait y cómo se define?  
+
+Un **trait** en Rust se define utilizando la palabra clave `trait`. Dentro del trait, declaramos métodos que los tipos que lo implementen deben cumplir.  
+
+### Ejemplo básico  
+
+```rust
+trait Greeting {
+    fn say_hello(&self);
+}
+
+struct Person {
+    name: String,
+}
+
+impl Greeting for Person {
+    fn say_hello(&self) {
+        println!("Hello, my name is {}", self.name);
+    }
+}
+
+let user = Person { name: "Alice".to_string() };
+user.say_hello(); // Output: Hello, my name is Alice
+```
+
+## Métodos con implementación por defecto  
+
+Rust permite definir métodos con una implementación predeterminada en un trait. Esto significa que cualquier tipo que implemente el trait puede optar por usar la implementación predeterminada o proporcionar la suya propia.  
+
+```rust
+trait Greeting {
+    fn say_hello(&self) {
+        println!("Hello!");
+    }
+}
+
+struct Robot;
+
+impl Greeting for Robot {} // Usa la implementación por defecto
+
+let bot = Robot;
+bot.say_hello(); // Output: Hello!
+```
+
+Esto es útil para reducir duplicación de código y proporcionar un comportamiento genérico.  
+
+## Constantes en los traits  
+
+Los traits también pueden contener constantes. Estas constantes deben ser definidas en las implementaciones del trait.  
+
+```rust
+trait Configurable {
+    const MAX_RETRIES: u32;
+
+    fn retries_allowed(&self) -> u32 {
+        Self::MAX_RETRIES
+    }
+}
+
+struct Network;
+
+impl Configurable for Network {
+    const MAX_RETRIES: u32 = 3;
+}
+
+let net = Network;
+println!("Max retries: {}", net.retries_allowed()); // Output: Max retries: 3
+```
+
+## Tipos asociados en los traits  
+
+Los traits pueden definir **tipos asociados**. Esto permite que los tipos que implementen el trait especifiquen un tipo concreto para ese asociado.  
+
+```rust
+trait Container {
+    type Item;
+
+    fn add(&mut self, item: Self::Item);
+    fn remove(&mut self) -> Option<Self::Item>;
+}
+
+struct Bag<T> {
+    items: Vec<T>,
+}
+
+impl<T> Container for Bag<T> {
+    type Item = T;
+
+    fn add(&mut self, item: T) {
+        self.items.push(item);
+    }
+
+    fn remove(&mut self) -> Option<T> {
+        self.items.pop()
+    }
+}
+
+let mut bag = Bag { items: vec![1, 2, 3] };
+bag.add(4);
+println!("{:?}", bag.remove()); // Output: Some(4)
+```
+
+Los tipos asociados hacen que el diseño sea más flexible y expresivo, especialmente cuando trabajamos con genéricos.  
+
+## Autoimplementación de traits  
+
+Podemos crear traits que se implementen automáticamente para ciertos tipos o bajo condiciones específicas. Esto se conoce como **implementación en bloque blanket**.  
+
+### Ejemplo: Implementación para todos los tipos que cumplen un trait  
+
+```rust
+trait Printable {
+    fn print(&self);
+}
+
+impl<T: std::fmt::Display> Printable for T {
+    fn print(&self) {
+        println!("{}", self);
+    }
+}
+
+42.print();             // Output: 42
+"Hello, Rust!".print(); // Output: Hello, Rust!
+```
+
+Aquí, cualquier tipo que implemente `Display` también implementará automáticamente `Printable`.  
+
+## Separando lógicas con traits  
+
+Los traits nos permiten dividir la lógica de un programa en unidades pequeñas y reutilizables. Esto es especialmente útil en programas complejos.  
+
+### Ejemplo: Modularidad con múltiples traits  
+
+```rust
+trait Flyable {
+    fn fly(&self) {
+        println!("I can fly!");
+    }
+}
+
+trait Swimmable {
+    fn swim(&self) {
+        println!("I can swim!");
+    }
+}
+
+struct Bird;
+
+impl Flyable for Bird {}
+
+struct Fish;
+
+impl Swimmable for Fish {}
+
+let sparrow = Bird;
+let goldfish = Fish;
+
+sparrow.fly();      // Output: I can fly!
+goldfish.swim();    // Output: I can swim!
+```
+
+Al separar los comportamientos en traits, puedes combinarlos fácilmente según sea necesario.  
+
+## Implementaciones condicionales  
+
+Los traits pueden implementarse bajo ciertas condiciones utilizando el sistema de bounds genéricos de Rust.  
+
+```rust
+trait Summable {
+    fn sum(&self) -> i32;
+}
+
+impl<T> Summable for Vec<T>
+where
+    T: std::ops::Add<Output = T> + Copy + Into<i32>,
+{
+    fn sum(&self) -> i32 {
+        self.iter().map(|&x| x.into()).sum()
+    }
+}
+
+let numbers: Vec<i32> = vec![1, 2, 3];
+println!("Sum: {}", numbers.sum()); // Output: Sum: 6
+```
+
+Esta implementación solo es válida si los elementos del `Vec` cumplen con las condiciones establecidas.  
+
+## Ventajas del diseño con traits  
+
+1. **Modularidad**: Los traits permiten dividir grandes problemas en piezas pequeñas y manejables.  
+2. **Reutilización de código**: Implementar comportamientos comunes en múltiples tipos.  
+3. **Abstracción poderosa**: Combinados con genéricos, los traits eliminan la necesidad de duplicar código para diferentes tipos.  
+4. **Extensibilidad**: Puedes añadir comportamientos a tipos existentes sin modificar su definición original.  
+
+## Conclusión  
+
+Los traits en Rust son una herramienta increíblemente poderosa para modelar comportamientos, separar lógicas y extender la funcionalidad de los tipos. Desde métodos con implementación por defecto hasta constantes y tipos asociados, los traits ofrecen flexibilidad para diseñar sistemas robustos y reutilizables.  
+
+Al comprender cómo funcionan y cómo podemos aprovecharlos para estructurar programas de manera más eficiente, estaremos mejor equipados para aprovechar todo el potencial que Rust tiene para ofrecer. 🚀