A Linguagem de Programação Rust

📚 Resumo do Conteúdo

Um guia introdutório abrangente sobre Rust, cobrindo conceitos de programação de sistemas, segurança de memória, concorrência e a ferramenta Rust (Cargo, rustup). O conteúdo evolui desde a sintaxe básica até a construção de projetos completos, como um servidor web multithread.

Domine a arte da programação de sistemas segura, rápida e concorrente com o guia definitivo para Rust.

Autor: Steve Klabnik e Carol Nichols, com contribuições da Comunidade Rust

Agradecimentos: Contribuições da Comunidade Rust; publicado em formato impresso e ebook pela No Starch Press.

🎯 Objetivos de Aprendizagem

1. Instalar e gerenciar ferramentas Rust usando rustup em diferentes sistemas operacionais.
2. Escrever, compilar e executar um programa Rust básico, identificando os componentes principais do código.
3. Usar Cargo para criar estruturas padrão de projetos, gerenciar compilações e produzir binários otimizados para lançamento.
4. Capturar e armazenar entradas do usuário, gerenciando mutabilidade de variáveis e falhas potenciais de I/O.
5. Integrar dependências externas usando Cargo e gerenciar compilações reprodutíveis por meio do Cargo.lock.
6. Implementar lógica de jogo usando inferência de tipos, análise de strings, loops e o operador de fluxo de controle match.
7. Diferenciar entre constantes e sombreamento de variáveis para gerenciar imutabilidade e escopo de dados.
8. Implementar corretamente tipos escalares (inteiros, ponto flutuante, booleanos, caracteres) e compostos (tuplas, arrays).
9. Distinguir entre declarações e expressões para definir funções com valores de retorno específicos.
10. Distinguir entre memória de pilha e memória de heap e explicar como o Rust gerencia dados na heap.

🔹 Aula 1: Começando com Rust

Visão Geral: Esta aula oferece uma introdução abrangente ao ecossistema Rust, focando na configuração do ambiente e no fluxo fundamental de trabalho de um desenvolvedor Rust. Os alunos passarão da instalação da linguagem via rustup até escrever um programa manual "Olá, Mundo!", finalizando com o domínio do Cargo, o sistema oficial de compilação e gerenciador de pacotes do Rust, para gestão profissional de projetos e otimização de lançamento.

Resultados de Aprendizagem:

• Instalar e gerenciar ferramentas Rust usando rustup em diferentes sistemas operacionais.
• Escrever, compilar e executar um programa Rust básico, identificando os componentes principais do código.
• Usar Cargo para criar estruturas padrão de projetos, gerenciar compilações e produzir binários otimizados para lançamento.

🔹 Aula 2: Prático: Programando um Jogo de Adivinhação

Visão Geral: Esta aula orienta desenvolvedores na construção de um jogo funcional baseado em CLI em Rust. Cobrimos conceitos fundamentais de programação de sistemas, incluindo processamento de entrada do usuário, integração de crates externas para geração de números aleatórios e a abordagem única do Rust para segurança de memória e tratamento de erros através do tipo Result e correspondência de padrões. Ao final, os aprendizes terão uma aplicação robusta que lida com entradas inválidas e garante compilações reprodutíveis.

Resultados de Aprendizagem:

• Capturar e armazenar entradas do usuário enquanto gerenciam mutabilidade de variáveis e falhas potenciais de I/O.
• Integrar dependências externas usando Cargo e gerenciar compilações reprodutíveis via Cargo.lock.
• Implementar a lógica do jogo usando inferência de tipos, análise de strings, loops e o operador de fluxo de controle match.

🔹 Aula 3: Conceitos Comuns de Programação

Visão Geral: Esta aula aborda os blocos de construção fundamentais da programação em Rust, focando em como os dados são armazenados e manipulados. Explora as nuances do sombreamento de variáveis e constantes, a categorização dos dados em tipos escalares e compostos, as regras estruturais das funções e a lógica que governa fluxo de controle e execução repetida.

Resultados de Aprendizagem:

• Diferenciar entre constantes e sombreamento de variáveis para gerenciar imutabilidade e escopo de dados.
• Implementar corretamente tipos escalares (inteiros, ponto flutuante, booleanos, caracteres) e compostos (tuplas, arrays).
• Distinguir entre declarações e expressões para definir funções com valores de retorno específicos.

🔹 Aula 4: Entendendo Propriedade e Memória

Visão Geral: Esta aula explora a abordagem única do Rust para gerenciamento de memória por meio de seu sistema de Propriedade. Em vez de depender de coletor de lixo ou gerenciamento manual de memória, o Rust utiliza um conjunto de regras verificadas em tempo de compilação para garantir segurança de memória. Este módulo cobre os mecanismos da pilha e da heap, o ciclo de vida dos dados e como referências e fatias fornecem acesso seguro e eficiente à memória sem transferir propriedade.

Resultados de Aprendizagem:

• Distinguir entre memória de pilha e memória de heap e explicar como o Rust gerencia dados na heap.
• Aplicar as três regras da Propriedade para prever validade e escopo de variáveis.
• Demonstrar a diferença entre operações Move, Clone e Copy.

🔹 Aula 5: Estruturas: Gerenciando Dados Relacionados

Visão Geral: Esta aula explora como agrupar dados relacionados em tipos personalizados usando estruturas (structs) para criar códigos mais significativos e organizados. Aborda a definição e instanciação de vários tipos de structs (clássicas, de tupla e sem campos), o gerenciamento da propriedade de dados dentro dessas estruturas e a melhoria de structs por meio de traits derivadas como Debug e métodos personalizados definidos via blocos impl.

Resultados de Aprendizagem:

• Definir e instanciar structs usando campos nomeados, sintaxe reduzida e sintaxe de atualização.
• Distinguir entre structs clássicas, structs de tupla e structs sem campo e identificar seus casos de uso.
• Implementar a trait Debug e usar o macro dbg! para inspecionar dados de structs.

🔹 Aula 6: Enums e Correspondência de Padrões

Visão Geral: Esta aula explora como o Rust usa enumerações (enums) para definir tipos enumerando suas variantes possíveis, proporcionando uma maneira mais flexível de agrupar constantes relacionadas e dados do que as structs sozinhas. Cobrimos o papel crítico da enum Option na eliminação de erros de ponteiro nulo e demonstramos como os construtos match e if let fornecem um poderoso fluxo de controle exaustivo para lidar com padrões complexos de dados de forma segura.

Resultados de Aprendizagem:

• Definir enums com diversos tipos de dados e implementar métodos neles usando blocos impl.
• Explicar os benefícios de segurança da enum Option<T> em comparação com valores nulos tradicionais.
• Criar expressões match exaustivas que vinculam valores internos às variantes e usam placeholders gerais.

🔹 Aula 7: Módulos, Pacotes e Crates

Visão Geral: Esta aula explora como o Rust organiza o código para legibilidade e reutilização por meio de seu sistema de módulos. Aborda a criação de uma árvore de módulos, a aplicação de regras de privacidade para controlar a visibilidade de itens e o uso de caminhos e palavras-chave como use e pub para gerenciar escopo e criar APIs limpas.

Resultados de Aprendizagem:

• Organizar o código em uma estrutura hierárquica usando módulos e árvore de módulos.
• Referenciar itens de código usando caminhos absolutos e relativos.
• Controlar a visibilidade de funções, módulos e campos usando a palavra-chave pub e regras de privacidade.

🔹 Aula 8: Coleções Comuns

Visão Geral: Esta aula explora as coleções da biblioteca padrão do Rust, focando especificamente em Vetores, Strings e Mapas Hash. Essas estruturas de dados são armazenadas na heap, permitindo que cresçam ou diminuam durante a execução, e a aula detalha como as regras de propriedade e empréstimo do Rust garantem segurança de memória e desempenho ao gerenciar essas listas de valores, texto codificado em UTF-8 e associações chave-valor.

Resultados de Aprendizagem:

• Implementar listas dinâmicas usando Vec<T> e gerenciar seu ciclo de vida através do verificador de empréstimos.
• Manipular texto codificado em UTF-8 usando o tipo String, navegando pelas complexidades da representação interna e concatenação.
• Aplicar HashMap<K, V> para armazenar e atualizar dados associados de forma eficiente usando a API Entry e considerações personalizadas de hashing.

🔹 Aula 9: Estratégias de Tratamento de Erros

Visão Geral: Esta aula explora a filosofia robusta de tratamento de erros do Rust, que distingue entre erros recuperáveis e não recuperáveis. Os alunos aprenderão a usar o macro panic! para falhas fatais, o tipo Result para falhas gerenciáveis e o operador ? para simplificar a propagação de erros. Além disso, a aula aborda como usar o sistema de tipos do Rust para forçar validação de dados e manter a integridade do programa.

Resultados de Aprendizagem:

• Identificar quando usar panic! irreversível versus Result recuperável com base nos critérios de estado ruim.
• Utilizar rastreamentos (backtraces) para depurar a origem de erros irreversíveis.
• Implementar propagação de erros usando o operador ? e modificar a função main para suportar retornos de erro.

🔹 Aula 10: Genéricos, Traits e Vidas

Visão Geral: Esta aula explora as ferramentas do Rust para abstração eficaz: Genéricos para reduzir duplicação de código entre tipos, Traits para definir comportamentos compartilhados (interfaces) e Vidas para garantir segurança de memória sem gerenciamento manual. Juntos, esses recursos permitem aos desenvolvedores escrever código de alto desempenho e reutilizável, validado pelo compilador para evitar referências pendentes e conflitos de tipo.

Resultados de Aprendizagem:

• Definir e usar parâmetros de tipo genéricos em funções, structs e enums para lidar com múltiplos tipos de dados.
• Implementar comportamentos compartilhados usando Traits e Restrições de Trait para limitar tipos genéricos.
• Aplicar anotações de Vida e regras de elisão para gerenciar a validade de referências e satisfazer o verificador de empréstimos.

🔹 Aula 11: Escrita de Testes Automatizados

Visão Geral: Esta aula explora a implementação e organização de testes automatizados em Rust. Cobremos os requisitos estruturais de uma função de teste, o uso de macros de afirmação para verificar lógica e as distinções técnicas entre testes unitários e integrados. Os aprendizes também entenderão como controlar o comportamento do executor de testes do Rust para gerenciar o fluxo de execução e visibilidade.

Resultados de Aprendizagem:

• Definir a estrutura e metadados necessários para uma função de teste válida em Rust.
• Implementar verificações de igualdade e verificação de estado de panic para garantir confiabilidade do código.
• Configurar o executor de testes para execução paralela ou consecutiva e visibilidade da saída do programa.

🔹 Aula 12: Projeto I/O: Ferramenta de Linha de Comando

Visão Geral: Esta aula orienta desenvolvedores na construção de uma ferramenta de linha de comando funcional (um grep simplificado) em Rust. Foca na transição de um script de arquivo único para um binário modular e pronto para produção, enfatizando análise segura de argumentos, entrada/saída de arquivos e a separação de preocupações entre lógica da biblioteca e interfaces de linha de comando. Os aprendizes implementarão tratamento robusto de erros e desenvolverão funcionalidades usando Desenvolvimento Orientado a Testes (TDD), gerenciando o estado da aplicação por meio de variáveis de ambiente.

Resultados de Aprendizagem:

• Capturar e transformar argumentos de linha de comando em objetos de configuração estruturados.
• Refatorar código para seguir o princípio da "Separação de Preocupações" em projetos binários.
• Implementar a lógica central usando um ciclo de TDD com anotações de vida.

🔹 Aula 13: Recursos Funcionais: Iteradores e Fechamentos

Visão Geral: Esta aula explora os recursos funcionais do Rust, focando especificamente em fechamentos (closures) e iteradores. Fechamentos são funções anônimas que podem capturar seu ambiente, regidos pelos traços Fn, enquanto iteradores fornecem uma maneira preguiçosa e eficiente de processar sequências de itens. Juntos, esses recursos permitem código expressivo que respeita o princípio de "abstração de custo zero" do Rust, muitas vezes igualando ou superando o desempenho de loops tradicionais.

Resultados de Aprendizagem:

• Definir funções anônimas (fechamentos) e explicar como capturam variáveis do seu ambiente por empréstimo ou movimentação.
• Diferenciar entre os três traços Fn (Fn, FnMut e FnOnce) e entender como o compilador infere os tipos de fechamentos.
• Implementar a trait Iterator usando o método next e distinguir entre adaptadores consumidores e adaptadores de iteradores.

🔹 Aula 14: Cargo Avançado e Crates.io

Visão Geral: Esta aula explora os recursos avançados do gerenciador de pacotes do Rust, Cargo, e seu ecossistema, Crates.io. Foca em otimizar compilações por meio de perfis de lançamento, criar documentação de qualidade profissional com testes integrados e dominar a arquitetura de APIs públicas. Além disso, aborda o ciclo de vida de um crate — desde publicação e versionamento até gerenciar projetos multi-pacote via workspaces e estender a funcionalidade nativa do Cargo.

Resultados de Aprendizagem:

• Configurar Perfis de Lançamento para equilibrar velocidade de compilação e desempenho em tempo de execução.
• Gerar e verificar comentários de documentação que servem como guias para usuários e testes automatizados.
• Projetar uma API pública conveniente usando reexportações (pub use) para desconectar a estrutura interna do uso externo.

🔹 Aula 15: Ponteiros Inteligentes

Visão Geral: Esta aula explora os Ponteiros Inteligentes do Rust — estruturas de dados que atuam como ponteiros mas carregam metadados e capacidades adicionais. Focamos no gerenciamento de alocação na heap com Box<T>, habilitando propriedade compartilhada com Rc<T> e contornando regras rigorosas de empréstimo via padrão de Mutabilidade Interna com RefCell<T>. Também abordamos as traits Deref e Drop, que sustentam o comportamento dos ponteiros inteligentes e a limpeza de recursos.

Resultados de Aprendizagem:

• Implementar estruturas de dados recursivas usando Box<T> para fornecer indireção e tamanhos de memória conhecidos.
• Personalizar o comportamento do ponteiro e gerenciamento de recursos usando as traits Deref e Drop.
• Gerenciar múltiplos proprietários e mutabilidade verificada em tempo de execução combinando Rc<T> e RefCell<T>.

🔹 Aula 16: Concorrência Sem Medo

Visão Geral: Esta aula explora a filosofia da "Concorrência Sem Medo" do Rust, demonstrando como a linguagem aproveita seus sistemas de propriedade e tipos para transformar a programação concorrente de um campo minado em tempo de execução em certeza em tempo de compilação. Cobrimos a criação de threads, comunicação segura via passagem de mensagens, gerenciamento de estado compartilhado com mutexes e os traços fundamentais que definem segurança de threads.

Resultados de Aprendizagem:

• Criar e gerenciar threads usando spawn e join, resolvendo conflitos de propriedade com a palavra-chave move.
• Implementar concorrência por passagem de mensagens usando canais mpsc para transferir dados de forma segura entre threads.
• Gerenciar estado compartilhado entre múltiplas threads usando Mutex<T> para exclusão mútua e Arc<T> para contagem de referências thread-safe.

🔹 Aula 17: Programação Orientada a Objetos em Rust

Visão Geral: Esta aula explora como o Rust implementa princípios fundamentais de programação orientada a objetos (POO), focando especificamente em encapsulamento e polimorfismo. Detalha os mecanismos de objetos de trait para lidar com coleções heterogêneas e os trade-offs entre despacho estático e dinâmico. Por fim, contrasta a implementação do padrão State clássico com uma abordagem mais idiomática do Rust de codificar estados e comportamentos diretamente no sistema de tipos.

Resultados de Aprendizagem:

• Implementar encapsulamento em Rust usando módulos e modificadores de visibilidade para esconder o estado interno.
• Utilizar objetos de trait para alcançar polimorfismo e entender as implicações de desempenho entre despacho estático e dinâmico.
• Aplicar o Padrão State para gerenciar comportamentos complexos de objetos e transições entre estados.

🔹 Aula 18: Padrões Avançados e Correspondência

Visão Geral: Esta aula explora a profundidade do sistema de correspondência de padrões do Rust, indo além de braços simples de match para extração sofisticada de dados e fluxo de controle. Os alunos dominarão a distinção entre padrões irrefutáveis e refutáveis, aprenderão a decompor estruturas aninhadas complexas e utilizarão sintaxe avançada como guardas de match e vinculações para escrever código mais expressivo e seguro.

Resultados de Aprendizagem:

• Distinguir entre padrões irrefutáveis e refutáveis e aplicá-los nos constructos Rust corretos (ex: let vs. if let).
• Decompor structs, enums e tuplas para extrair dados específicos em variáveis locais.
• Empregar sintaxe de padrão avançada, incluindo intervalos, múltiplos padrões, ignorar valores e vinculações @ para correspondência condicional complexa.

🔹 Aula 19: Recursos Avançados e Rust Inseguro

Visão Geral: Esta aula explora os "superpoderes" do Rust que permitem aos desenvolvedores contornar certas restrições do compilador e criar abstrações altamente flexíveis. Cobrimos o uso do Rust Inseguro para manipulação de memória de baixo nível, técnicas avançadas de trait para relações complexas de tipos e as poderosas capacidades de metaprogramação de Macros Declarativas e Procedurais.

Resultados de Aprendizagem:

• Diferenciar entre Rust seguro e os "superpoderes" inseguros necessários para manipulação de ponteiros brutos e chamadas de funções inseguras.
• Implementar padrões avançados de trait, incluindo Tipos Associados, Sobrecarga de Operadores, Supertraits e o padrão Newtype.
• Resolver ambiguidades em chamadas de método usando Sintaxe Plenamente Qualificada e gerenciar tipos complexos como Tipos de Tamanho Dinâmico (DSTs) e Aliases de Tipo.

🔹 Aula 20: Projeto Final: Servidor Web Multithread

Visão Geral: Esta aula orienta o desenvolvimento de um servidor web de alto desempenho usando primitivas de rede e concorrência do Rust. Cobrimos a transição de um listener TCP básico para um sistema multithread sofisticado utilizando um pool de threads personalizado. Os alunos aprenderão a gerenciar streams de baixo nível, implementar passagem de mensagens baseada em workers para distribuição de tarefas e garantir a estabilidade do sistema por meio de um mecanismo de desligamento elegante.

Resultados de Aprendizagem:

• Estabelecer e Gerenciar Conexões TCP: Vincular um servidor a uma porta local e lidar com fluxos de bytes entrantes.
• Analisar e Responder a HTTP: Ler dados de requisição brutos e construir respostas HTTP válidas com linhas de status e corpos HTML.
• Arquitetar um Pool de Threads Personalizado: Usar canais mpsc e primitivas de sincronização (Arc, Mutex) para distribuir tarefas entre um número finito de threads.

🔹 Aula 21: Apêndices do Rust: Ferramentas e Referências

Visão Geral: Esta aula fornece uma referência técnica abrangente para a linguagem Rust, focando em sua sintaxe densa, ferramentas de desenvolvimento automatizadas e processo evolutivo de lançamentos. Os alunos aprenderão a navegar pela sintaxe cheia de símbolos do Rust, implementar comportamentos padrão via traits deriváveis e aproveitar a ferramentaria do ecossistema para manter alta qualidade de código e seguir a filosofia da linguagem de "estabilidade sem estagnação".

Resultados de Aprendizagem:

• Identificar e Interpretar Sintaxe: Decodificar operadores do Rust, símbolos relacionados a caminhos e restrições genéricas usando tabelas de referência padronizadas.
• Implementar Comportamentos Padrão: Automatizar a implementação das traits Debug, Clone, Eq, Ord e Hash usando o atributo derive.
• Otimizar Fluxo de Desenvolvimento: Utilizar rustfmt, rustfix e Clippy para formatar, consertar e analisar código de acordo com padrões da comunidade.