Programação em Rust – 2ª Edição

Sumário

• Prefácio
• Capítulo 1 ■ Os programadores de sistemas podem ter coisas legais
• O Rust carrega o peso para você
• A programação paralela foi domada
• E, mesmo assim, o Rust ainda é rápido
• O Rust facilita a colaboração
• Capítulo 2 ■ Um passeio pelo Rust
• rustup e Cargo
• Funções no Rust
• Escrevendo e executando testes unitários
• Manipulando argumentos de linha de comando
• Servindo páginas para a web
• Concorrência
  • O que é realmente o conjunto de Mandelbrot
  • Analisando argumentos de linha de comando em pares
  • Mapeando pixels para números complexos
  • Plotando o conjunto
  • Gravando arquivos de imagem
  • Um programa de Mandelbrot concorrente
  • Executando o plotter de Mandelbrot
  • A segurança é invisível
• Sistemas de arquivos e ferramentas de linha de comando
  • Interface de linha de comando
  • Lendo e gravando arquivos
  • Localizar e substituir
• Capítulo 3 ■ Tipos fundamentais
• Tipos numéricos de tamanho fixo
  • Tipos inteiros
  • Aritmética: verificação, enquadramento, saturação e estouro
  • Tipos de ponto flutuante
• Tipo bool
• Caracteres
• Tuplas
• Tipos de ponteiro
  • Referências
  • Boxes
  • Ponteiros brutos
• Arrays, vetores e fatias
  • Arrays
  • Vetores
  • Fatias
• Tipos de string
  • Literais de string
  • Strings de bytes
  • Strings na memória
  • String
  • Usando strings
  • Outros tipos semelhantes a strings
• Aliases de tipo
• Além do básico
• Capítulo 4 ■ Posse e movimentos
• Posse (ownership)
• Movimentos
  • Mais operações que movem
  • Movimentos e fluxo de controle
  • Movimentos e conteúdo indexado
• Tipos de cópia: A exceção aos movimentos
• Rc e Arc: Posse compartilhada
• Capítulo 5 ■ Referências
• Referências a valores
• Trabalhando com referências
  • Referências Rust versus referências C++
  • Atribuição de referências
  • Referências a referências
  • Comparando referências
  • Referências nunca são nulas
  • Emprestando referências a expressões arbitrárias
  • Referências a fatias e objetos trait
• Segurança de referência
  • Emprestando uma variável local
  • Recebendo referências como argumentos de função
  • Passando referências para funções
  • Retornando referências
  • Structs contendo referências
  • Parâmetros de tempo de vida distintos
  • Omitindo parâmetros de tempo de vida
• Compartilhamento versus mutação
• Pegando em armas contra um mar de objetos
• Capítulo 6 ■ Expressões
• Uma linguagem de expressão
• Precedência e associatividade
• Blocos e pontos e vírgulas
• Declarações
• if e match
• if let
• Loops
• Fluxo de controle em loops
• Expressões return
• Por que o Rust tem loops
• Chamadas de função e método
• Campos e elementos
• Operadores de referência
• Operadores aritméticos, de bit a bit, de comparação e lógicos
• Atribuição
• Coerções de tipo
• Closures
• A seguir
• Capítulo 7 ■ Tratamento de erros
• Pânico
  • Desempilhamento
  • Abortando
• Result
  • Capturando erros
  • Aliases do tipo Result
  • Imprimindo erros
  • Propagando erros
  • Trabalhando com vários tipos de erro
  • Lidando com erros que “não podem acontecer”
  • Ignorando erros
  • Tratando erros em main()
  • Declarando um tipo de erro personalizado
  • Por que Results?
• Capítulo 8 ■ Crates e módulos
• Crates
  • Edições
  • Perfis de compilação
• Módulos
  • Módulos aninhados
  • Módulos em arquivos separados
  • Caminhos e importações
  • Prelúdio padrão
  • Criando declarações use públicas
  • Criando campos struct públicos
  • Variáveis estáticas e constantes
• Transformando um programa em uma biblioteca
• Diretório src/bin
• Atributos
• Testes e documentação
  • Testes de integração
  • Documentação
  • Doc-Tests
• Especificando dependências
  • Versões
  • Cargo lock
• Publicando crates em crates io
• Espaços de trabalho
• Mais coisas legais
• Capítulo 9 ■ Structs
• Structs de campo nomeado
• Structs do tipo tupla
• Structs do tipo unidade
• Disposição de um struct na memória
• Definindo métodos com impl
  • Passando Self como um Box, Rc ou Arc
  • Funções associadas a tipos
• Consts associadas
• Structs genéricos
• Structs genéricos com parâmetros de tempo de vida
• Structs genéricos com parâmetros constantes
• Derivando traits comuns para tipos de struct
• Mutabilidade interior
• Capítulo 10 ■ Enums e padrões
• Enums
  • Enums com dados
  • Enums na memória
  • Estruturas de dados ricas usando enums
  • Enums genéricos
• Padrões
  • Literais, variáveis e curingas em padrões
  • Padrões com tupla e struct
  • Padrões de array e fatia
  • Padrões de referência
  • Guardas de correspondência
  • Combinando múltiplas possibilidades
  • Vinculando com padrões @
  • Onde os padrões são permitidos
  • Preenchendo uma árvore binária
• Visão geral
• Capítulo 11 ■ Traits e genéricos
• Utilizando traits
  • Objetos trait
  • Funções genéricas e parâmetros de tipo
  • Qual utilizar
• Definindo e implementando traits
  • Métodos padrão
  • Traits e tipos de outras pessoas
  • Self em traits
  • Subtraits
  • Funções associadas a tipos
• Chamadas de método totalmente qualificadas
• Traits que definem relacionamentos entre tipos
  • Tipos associados (ou como funcionam os iteradores)
  • Traits genéricos (ou como funciona a sobrecarga do operador)
  • impl Trait
  • Consts associadas
• Engenharia reversa de limites
• Traits como uma fundação
• Capítulo 12 ■ Sobrecarga de operador
• Operadores aritméticos e de bit a bit
  • Operadores unários
  • Operadores binários
  • Operadores de atribuição composta
• Comparações de equivalência
• Comparações ordenadas
• Index e IndexMut
• Outros operadores
• Capítulo 13 ■ Traits utilitários
• Drop
• Sized
• Clone
• Copy
• Deref e DerefMut
• Default
• AsRef e AsMut
• Borrow e BorrowMut
• From e Into
• TryFrom e TryInto
• ToOwned
• Borrow e ToOwned em funcionamento: Cow (“clone on write”)
• Capítulo 14 ■ Closures
• Capturando variáveis
  • Closures que pedem emprestado
  • Closures que roubam
• Função e tipos de closure
• Desempenho de closure
• Closures e segurança
  • Closures que matam
  • FnOnce
  • FnMut
  • Copy e Clone para closures
• Callbacks
• Usando closures de forma eficaz
• Capítulo 15 ■ Iteradores
• Traits Iterator e IntoIterator
• Criando iteradores
  • Métodos iter e iter_mut
  • Implementações de IntoIterator
  • from_fn e sucessores
  • Métodos drain
  • Outras fontes do iterador
• Adaptadores iteradores
  • map e filter
  • filter_map e flat_map
  • flatten
  • take e take_while
  • skip e skip_while
  • peekable
  • fuse
  • Iteradores reversíveis e rev
  • inspect
  • chain
  • enumerate
  • zip
  • by_ref
  • cloned, copied
  • cycle
• Consumindo iteradores
  • Acumulação simples: contagem, soma, produto
  • max, min
  • max_by, min_by
  • max_by_key, min_by_key
  • Comparando sequências de itens
  • any e all
  • position, rposition e ExactSizeIterator
  • fold e rfold
  • try_fold e try_rfold
  • nth, nth_back
  • last
  • find, rfind e find_map
  • Construindo coleções: collect e FromIterator
  • Trait Extend
  • partition
  • for_each e try_for_each
• Implementando seus próprios iteradores
• Capítulo 16 ■ Coleções
• Visão geral
• Vec<T>
  • Acessando elementos
  • Iteração
  • Crescendo e encolhendo vetores
  • Unindo
  • Dividindo
  • Permutando
  • Preenchimento
  • Ordenando e pesquisando
  • Comparando fatias
  • Elementos aleatórios
  • O Rust descarta erros de invalidação
• VecDeque<T>
• BinaryHeap<T>
• HashMap<K, V> e BTreeMap<K, V>
  • Entradas
  • Iteração em mapas
• HashSet<T> e BTreeSet<T>
  • Iteração em conjuntos
  • Quando valores iguais são diferentes
  • Operações sobre o conjunto inteiro
• Hash
• Usando um algoritmo de hash personalizado
• Além das coleções padrão
• Capítulo 17 ■ Strings e texto
• Princípios básicos de Unicode
  • ASCII, Latin-1 e Unicode
  • UTF-8
  • Direcionalidade do texto
• Caracteres (char)
  • Classificando caracteres
  • Manipulando dígitos
  • Conversão de maiúsculas e minúsculas para caracteres
  • Conversões de e para inteiros
• String e str
  • Criando valores string
  • Inspeção simples
  • Acrescentando e inserindo texto
  • Removendo e substituindo texto
  • Convenções para pesquisa e iteração
  • Padrões para pesquisar texto
  • Pesquisando e substituindo
  • Iterando por texto
  • Recortando uma string
  • Conversão de maiúsculas e minúsculas para strings
  • Convertendo outros tipos a partir de strings
  • Convertendo outros tipos em strings
  • Emprestando como outros tipos semelhantes a texto
  • Acessando texto como UTF-8
  • Produzindo texto a partir de dados UTF-8
  • Adiando a alocação
  • Strings como coleções genéricas
• Formatando valores
  • Formatando valores de texto
  • Formatando números
  • Formatando outros tipos
  • Valores de formatação para depuração
  • Ponteiros de formatação para depuração
  • Referindo-se a argumentos por índice ou nome
  • Larguras dinâmicas e precisões
  • Formatando os próprios tipos
  • Usando a linguagem de formatação em seu próprio código
• Expressões regulares
  • Uso básico de Regex
  • Construindo valores regex preguiçosamente (lazily)
• Normalização
  • Formas de normalização
  • Crate de normalização Unicode
• Capítulo 18 ■ Entrada e saída
• Leitores e escritores
  • Leitores
  • Leitores bufferizados
  • Lendo linhas
  • Coletando linhas
  • Escritores
  • Arquivos
  • Posicionando
  • Outros tipos de leitores e escritores
  • Dados binários, compactação e serialização
• Arquivos e diretórios
  • OsStr e Path
  • Métodos Path e PathBuf
  • Funções de acesso ao sistema de arquivos
  • Lendo diretórios
  • Recursos específicos da plataforma
• Redes
• Capítulo 19 ■ Concorrência
• Paralelismo fork-join
  • spawn e join
  • Tratamento de erros entre threads
  • Compartilhamento de dados imutáveis entre threads
  • Rayon
  • Revisitando o conjunto de Mandelbrot
• Canais
  • Enviando valores
  • Recebendo valores
  • Executando o pipeline
  • Recursos e desempenho do canal
  • Segurança de thread: Send e Sync
  • Utilizando pipes em quase qualquer iterador para um canal
  • Além de pipelines
• Estado mutável compartilhado
  • O que é um mutex?
  • Mutex<T>
  • mut e Mutex
  • Por que mutexes nem sempre são uma boa ideia
  • Deadlock
  • Mutexes envenenados
  • Canais multiconsumidores usando mutexes
  • Bloqueios de leitura/escrita (RwLock<T>)
  • Variáveis de condição (Condvar)
  • Atômicos
  • Variáveis globais
• Como é hackear código concorrente em Rust
• Capítulo 20 ■ Programação assíncrona
• De síncrono a assíncrono
  • Futuros
  • Funções assíncronas e expressões await
  • Chamando funções assíncronas a partir do código síncrono: block_on
  • Gerando tarefas assíncronas
  • Blocos assíncronos
  • Construindo funções assíncronas a partir de blocos assíncronos
  • Gerando tarefas assíncronas em um pool de threads
  • Mas seu futuro implementa Send?
  • Cálculos de longa duração: yield_now e spawn_blocking
  • Comparando projetos assíncronos
  • Um cliente HTTP assíncrono real
• Um cliente e servidor assíncronos
  • Tipos de erro e resultado
  • O protocolo
  • Recebendo a entrada do usuário: Fluxos assíncronos
  • Enviando pacotes
  • Recebendo pacotes: mais fluxos assíncronos
  • A função main do cliente
  • A função main do servidor
  • Lidando com conexões de bate-papo: Mutexes assíncronos
  • A tabela de grupo: Mutexes síncronos
  • Grupos de bate-papo: canais de transmissão do tokio
  • Invocando wakers: spawn_blocking
  • Implementando block_on
• Fixando
  • As duas fases da vida de um futuro
  • Ponteiros fixados
  • Trait Unpin
• Quando o código assíncrono é útil?
• Capítulo 21 ■ Macros
• Noções básicas de macro
  • Noções básicas de expansão de macro
  • Consequências não intencionais
  • Repetição
• Macros internas
• Depurando macros
• Construindo a macro json!
  • Tipos de fragmento
  • Recursão em macros
  • Usando traits com macros
  • Escopo e higiene
  • Importando e exportando macros
• Evitando erros de sintaxe durante a correspondência
• Para além de macro_rules!
• Capítulo 22 ■ Código inseguro
• Inseguro de quê?
• Blocos inseguros
• Exemplo: Um tipo de string ASCII eficiente
• Funções inseguras
• Bloco inseguro ou função insegura?
• Comportamento indefinido
• Traits inseguros
• Ponteiros brutos
  • Desreferenciando ponteiros brutos com segurança
  • Exemplo: RefWithFlag
  • Ponteiros que podem ser nulos
  • Tamanhos e alinhamentos de tipos
  • Aritmética de ponteiro
  • Movendo dados para dentro e para fora da memória
  • Exemplo: GapBufferGenericName
  • Segurança contra pânico em código inseguro
• Reinterpretando a memória com uniões
• Correspondendo uniões
• Pegando emprestadas uniões
• Capítulo 23 ■ Funções externas
• Encontrando representações de dados comuns
• Declarando funções e variáveis externas
• Usando funções de bibliotecas
• Uma interface bruta para libgit2
• Uma interface segura para libgit2
• Conclusão
• Sobre os autores
• Colofão
• Índice remissivo