Rust II: dados, escolhas e confiança · Lição 12 / 12

Sua oficina de equipamentos

Agora as peças trabalham juntas: catálogo validado, retirada, devolução, relatório e testes. Sua missão é explicar tanto o caminho feliz quanto uma tentativa recusada.

Vamos descobrir juntos

1
Baixe o ZIP da atividade e extraia em uma pasta nova. Ele inclui Cargo.toml, src/main.rs, items.txt, README, caderno e guia GitHub. Na pasta de Cargo.toml, execute cargo test e cargo run --offline. Não há dependências externas.
2
O programa começa com sensor;3 e motor;2. Retira uma unidade do primeiro equipamento, tenta retirar 20 e devolve uma. A tentativa impossível mantém o estado; o relatório final preserva a ordem do arquivo.
3
cargo run --offline -- items.txt lê seu arquivo UTF-8. O parser aceita até 20 nomes únicos, com 1 a 40 valores escalares, sem controles nem ponto e vírgula; quantidades de 1 a 20. Linhas vazias são ignoradas; um registro inválido recusa o conjunto todo.
4
É uma simulação local, sem contas, rede, banco de dados ou persistência de empréstimos. O programa lê dados e imprime; não altera items.txt. Salve suas mudanças no editor e registre resultados no caderno. A publicação pelo painel envia um arquivo por vez, após sua confirmação.

DA LIÇÃO PARA A PRÁTICA

Guia para acompanhar no seu ritmo

Leia os passos antes de usar a referência abaixo. Comandos são executados no terminal do sistema indicado; o cadastro acontece no site oficial. Os exercícios da Rullst Academy são treino e não verificam sua instalação ou conta 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}");
}

Links oficiais e próximo passo

Referência oficial de Rust

✦

SUA MISSÃO

Executar, testar e modificar um projeto Rust completo com dados fictícios.

Agora é a sua vez

Oficina de descobertas

Leia, preveja, investigue

Preveja antes de mostrar. Este painel revela resultados preparados, não compila seu código. Erros de compilação são resumidos; o texto exato pode variar com a versão do compilador.

Mini experimento

Simulação didática: compare os cartões e confira suas previsões. O navegador não está compilando Rust nem iniciando um 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 deste cenário

01Após retirar 1 de 302Após recusar a retirada de 2003Após devolver 1

Monte suas respostas e confira quando estiver pronto.

Uma pausa para entender

Qual evidência mostra que uma retirada recusada preservou o estado?

Somente imprimir uma mensagem bonita.Comparar a quantidade antes e depois, além de conferir o erro.Somente conseguir compilar.

Preciso de uma pista

Um erro pode ser informado depois de uma alteração indevida; confira também os dados.

Carregando sua jornada…

Como perceber o que aprendi?

Use os objetivos e o desafio abaixo como uma conversa com você mesmo ou com alguém que possa ajudar. É uma autoavaliação orientada: não envia respostas, não concede XP e não verifica automaticamente sua autonomia.

Em Fundamentos, altere um exemplo, preveja o resultado, confira um caso comum e um caso de erro, e explique suas escolhas. Se precisar de ajuda, identifique o trecho que quer praticar novamente.

Seu desafio de transferência

Crie um catálogo com três equipamentos fictícios. Teste vazio, duplicata e quantidade 21. Acrescente uma sequência de retiradas/devoluções e um teste que falhe se uma operação recusada mudar o estado. Explique uma limitação e publique opcionalmente com README; não inclua dados pessoais.

Guarde uma evidência: previsão, tentativa, resultado, uma mudança sua e o que ainda não consegue explicar. Quando possível, peça feedback a alguém; se estudar sozinho, retome depois sem copiar e compare suas tentativas.

Tente de novo em outro momento

Depois de uma pausa, explique a ideia sem abrir a solução e tente um exemplo diferente. Compare com sua primeira tentativa: o que consegue fazer sozinho e onde precisa de uma pista? Você pode escrever, falar ou desenhar; escolha uma forma que permita conferir a mesma ideia. Registre ajuda recebida, inclusive de IA, e volte ao trecho necessário. Não há prazo universal nem XP extra por esse registro.

Conclusões e XP registram as avaliações da Rullst Academy. Uma trilha introdutória pode ajudar na vida cotidiana e preparar próximos estudos; sozinha não comprova domínio completo ou preparo profissional. O nível indica profundidade, não idade.

Leve com você

RUST II · .rs

Sua bancada Rust II

Leia, preveja e responda aqui. Para compilar de verdade, extraia o ZIP da atividade em uma pasta nova, abra o terminal ao lado de Cargo.toml e use os comandos abaixo. Rust e as ferramentas do seu sistema precisam estar instalados.

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

Meus arquivos e GitHub

O editor abaixo salva um rascunho neste navegador e permite baixar ou publicar seu .rs. Para executá-lo no projeto, salve o arquivo editado como src/main.rs. O ZIP contém a versão inicial; os resultados preparados não mudam com suas edições. A avaliação online não comprova execução local.

Windows macOS Ubuntu

No seu ritmo

Meus arquivos e GitHub

Toda lição pode virar um registro seu: código, anotações ou um plano de prática. Guardar um arquivo no GitHub é opcional e não altera seu XP.

Manual do aluno

O editor e os downloads abrem quando esta lição estiver liberada para sua conta. Confira o acesso abaixo ou volte ao mapa da trilha.

Conferindo seu acesso à lição…

Seu caminho, passo a passo

Baixar material da atividade

Baixe o exemplo da lição e um caderno para suas anotações. O ZIP inclui um guia para organizar atividades em um ou mais repositórios. Publicar é opcional; contas elegíveis também podem usar o botão de envio ao GitHub.

Seu arquivo desta lição

Edite o exemplo ou registre o que aprendeu. Este espaço não executa código nem corrige respostas. O rascunho é salvo apenas neste navegador, separado por conta; baixar e enviar ao GitHub são ações suas.

O exemplo pode ser apenas um trecho ou roteiro. Mudar a extensão não o transforma em programa completo. O ZIP da atividade contém material inicial; o botão de arquivo editado baixa o seu texto.

Meu código ou minhas anotações

// Oficina de equipamentos
// Simulação local: mudanças de estoque não são gravadas.
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 nome;quantidade.",
    Error::Name => "Nome inválido: use 1 a 40 valores escalares, sem controles ou ponto e vírgula.",
    Error::Quantity => "Quantidade inválida: use um inteiro de 1 a 20 para o catálogo ou uma operação positiva.",
    Error::Duplicate => "Nome repetido no catálogo.",
    Error::Empty => "O catálogo está vazio.",
    Error::TooMany => "O catálogo aceita no máximo 20 equipamentos.",
    Error::Unavailable => "Não há unidades suficientes.",
    Error::OverReturn => "A devolução supera a quantidade emprestada.",
  }
}

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] (no máximo um caminho).".into()); }
  let text = if let Some(path) = input {
    let file = std::fs::File::open(path).map_err(|_| "Não foi possível ler o arquivo como UTF-8; confira caminho e permissões.")?;
    let mut text = String::new();
    file.take(65_537).read_to_string(&mut text).map_err(|_| "Não foi possível ler o arquivo como UTF-8; confira caminho e permissões.")?;
    if text.len() > 65_536 { return Err("O arquivo deve ter no 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!("Oficina de equipamentos");
  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!("Após retirar uma unidade: {}", first.available());
    match first.apply(Action::Take(20)) {
      Err(error) => println!("Pedido recusado: {}", explain(&error)),
      Ok(()) => return Err("A simulação esperava a recusa: revise a regra.".into()),
    }
    println!("Disponível após a recusa: {}", first.available());
    first.apply(Action::Return(1)).map_err(|e| explain(&e).to_owned())?;
  }
  println!("Relatório: disponível/total");
  for item in &items { println!("{}: {}/{}", item.name(), item.available(), item.total()); }
  println!("Simulação local: mudanças de estoque não são gravadas.");
  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 do arquivo

Seu texto será guardado neste navegador ao editar. Em computador compartilhado, limpe os rascunhos ao terminar.

O envio direto aceita até 8 KiB de texto em um arquivo. Use o download e o guia manual para projetos com vários arquivos.

Sua oficina de equipamentos

Vamos descobrir juntos

Guia para acompanhar no seu ritmo

Links oficiais e próximo passo

Agora é a sua vez

Leia, preveja, investigue

Seu desafio de transferência

Tente de novo em outro momento

Leve com você

Sua bancada Rust II

Meus arquivos e GitHub

Seu arquivo desta lição

Guardar no meu GitHub

Rullstpetbot