Rust II: data, choices and confidence · Lesson 12 / 12

Your equipment workshop

Now the pieces work together: a validated catalogue, checkout, return, report and tests. Explain both success and a rejected attempt.

Let's discover together

1
Download the activity ZIP and extract it into a new folder. It includes Cargo.toml, src/main.rs, items.txt, README, workbook and GitHub guide. In the Cargo.toml folder run cargo test and cargo run --offline. There are no external dependencies.
2
The program starts with sensor;3 and motor;2. It checks out one unit of the first item, tries to take 20, then returns one. The impossible request preserves state; the final report keeps file order.
3
cargo run --offline -- items.txt reads your UTF-8 file. The parser accepts up to 20 unique names of 1 to 40 scalar values, with no controls or semicolons; quantities range from 1 to 20. Blank lines are ignored; one invalid record rejects the entire set.
4
This is a local simulation without accounts, networking, a database or persistent checkouts. It reads and prints; it does not change items.txt. Save edits in your editor and record results in the workbook. The publishing panel sends one file at a time after confirmation.

FROM LESSON TO PRACTICE

A guide to follow at your pace

Read the steps before using the reference below. Commands run in the indicated system’s terminal; signup happens on the official site. Rullst Academy exercises are practice and do not verify your installation or external account.

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}");
}

Official links and next step

Official Rust reference

✦

YOUR MISSION

Run, test and modify a complete Rust project using fictional data.

Now it's your turn

Discovery workshop

Read, predict, investigate

Predict before revealing. This panel shows prepared results; it does not compile your code. Compiler errors are summarised; exact wording can vary with the compiler version.

Mini experiment

Learning simulation: compare cards and check your predictions. The browser is not compiling Rust or starting a server.

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}");
}

This scenario’s result

01After taking 1 from 302After rejecting checkout of 2003After returning 1

Build your answers and check when you are ready.

A moment to understand

What evidence shows a rejected checkout preserved state?

Only printing an attractive message.Compare quantity before and after, and check the error.Only being able to compile.

I need a hint

An error can be reported after an improper change; check the data too.

Loading your journey…

How can I tell what I learned?

Use the objectives and challenge below for reflection or a conversation with someone who can help. This is guided self-assessment: it sends no answers, awards no XP and does not automatically verify independence.

In Foundations, change an example, predict results, check a normal case and an error case, and explain your choices. If you need help, identify what to practice again.

Your transfer challenge

Create a catalogue of three fictional items. Test empty input, duplicates and quantity 21. Add a checkout/return sequence and a test that fails if rejection changes state. Explain a limitation and optionally publish with a README; include no personal data.

Keep evidence: prediction, attempt, result, an original change and what you still cannot explain. Seek feedback when possible; if studying alone, return later without copying and compare attempts.

Try again another time

After a break, explain the idea without opening the solution and try a different example. Compare with your first attempt: what can you do independently, and where do you need a hint? You may write, speak or draw; choose a way to check the same idea. Record help received, including AI, and revisit the part you need. There is no universal deadline or extra XP for this record.

Completions and XP record Rullst Academy assessments. An introductory track can help everyday life and prepare further study; alone it does not prove complete mastery or professional readiness. Level indicates depth, not age.

Take it with you

RUST II · .rs

Your Rust II workbench

Read, predict and answer here. To actually compile, extract the activity ZIP into a new folder, open a terminal beside Cargo.toml and use the commands below. Rust and your operating system tools must be installed.

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

My files and GitHub

The editor below saves a draft in this browser and lets you download or publish your .rs. To run it in the project, save the edited file as src/main.rs. The ZIP contains the starter version; prepared results do not change with your edits. Online grading does not verify local execution.

Windows macOS Ubuntu

At your own pace

My files and GitHub

Every lesson can become your own record: code, notes or a practice plan. Saving a file to GitHub is optional and does not change your XP.

Student guide

The editor and downloads open when this lesson is available to your account. Check access below or return to the track map.

Checking your access to this lesson…

Your path, step by step

Download activity materials

Download the lesson example and a workbook for your notes. The ZIP includes a guide to organizing activities in one or more repositories. Publishing is optional; eligible accounts can also use the GitHub upload button.

Your file for this lesson

Edit the example or record what you learned. This space does not run code or grade answers. The draft is saved only in this browser, separately per account; you choose when to download or upload to GitHub.

The example may be only a snippet or outline. Changing the extension does not make it a complete program. The activity ZIP contains starting material; the edited-file button downloads your text.

My code or notes

// Equipment workshop
// Local simulation: stock changes are not saved.
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 => "Use name;quantity.",
    Error::Name => "Invalid name: use 1 to 40 scalar values without controls or semicolons.",
    Error::Quantity => "Invalid quantity: use an integer from 1 to 20 for the catalogue or a positive operation.",
    Error::Duplicate => "Duplicate catalogue name.",
    Error::Empty => "The catalogue is empty.",
    Error::TooMany => "The catalogue accepts at most 20 items.",
    Error::Unavailable => "Not enough units are available.",
    Error::OverReturn => "The return exceeds the borrowed quantity.",
  }
}

fn run() -> Result<(), String> {
  let mut args = std::env::args_os().skip(1);
  let input = args.next();
  if args.next().is_some() { return Err("Usage: cargo run --offline -- [items.txt] (at most one path).".into()); }
  let text = if let Some(path) = input {
    let file = std::fs::File::open(path).map_err(|_| "Could not read the file as UTF-8; check its path and permissions.")?;
    let mut text = String::new();
    file.take(65_537).read_to_string(&mut text).map_err(|_| "Could not read the file as UTF-8; check its path and permissions.")?;
    if text.len() > 65_536 { return Err("The file must be at most 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!("Equipment workshop");
  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!("After checking out one unit: {}", first.available());
    match first.apply(Action::Take(20)) {
      Err(error) => println!("Request rejected: {}", explain(&error)),
      Ok(()) => return Err("The simulation expected rejection: review the rule.".into()),
    }
    println!("Available after rejection: {}", first.available());
    first.apply(Action::Return(1)).map_err(|e| explain(&e).to_owned())?;
  }
  println!("Report: available/total");
  for item in &items { println!("{}: {}/{}", item.name(), item.available(), item.total()); }
  println!("Local simulation: stock changes are not saved.");
  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); }
          }
        }
      }
    }
  }
}

File format

Your text will be saved in this browser when you edit it. On a shared computer, clear your drafts when finished.

Direct upload accepts up to 8 KiB of text in one file. Use downloads and the manual guide for projects with multiple files.

Your equipment workshop

Let's discover together

A guide to follow at your pace

Official links and next step

Now it's your turn

Read, predict, investigate

Your transfer challenge

Try again another time

Take it with you

Your Rust II workbench

My files and GitHub

Your file for this lesson

Save to my GitHub

Rullstpetbot