Rust II: datos, decisiones y confianza · Lección 12 / 12

Tu taller de equipos

Ahora las piezas trabajan juntas: catálogo validado, préstamo, devolución, informe y pruebas. Explica tanto un éxito como un intento rechazado.

Vamos a descubrir juntos

1
Descarga el ZIP y extráelo en una carpeta nueva. Incluye Cargo.toml, src/main.rs, items.txt, README, cuaderno y guía GitHub. En la carpeta de Cargo.toml ejecuta cargo test y cargo run --offline. No hay dependencias externas.
2
El programa empieza con sensor;3 y motor;2. Presta una unidad del primer equipo, intenta retirar 20 y devuelve una. El intento imposible conserva el estado; el informe mantiene el orden del archivo.
3
cargo run --offline -- items.txt lee tu archivo UTF-8. El parser acepta hasta 20 nombres únicos de 1 a 40 valores escalares, sin controles ni punto y coma; cantidades de 1 a 20. Ignora líneas vacías; un registro inválido rechaza todo el conjunto.
4
Es una simulación local sin cuentas, red, base de datos ni préstamos persistentes. Lee e imprime; no cambia items.txt. Guarda cambios en tu editor y resultados en el cuaderno. El panel publica un archivo por operación tras tu confirmación.

DE LA LECCIÓN A LA PRÁCTICA

Una guía para seguir a tu ritmo

Lee los pasos antes de usar la referencia de abajo. Los comandos se ejecutan en el terminal del sistema indicado; el registro ocurre en el sitio oficial. Los ejercicios de Rullst Academy son práctica y no verifican tu instalación ni cuenta externa.

fn main() {
    let total = 3_u16;
    let mut available = total;
    available -= 1;
    println!("{available}");
    let request = 20;
    if request <= available { available -= request; }
    println!("{available}");
    if available < total { available += 1; }
    println!("{available}");
}

Enlaces oficiales y siguiente paso

Referencia oficial de Rust

✦

TU MISIÓN

Ejecutar, probar y modificar un proyecto Rust completo con datos ficticios.

Ahora te toca

Taller de descubrimientos

Lee, predice, investiga

Predice antes de mostrar. Este panel revela resultados preparados; no compila tu código. Los errores se resumen; el texto exacto puede variar con la versión del compilador.

Mini experimento

Simulación didáctica: compara tarjetas y comprueba tus predicciones. El navegador no compila Rust ni inicia un servidor.

fn main() {
    let total = 3_u16;
    let mut available = total;
    available -= 1;
    println!("{available}");
    let request = 20;
    if request <= available { available -= request; }
    println!("{available}");
    if available < total { available += 1; }
    println!("{available}");
}

Resultado de este escenario

01Tras prestar 1 de 302Tras rechazar el préstamo de 2003Tras devolver 1

Prepara tus respuestas y comprueba cuando estés listo.

Una pausa para entender

¿Qué evidencia muestra que un préstamo rechazado conservó el estado?

Solo imprimir un mensaje bonito.Comparar la cantidad antes y después, además de comprobar el error.Solo poder compilar.

Necesito una pista

Puede informarse un error después de un cambio indebido; comprueba también los datos.

Cargando tu camino…

¿Cómo reconocer lo que aprendí?

Usa objetivos y desafío para reflexionar o conversar con alguien que pueda ayudar. Es autoevaluación orientada: no envía respuestas, no da XP ni verifica automáticamente autonomía.

En Fundamentos, modifica un ejemplo, predice, comprueba un caso normal y uno de error, y explica tus decisiones. Si necesitas ayuda, identifica qué practicar otra vez.

Tu desafío de transferencia

Crea un catálogo con tres equipos ficticios. Prueba vacío, duplicados y cantidad 21. Añade una secuencia de préstamos/devoluciones y una prueba que falle si un rechazo cambia el estado. Explica una limitación y publica opcionalmente con README; no incluyas datos personales.

Guarda evidencia: predicción, intento, resultado, cambio propio y lo que aún no explicas. Busca feedback si es posible; si estudias solo, vuelve después sin copiar y compara intentos.

Inténtalo de nuevo en otro momento

Tras una pausa, explica la idea sin abrir la solución y prueba otro ejemplo. Compara con tu primer intento: ¿qué puedes hacer por tu cuenta y dónde necesitas una pista? Puedes escribir, hablar o dibujar; elige una forma de comprobar la misma idea. Registra la ayuda recibida, incluida IA, y vuelve al fragmento necesario. No hay plazo universal ni XP extra por este registro.

Las conclusiones y XP registran evaluaciones de Rullst Academy. Una ruta introductoria puede ayudar en la vida diaria y preparar estudios; sola no demuestra dominio completo ni preparación profesional. Nivel indica profundidad, no edad.

Llévatelo contigo

RUST II · .rs

Tu espacio de práctica Rust II

Lee, predice y responde aquí. Para compilar realmente, extrae el ZIP en una carpeta nueva, abre la terminal junto a Cargo.toml y usa estos comandos. Debes tener instalados Rust y las herramientas de tu sistema.

cargo check --offline
cargo test --offline
cargo run --offline

Mis archivos y GitHub

El editor guarda un borrador en este navegador y permite descargar o publicar tu .rs. Para ejecutarlo en el proyecto, guarda el archivo editado como src/main.rs. El ZIP contiene la versión inicial; los resultados preparados no cambian con tus ediciones. La evaluación online no verifica ejecución local.

Windows macOS Ubuntu

A tu ritmo

Mis archivos y GitHub

Cada lección puede convertirse en un registro propio: código, notas o un plan de práctica. Guardar un archivo en GitHub es opcional y no cambia tus XP.

Manual del alumno

El editor y las descargas se abren cuando esta lección esté disponible para tu cuenta. Revisa el acceso indicado abajo o vuelve al mapa de la ruta.

Comprobando tu acceso a esta lección…

Tu camino, paso a paso

Descargar material de la actividad

Descarga el ejemplo de la lección y un cuaderno para tus notas. El ZIP incluye una guía para organizar actividades en uno o varios repositorios. Publicar es opcional; las cuentas habilitadas también pueden usar el botón de envío a GitHub.

Tu archivo de esta lección

Edita el ejemplo o registra lo aprendido. Este espacio no ejecuta código ni corrige respuestas. El borrador se guarda solo en este navegador, separado por cuenta; tú decides cuándo descargar o enviar a GitHub.

El ejemplo puede ser solo un fragmento o una guía. Cambiar la extensión no lo convierte en un programa completo. El ZIP de la actividad contiene material inicial; el botón de archivo editado descarga tu texto.

Mi código o mis notas

// Taller de equipos
// Simulación local: los cambios de existencias no se guardan.
mod inventory {
  use std::collections::HashMap;

#[derive(Debug, PartialEq)]
  pub enum Error { Format, Name, Quantity, Duplicate, Empty, TooMany, Unavailable, OverReturn }
  pub enum Action { Take(u16), Return(u16) }
  #[derive(Debug)]
  pub struct Item { name: String, total: u16, available: u16 }

impl Item {
    pub fn new(name: &str, total: u16) -> Result<Self, Error> {
      let name = name.trim();
      if name.is_empty() || name.chars().count() > 40
        || name.chars().any(|c| c.is_control() || c == ';') {
        return Err(Error::Name);
      }
      if !(1..=20).contains(&total) { return Err(Error::Quantity); }
      Ok(Self { name: name.into(), total, available: total })
    }
    pub fn name(&self) -> &str { &self.name }
    pub fn total(&self) -> u16 { self.total }
    pub fn available(&self) -> u16 { self.available }
    pub fn apply(&mut self, action: Action) -> Result<(), Error> {
      match action {
        Action::Take(n) => {
          if n == 0 { return Err(Error::Quantity); }
          if n > self.available { return Err(Error::Unavailable); }
          self.available -= n;
        }
        Action::Return(n) => {
          if n == 0 { return Err(Error::Quantity); }
          if n > self.total - self.available { return Err(Error::OverReturn); }
          self.available += n;
        }
      }
      Ok(())
    }
  }

pub fn parse(text: &str) -> Result<Vec<Item>, Error> {
    let mut items = Vec::new();
    let mut names = HashMap::new();
    for raw in text.lines() {
      if raw.trim().is_empty() { continue; }
      if items.len() == 20 { return Err(Error::TooMany); }
      let (name, amount) = raw.split_once(';').ok_or(Error::Format)?;
      let amount = amount.trim().parse::<u16>().map_err(|_| Error::Quantity)?;
      let item = Item::new(name, amount)?;
      if names.insert(item.name.clone(), ()).is_some() { return Err(Error::Duplicate); }
      items.push(item);
    }
    if items.is_empty() { return Err(Error::Empty); }
    Ok(items)
  }
}

use inventory::{Action, Error};
use std::io::Read;

fn explain(error: &Error) -> &'static str {
  match error {
    Error::Format => "Usa nombre;cantidad.",
    Error::Name => "Nombre inválido: usa de 1 a 40 valores escalares sin controles ni punto y coma.",
    Error::Quantity => "Cantidad inválida: usa un entero de 1 a 20 para el catálogo o una operación positiva.",
    Error::Duplicate => "Nombre repetido en el catálogo.",
    Error::Empty => "El catálogo está vacío.",
    Error::TooMany => "El catálogo acepta como máximo 20 equipos.",
    Error::Unavailable => "No hay suficientes unidades.",
    Error::OverReturn => "La devolución supera la cantidad prestada.",
  }
}

fn run() -> Result<(), String> {
  let mut args = std::env::args_os().skip(1);
  let input = args.next();
  if args.next().is_some() { return Err("Uso: cargo run --offline -- [items.txt] (como máximo una ruta).".into()); }
  let text = if let Some(path) = input {
    let file = std::fs::File::open(path).map_err(|_| "No se pudo leer el archivo como UTF-8; comprueba ruta y permisos.")?;
    let mut text = String::new();
    file.take(65_537).read_to_string(&mut text).map_err(|_| "No se pudo leer el archivo como UTF-8; comprueba ruta y permisos.")?;
    if text.len() > 65_536 { return Err("El archivo debe tener como máximo 64 KiB.".into()); }
    text
  } else { String::from("sensor;3\nmotor;2\n") };
  let mut items = inventory::parse(&text).map_err(|e| explain(&e).to_owned())?;
  println!("Taller de equipos");
  if let Some(first) = items.first_mut() {
    println!("{}: {}", first.name(), first.available());
    first.apply(Action::Take(1)).map_err(|e| explain(&e).to_owned())?;
    println!("Tras prestar una unidad: {}", first.available());
    match first.apply(Action::Take(20)) {
      Err(error) => println!("Pedido rechazado: {}", explain(&error)),
      Ok(()) => return Err("La simulación esperaba un rechazo: revisa la regla.".into()),
    }
    println!("Disponible tras el rechazo: {}", first.available());
    first.apply(Action::Return(1)).map_err(|e| explain(&e).to_owned())?;
  }
  println!("Informe: disponible/total");
  for item in &items { println!("{}: {}/{}", item.name(), item.available(), item.total()); }
  println!("Simulación local: los cambios de existencias no se guardan.");
  Ok(())
}

fn main() -> std::process::ExitCode {
  match run() {
    Ok(()) => std::process::ExitCode::SUCCESS,
    Err(error) => { eprintln!("{error}"); std::process::ExitCode::FAILURE }
  }
}

#[cfg(test)]
mod tests {
  use super::*;
  #[test]
  fn state_after_actions() {
    let mut item = inventory::Item::new("sensor", 3).unwrap();
    assert_eq!(item.apply(Action::Take(1)), Ok(()));
    assert_eq!(item.available(), 2);
    assert_eq!(item.apply(Action::Take(20)), Err(Error::Unavailable));
    assert_eq!(item.available(), 2);
    assert_eq!(item.apply(Action::Return(1)), Ok(()));
    assert_eq!(item.available(), 3);
    assert_eq!(item.apply(Action::Return(1)), Err(Error::OverReturn));
    assert_eq!(item.available(), 3);
  }
  #[test]
  fn limits_and_zero() {
    let mut item = inventory::Item::new("motor", 20).unwrap();
    assert_eq!(item.apply(Action::Take(0)), Err(Error::Quantity));
    assert_eq!(item.available(), 20);
    assert_eq!(item.apply(Action::Take(20)), Ok(()));
    assert_eq!(item.available(), 0);
    assert_eq!(item.apply(Action::Take(1)), Err(Error::Unavailable));
    assert_eq!(item.available(), 0);
    assert_eq!(item.apply(Action::Return(0)), Err(Error::Quantity));
    assert_eq!(item.available(), 0);
    assert_eq!(item.apply(Action::Return(20)), Ok(()));
    assert_eq!(item.available(), 20);
  }
  #[test]
  fn order_and_spaces() {
    let items = inventory::parse(" motor ; 2 \r\n\r\nsensor;3\r\n").unwrap();
    assert_eq!(items.len(), 2);
    assert_eq!(items[0].name(), "motor");
    assert_eq!(items[1].available(), 3);
  }
  #[test]
  fn invalid_records() {
    for (input, expected) in [("", Error::Empty), (" \n", Error::Empty),
      ("sensor", Error::Format), (";3", Error::Name), ("sensor;0", Error::Quantity),
      ("sensor;21", Error::Quantity), ("sensor;-1", Error::Quantity),
      ("sensor;abc", Error::Quantity), ("sensor;2;3", Error::Quantity),
      ("sensor;3\nsensor;2", Error::Duplicate), ("sensor;3\n sensor ;2", Error::Duplicate),
      ("sensor;3\nbroken", Error::Format)] {
      assert_eq!(inventory::parse(input).unwrap_err(), expected);
    }
  }
  #[test]
  fn name_and_size_limits() {
    assert!(inventory::Item::new(&"é".repeat(40), 1).is_ok());
    assert_eq!(inventory::Item::new(&"é".repeat(41), 1).unwrap_err(), Error::Name);
    assert_eq!(inventory::Item::new("a\tb", 1).unwrap_err(), Error::Name);
    assert_eq!(inventory::Item::new("a;b", 1).unwrap_err(), Error::Name);
    let mut text = (0..20).map(|n| format!("item{n};1\n")).collect::<String>();
    assert_eq!(inventory::parse(&text).unwrap().len(), 20);
    text.push_str("extra;1\n");
    assert_eq!(inventory::parse(&text).unwrap_err(), Error::TooMany);
  }
  #[test]
  fn stock_invariant() {
    for total in 1..=20 {
      for taken in 0..=total {
        for request in 0..=21 {
          for (returning, action) in [(false, Action::Take(request)), (true, Action::Return(request))] {
            let mut item = inventory::Item::new("sensor", total).unwrap();
            if taken > 0 { item.apply(Action::Take(taken)).unwrap(); }
            let before = item.available();
            let result = item.apply(action);
            let valid = request > 0 && request <= if returning { taken } else { before };
            assert_eq!(result.is_ok(), valid);
            assert!(item.available() <= total);
            if result.is_err() { assert_eq!(item.available(), before); }
          }
        }
      }
    }
  }
}

Formato del archivo

Tu texto se guardará en este navegador al editarlo. En un equipo compartido, borra los borradores al terminar.

El envío directo acepta hasta 8 KiB de texto en un archivo. Usa las descargas y la guía manual para proyectos con varios archivos.

Tu taller de equipos

Vamos a descubrir juntos

Una guía para seguir a tu ritmo

Enlaces oficiales y siguiente paso

Ahora te toca

Lee, predice, investiga

Tu desafío de transferencia

Inténtalo de nuevo en otro momento

Llévatelo contigo

Tu espacio de práctica Rust II

Mis archivos y GitHub

Tu archivo de esta lección

Guardar en mi GitHub

Rullstpetbot