Plano de Estudos Rust: Nível Júnior (0-6 Meses)

fn main() {
    println!("Olá, mundo Rust!");

    // Experimente modificar e recompilar
    let nome = "Rustacean";
    println!("Bem-vindo(a), {}!", nome);
}

fn calcular_imc(peso: f64, altura: f64) -> f64 {
    peso / (altura * altura) // expressão - sem ponto-e-vírgula
}

fn classificar_imc(imc: f64) -> &'static str {
    if imc < 18.5 {
        "Abaixo do peso"
    } else if imc < 25.0 {
        "Peso normal"
    } else if imc < 30.0 {
        "Sobrepeso"
    } else {
        "Obesidade"
    }
}

fn main() {
    let peso = 75.0;
    let altura = 1.78;
    let imc = calcular_imc(peso, altura);

    println!("IMC: {:.1} - {}", imc, classificar_imc(imc));
}

fn fibonacci(n: u32) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a: u64 = 0;
            let mut b: u64 = 1;
            for _ in 2..=n {
                let temp = b;
                b = a + b;
                a = temp;
            }
            b
        }
    }
}

fn main() {
    for i in 0..10 {
        println!("fibonacci({}) = {}", i, fibonacci(i));
    }
}

fn contar_vogais(texto: &str) -> usize {
    texto.chars()
        .filter(|c| "aeiouáéíóúâêôãõ".contains(c.to_lowercase().next().unwrap()))
        .count()
}

fn inverter_palavras(frase: &str) -> String {
    frase.split_whitespace()
        .rev()
        .collect::<Vec<&str>>()
        .join(" ")
}

fn main() {
    let frase = String::from("Rust é incrível para sistemas");
    println!("Vogais: {}", contar_vogais(&frase));
    println!("Invertida: {}", inverter_palavras(&frase));
}

fn main() {
    // Move semantics com String
    let s1 = String::from("Olá");
    let s2 = s1; // s1 foi movido para s2
    // println!("{}", s1); // ERRO: s1 não é mais válido
    println!("{}", s2);

    // Copy semantics com tipos primitivos
    let x = 42;
    let y = x; // x é copiado, não movido
    println!("x = {}, y = {}", x, y); // Funciona!

    // Passando ownership para função
    let nome = String::from("Brasil");
    imprimir(nome); // nome é movido para a função
    // println!("{}", nome); // ERRO: nome foi movido
}

fn imprimir(texto: String) {
    println!("{}", texto);
} // texto é dropped aqui

fn adicionar_sobrenome(nome: &mut String, sobrenome: &str) {
    nome.push(' ');
    nome.push_str(sobrenome);
}

fn tamanho(texto: &str) -> usize {
    texto.len()
}

fn main() {
    let mut nome = String::from("Ferris");

    // Referência imutável - pode ter várias simultâneas
    let tam = tamanho(&nome);
    println!("Tamanho: {}", tam);

    // Referência mutável - apenas uma por vez
    adicionar_sobrenome(&mut nome, "the Crab");
    println!("Nome completo: {}", nome);
}

struct ContaBancaria {
    titular: String,
    saldo: f64,
    ativa: bool,
}

impl ContaBancaria {
    fn nova(titular: String) -> Self {
        ContaBancaria {
            titular,
            saldo: 0.0,
            ativa: true,
        }
    }

    fn depositar(&mut self, valor: f64) -> Result<f64, String> {
        if valor <= 0.0 {
            return Err("Valor deve ser positivo".to_string());
        }
        self.saldo += valor;
        Ok(self.saldo)
    }

    fn sacar(&mut self, valor: f64) -> Result<f64, String> {
        if valor <= 0.0 {
            return Err("Valor deve ser positivo".to_string());
        }
        if valor > self.saldo {
            return Err("Saldo insuficiente".to_string());
        }
        self.saldo -= valor;
        Ok(self.saldo)
    }

    fn extrato(&self) {
        println!("=== Extrato ===");
        println!("Titular: {}", self.titular);
        println!("Saldo: R$ {:.2}", self.saldo);
        println!("Status: {}", if self.ativa { "Ativa" } else { "Inativa" });
    }
}

fn main() {
    let mut conta = ContaBancaria::nova("Maria Silva".to_string());
    conta.depositar(1500.0).unwrap();
    conta.sacar(350.0).unwrap();
    conta.extrato();
}

enum Forma {
    Circulo(f64),
    Retangulo(f64, f64),
    Triangulo(f64, f64, f64),
}

impl Forma {
    fn area(&self) -> f64 {
        match self {
            Forma::Circulo(raio) => std::f64::consts::PI * raio * raio,
            Forma::Retangulo(largura, altura) => largura * altura,
            Forma::Triangulo(a, b, c) => {
                let s = (a + b + c) / 2.0;
                (s * (s - a) * (s - b) * (s - c)).sqrt()
            }
        }
    }

    fn descricao(&self) -> String {
        match self {
            Forma::Circulo(r) => format!("Círculo com raio {:.1}", r),
            Forma::Retangulo(l, a) => format!("Retângulo {}x{}", l, a),
            Forma::Triangulo(a, b, c) => format!("Triângulo ({}, {}, {})", a, b, c),
        }
    }
}

fn main() {
    let formas = vec![
        Forma::Circulo(5.0),
        Forma::Retangulo(4.0, 6.0),
        Forma::Triangulo(3.0, 4.0, 5.0),
    ];

    for forma in &formas {
        println!("{}: área = {:.2}", forma.descricao(), forma.area());
    }
}

use std::fs;
use std::num::ParseIntError;

#[derive(Debug)]
enum AppError {
    ArquivoNaoEncontrado(String),
    ParseErro(ParseIntError),
    ValorInvalido(String),
}

impl std::fmt::Display for AppError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AppError::ArquivoNaoEncontrado(nome) => {
                write!(f, "Arquivo não encontrado: {}", nome)
            }
            AppError::ParseErro(e) => write!(f, "Erro ao converter: {}", e),
            AppError::ValorInvalido(msg) => write!(f, "Valor inválido: {}", msg),
        }
    }
}

impl From<ParseIntError> for AppError {
    fn from(e: ParseIntError) -> Self {
        AppError::ParseErro(e)
    }
}

fn ler_numero_do_arquivo(caminho: &str) -> Result<i32, AppError> {
    let conteudo = fs::read_to_string(caminho)
        .map_err(|_| AppError::ArquivoNaoEncontrado(caminho.to_string()))?;

    let numero: i32 = conteudo.trim().parse()?;

    if numero < 0 {
        return Err(AppError::ValorInvalido(
            "Número deve ser positivo".to_string(),
        ));
    }

    Ok(numero)
}

use std::collections::HashMap;

fn analise_de_texto(texto: &str) -> HashMap<String, usize> {
    let mut contagem: HashMap<String, usize> = HashMap::new();

    for palavra in texto.split_whitespace() {
        let palavra_limpa = palavra
            .to_lowercase()
            .chars()
            .filter(|c| c.is_alphabetic())
            .collect::<String>();

        if !palavra_limpa.is_empty() {
            *contagem.entry(palavra_limpa).or_insert(0) += 1;
        }
    }

    contagem
}

fn top_palavras(contagem: &HashMap<String, usize>, n: usize) -> Vec<(&String, &usize)> {
    let mut pares: Vec<_> = contagem.iter().collect();
    pares.sort_by(|a, b| b.1.cmp(a.1));
    pares.into_iter().take(n).collect()
}

fn main() {
    let texto = "Rust é seguro. Rust é rápido. Rust é incrível. \
                 Aprender Rust vale a pena.";

    let contagem = analise_de_texto(texto);

    println!("Top 5 palavras:");
    for (palavra, freq) in top_palavras(&contagem, 5) {
        println!("  {}: {} vezes", palavra, freq);
    }

    // Exemplo com iteradores encadeados
    let numeros = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let soma_pares: i32 = numeros
        .iter()
        .filter(|&&n| n % 2 == 0)
        .map(|&n| n * n)
        .sum();

    println!("Soma dos quadrados dos pares: {}", soma_pares);
}

use std::fmt;

trait Resumivel {
    fn resumo(&self) -> String;

    fn tipo(&self) -> &str {
        "Conteúdo genérico" // implementação padrão
    }
}

struct Artigo {
    titulo: String,
    autor: String,
    conteudo: String,
}

struct Tweet {
    usuario: String,
    texto: String,
    curtidas: u32,
}

impl Resumivel for Artigo {
    fn resumo(&self) -> String {
        format!("{}, por {} - {}...", self.titulo, self.autor, &self.conteudo[..50.min(self.conteudo.len())])
    }

    fn tipo(&self) -> &str {
        "Artigo"
    }
}

impl Resumivel for Tweet {
    fn resumo(&self) -> String {
        format!("@{}: {} ({} curtidas)", self.usuario, self.texto, self.curtidas)
    }

    fn tipo(&self) -> &str {
        "Tweet"
    }
}

impl fmt::Display for Artigo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "[{}] {} por {}", self.tipo(), self.titulo, self.autor)
    }
}

fn imprimir_resumo(item: &impl Resumivel) {
    println!("[{}] {}", item.tipo(), item.resumo());
}

// O compilador precisa saber qual referência determina o lifetime do retorno
fn maior<'a>(s1: &'a str, s2: &'a str) -> &'a str {
    if s1.len() > s2.len() {
        s1
    } else {
        s2
    }
}

// Struct com lifetime - garante que a referência vive o suficiente
struct Trecho<'a> {
    texto: &'a str,
    linha: usize,
}

impl<'a> Trecho<'a> {
    fn novo(texto: &'a str, linha: usize) -> Self {
        Trecho { texto, linha }
    }

    fn exibir(&self) {
        println!("Linha {}: {}", self.linha, self.texto);
    }
}

fn main() {
    let texto1 = String::from("Rust");
    let resultado;
    {
        let texto2 = String::from("Ferrugem");
        resultado = maior(&texto1, &texto2);
        println!("Maior: {}", resultado);
    }
    // resultado não pode ser usado aqui se dependesse de texto2
}

// src/models/usuario.rs
pub struct Usuario {
    pub nome: String,
    pub email: String,
    senha_hash: String, // privado
}

impl Usuario {
    pub fn novo(nome: String, email: String, senha: &str) -> Self {
        Usuario {
            nome,
            email,
            senha_hash: format!("hash_{}", senha), // simplificado
        }
    }

    pub fn verificar_senha(&self, senha: &str) -> bool {
        self.senha_hash == format!("hash_{}", senha)
    }
}

pub fn dividir(a: f64, b: f64) -> Result<f64, String> {
    if b == 0.0 {
        Err("Divisão por zero".to_string())
    } else {
        Ok(a / b)
    }
}

pub fn eh_palindromo(texto: &str) -> bool {
    let limpo: String = texto
        .to_lowercase()
        .chars()
        .filter(|c| c.is_alphanumeric())
        .collect();
    let reverso: String = limpo.chars().rev().collect();
    limpo == reverso
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn dividir_numeros_validos() {
        assert_eq!(dividir(10.0, 2.0).unwrap(), 5.0);
    }

    #[test]
    fn dividir_por_zero_retorna_erro() {
        assert!(dividir(10.0, 0.0).is_err());
    }

    #[test]
    fn palindromo_simples() {
        assert!(eh_palindromo("arara"));
        assert!(eh_palindromo("Ana"));
        assert!(!eh_palindromo("rust"));
    }

    #[test]
    fn palindromo_com_espacos() {
        assert!(eh_palindromo("A base do teto desaba"));
    }
}

//! # Minha Biblioteca de Utilidades
//!
//! Esta crate fornece funções utilitárias para manipulação
//! de texto e cálculos matemáticos.

/// Calcula a média de uma sequência de números.
///
/// # Argumentos
///
/// * `numeros` - Um slice de valores f64
///
/// # Retorno
///
/// Retorna `Some(media)` se o slice não estiver vazio,
/// ou `None` caso contrário.
///
/// # Exemplos
///
/// ```
/// let nums = vec![1.0, 2.0, 3.0, 4.0, 5.0];
/// let media = minha_lib::media(&nums);
/// assert_eq!(media, Some(3.0));
/// ```
pub fn media(numeros: &[f64]) -> Option<f64> {
    if numeros.is_empty() {
        return None;
    }
    Some(numeros.iter().sum::<f64>() / numeros.len() as f64)
}

[package]
name = "meu-projeto"
version = "0.1.0"
edition = "2021"
authors = ["Seu Nome <email@exemplo.com>"]
description = "Descrição do meu projeto"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tokio = { version = "1", features = ["full"] }
clap = { version = "4", features = ["derive"] }

[dev-dependencies]
assert_cmd = "2.0"
predicates = "3.0"

use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "tarefas")]
#[command(about = "Gerenciador de tarefas no terminal")]
struct Cli {
    #[command(subcommand)]
    comando: Comandos,
}

#[derive(Subcommand)]
enum Comandos {
    /// Adiciona uma nova tarefa
    Adicionar {
        /// Título da tarefa
        titulo: String,
        /// Prioridade (alta, media, baixa)
        #[arg(short, long, default_value = "media")]
        prioridade: String,
    },
    /// Lista todas as tarefas
    Listar {
        /// Filtrar por status (todas, pendentes, concluidas)
        #[arg(short, long, default_value = "todas")]
        filtro: String,
    },
    /// Marca uma tarefa como concluída
    Concluir {
        /// ID da tarefa
        id: usize,
    },
    /// Remove uma tarefa
    Remover {
        /// ID da tarefa
        id: usize,
    },
}

use axum::{
    extract::{Path, State},
    http::StatusCode,
    routing::{get, post},
    Json, Router,
};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Clone)]
struct Nota {
    id: Option<i64>,
    titulo: String,
    conteudo: String,
    tags: Vec<String>,
}

async fn criar_nota(
    State(pool): State<sqlx::SqlitePool>,
    Json(nota): Json<Nota>,
) -> Result<(StatusCode, Json<Nota>), StatusCode> {
    let resultado = sqlx::query_as!(
        Nota,
        "INSERT INTO notas (titulo, conteudo) VALUES (?, ?) RETURNING *",
        nota.titulo,
        nota.conteudo,
    )
    .fetch_one(&pool)
    .await
    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;

    Ok((StatusCode::CREATED, Json(resultado)))
}