Ejemplos de Código para "Aprendiendo Rust Leyendo Código Fuente: Guía para Principiantes"

Readme.md

Ejemplos de Código para "Aprendiendo Rust Leyendo Código Fuente: Guía para Principiantes"

¡Bienvenido/a! Este Gist contiene los ejemplos de código que acompañan mi artículo "Aprendiendo Rust Leyendo Código Fuente: Guía para Principiantes". Aquí encontrarás fragmentos prácticos para aprender a leer y entender código en Rust, desde conceptos básicos hasta temas más avanzados. Cada archivo está nombrado según la sección del artículo a la que corresponde.

Contenido

• ownership.rs
  • Qué hace: Muestra cómo funciona el ownership (propiedad) en Rust con un ejemplo simple de un String que se "mueve" entre variables.
  • Sección: 1. Conceptos Básicos de Rust.
• result.rs
  • Qué hace: Ejemplo de una función que usa Result para manejar divisiones, incluyendo un caso de error (división por cero).
  • Sección: 1. Conceptos Básicos de Rust.
• vec_growth.rs
  • Qué hace: Demuestra cómo crece un Vec al añadir elementos, con comentarios sobre capacidad y longitud.
  • Sección: 3. Leyendo Módulos Sencillos.
• borrowing.rs
  • Qué hace: Ilustra el concepto de préstamos (borrowing) con un String que se presta de forma inmutable varias veces.
  • Sección: 4. Gestión de Memoria para Mortales.
• smart_pointers1.rs
  • Qué hace: Ejemplo básico de Box<T> para entender punteros inteligentes.
  • Sección: 5. Punteros Inteligentes en Detalle.
• smart_pointers2.rs
  • Qué hace: Ejemplo básico de Rc<T> para entender punteros inteligentes.
  • Sección: 5. Punteros Inteligentes en Detalle.
• smart_pointers3.rs
  • Qué hace: Ejemplo básico de RefCell<T> para entender punteros inteligentes.
  • Sección: 5. Punteros Inteligentes en Detalle.
• traits.rs
  • Qué hace: Define un trait Dibujable y lo implementa para Circulo y Rectangulo, mostrando polimorfismo básico.
  • Sección: 6. Traits y Objetos Trait ().
• stack.rs
  • Qué hace: Implementación de una pila (stack) genérica usando Vec, con métodos como push, pop y is_empty.
  • Sección: 7. Proyectos Reales para Analizar.
• vec-exercise.rs
  • Qué hace: Crea un vector mutable y le añade los números 1 y 2.
  • Sección: Soluciones a Ejercicios.
• stack-with-peek.rs
  • Qué hace: Obtiene una referencia al último elemento del Stack sin eliminarlo, devolviendo None si la pila está vacía.
  • Sección: Soluciones a Ejercicios.

Cómo Usarlo

1. Clona este Gist o copia los archivos a tu máquina.
2. Asegúrate de tener Rust instalado (rustc y cargo).
3. Ejecuta cada archivo con rustc nombre_del_archivo.rs y ./nombre_del_archivo (o usa cargo run si creas un proyecto).
4. Lee los comentarios en el código y experimenta modificándolos para ver cómo cambian los resultados.

Notas

• Estos ejemplos están diseñados para principiantes y como repaso para quienes ya conocen Rust.
• Si quieres más detalles, revisa el artículo completo en mi blog.
• ¡Siéntete libre de jugar con el código y compartir tus ideas!

¡Diviértete explorando Rust! 🦀

borrowing.rs

fn prestar_libro(libro: &String) {
    println!("Leyendo: {}", libro);
}

fn main() {
    let mi_libro = String::from("El Señor de los Anillos");
    prestar_libro(&mi_libro); // Lo presto para leer
    prestar_libro(&mi_libro); // ¡Puedo prestarlo otra vez!
}

ownership.rs

fn main() {
    let s1 = String::from("hola"); // s1 es el dueño de "hola"
    let s2 = s1;                   // s1 "cede" la propiedad a s2
    // println!("{}", s1);         // ¡Error! s1 ya no existe aquí
}

result.rs

fn dividir(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("No se puede dividir por cero".to_string())
    } else {
        Ok(a / b)
    }
}

smart_pointers1.rs

let b = Box::new(5);
println!("b = {}", b); // b = 5

smart_pointers2.rs

use std::rc::Rc;

let a = Rc::new(10);
let b = Rc::clone(&a);
println!("Dueños: {}", Rc::strong_count(&a)); // 2

smart_pointers3.rs

use std::cell::RefCell;

let data = RefCell::new(5);
*data.borrow_mut() += 1;
println!("Dato: {}", data.borrow()); // Dato: 6

stack-with-peek.rs

impl<T> Stack<T> {
    fn peek(&self) -> Option<&T> {
        self.elementos.last()
    }
}

stack.rs

struct Stack<T> {
    elementos: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack { elementos: Vec::new() }
    }

    fn push(&mut self, elemento: T) {
        self.elementos.push(elemento);
    }

    fn pop(&mut self) -> Option<T> {
        self.elementos.pop()
    }

    fn is_empty(&self) -> bool {
        self.elementos.is_empty()
    }
}

fn main() {
    let mut stack = Stack::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);

    while let Some(elemento) = stack.pop() {
        println!("Elemento: {}", elemento);
    }
}

traits.rs

trait Dibujable {
    fn dibujar(&self);
}

struct Circulo {
    radio: f64,
}

impl Dibujable for Circulo {
    fn dibujar(&self) {
        println!("Círculo de radio {}", self.radio);
    }
}

struct Rectangulo {
    ancho: f64,
    alto: f64,
}

impl Dibujable for Rectangulo {
    fn dibujar(&self) {
        println!("Rectángulo de {}x{}", self.ancho, self.alto);
    }
}

fn dibujar_forma(forma: &dyn Dibujable) {
    forma.dibujar();
}

fn main() {
    let circulo = Circulo { radio: 5.0 };
    let rectangulo = Rectangulo { ancho: 3.0, alto: 4.0 };
    dibujar_forma(&circulo);
    dibujar_forma(&rectangulo);
}

vec-exercise.rs

let mut v = Vec::new();
v.push(1);
v.push(2);

vec_growth.rs

let mut v = Vec::new(); // Empieza vacío, capacidad = 0
v.push(1);              // Ahora tiene capacidad para 4 elementos
v.push(2);              // Capacidad = 4, pero solo 2 elementos usados