Menos Teoria, Mais Rust

Rust é famosa por sua velocidade, segurança e prevenção de bugs. Mas por onde começar? O livro oficial é ótimo, mas às vezes queremos apenas ir direto ao ponto.

É por isso que este livro existe.

Ele foi criado para ser sua ponte entre a teoria complexa e o código funcional, facilitando sua introdução à linguagem qualquer que seja seu nível. A abordagem é direta: menos teoria, mais prática.

O que você encontrará aqui:

Inúmeros exemplos;
Perguntas rápidas de fixação (3 a 5 minutos);
Projetos para por a mão na massa;
Links com material complementar.

Vamos começar a programar?

"A beleza que vive no ato de compartilhar algo com os outros." Monja Coen

Introdução ao Rust

Rust foi criado por Graydon Hoare na Mozilla Research em 2010. A primeira versão estável, 1.0, foi lançada em 2015, marcando o início de sua popularidade e adoção mais ampla na indústria.

Rust é uma linguagem de código aberto (open-source) e compilada, o que significa que é traduzida diretamente para código de máquina. Isso a torna extremamente rápida, sem a necessidade de um interpretador como Python ou JavaScript. Ela se posiciona como uma alternativa a linguagens como C e C++, que são conhecidas por sua performance, mas também são mais suscetíveis a erros de memória, como null pointers (ponteiros nulos) ou data races (condições de corrida de dados).

A grande inovação do Rust é o Ownership Model (Modelo de Posse), um sistema que garante a segurança de memória em tempo de compilação. Isso significa que o compilador do Rust verifica se o seu código está livre de erros de memória antes mesmo de ser executado. O compilador se torna um "guardião" da memória, e se ele não aprovar o seu código, ele simplesmente não compila. Essa abordagem elimina toda uma classe de bugs que são comuns em outras linguagens.

Começando

Olá, seja bem-vindo!

Este projeto foi criado não apenas para ajudá-lo a aprender a linguagem, mas também como um material de consulta. A longo prazo, este conteúdo será expandido continuamente, até se tornar algo mais completo e abordar de forma simples diversos tópicos complexos que ainda carecem de documentação, principalmente em português.

Espero de coração que você consiga aprender junto comigo e que este material lhe seja tão útil quanto tem sido para mim. Aproveite bem o que foi construído até aqui e continue acompanhando, pois novos conteúdos serão adicionados regularmente.

Bons estudos!

Rust Playground

O Rust Playground é a maneira mais rápida de começar a experimentar com Rust. É um ambiente online onde você pode:

Escrever e rodar código Rust diretamente no seu navegador;
Testar pequenos exemplos e conceitos;
Compartilhar código com outros desenvolvedores;
Experimentar sem a necessidade de instalar nada.

Acesse: https://play.rust-lang.org

Instalando

Para instalar no macOS, Linux ou em outros sistemas operacionais tipo Unix, execute o seguinte em seu terminal e siga as instruções na tela:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Certifique-se de visitar o site oficial do Rust para melhor entender o processo de instalação e outras ferramentas:

https://www.rust-lang.org/tools/install

Se você estiver no Windows, procure por "Outros Métodos de Instalação":

https://forge.rust-lang.org/infra/other-installation-methods.html

Versão

Se você deseja ver a versão do Rust:

rustc --version

Se você deseja ver a versão do Cargo:

cargo --version

Desinstalando

Se em algum momento você quiser desinstalar o Rust:

rustup self uninstall

Editores e IDEs

Zed

Um editor de código moderno e extremamente rápido, desenvolvido pelos criadores do Atom, focado em desempenho e colaboração em tempo real.

https://zed.dev/

RustRover: IDE Rust da JetBrains

É a IDE dedicada da JetBrains para Rust, oferecendo recursos avançados de desenvolvimento, como depuração inteligente, refactoring (refatoração) e análise de código.

https://www.jetbrains.com/rust/

VS Code: com a extensão rust-analyzer

É uma combinação popular e leve para o desenvolvimento em Rust, oferecendo autocomplete (autocompletar), verificação de erros em tempo real e integração com as ferramentas do ecossistema Rust.

https://code.visualstudio.com/

https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer

Helix

Editor de texto modal moderno inspirado em Vim/Kakoune, com suporte nativo a LSP (Language Server Protocol) e destaque de sintaxe, oferecendo uma experiência de edição rápida e eficiente sem a necessidade de configuração inicial.

https://helix-editor.com/

Config: languages.toml

[[language]]
name = "rust"
auto-format = true

roots = [
  "Cargo.toml",
  "Cargo.lock"
]

[language.auto-pairs]
'(' = ')'
'{' = '}'
'[' = ']'
'"' = '"'
'`' = '`'

[language-server.rust-analyzer]
command = "rust-analyzer"

[language-server.rust-analyzer.config]
inlayHints.bindingModeHints.enable = false
inlayHints.closingBraceHints.minLines = 10
inlayHints.closureReturnTypeHints.enable = "with_block"
inlayHints.discriminantHints.enable = "fieldless"
inlayHints.lifetimeElisionHints.enable = "skip_trivial"
inlayHints.typeHints.hideClosureInitialization = false

Neovim: com plugins específicos para Rust

Evolução moderna do Vim com suporte nativo a LSP, interface assíncrona e extensibilidade via Lua, sendo altamente customizável e ideal para desenvolvedores que buscam um editor modal poderoso e eficiente.

https://neovim.io/

https://rsdlt.github.io/posts/rust-nvim-ide-guide-walkthrough-development-debug/

Conceitos Comuns de Programação

Este capítulo foi desenvolvido para apresentar os conceitos fundamentais da linguagem de programação Rust. No entanto, os tópicos abordados aqui também estão presentes em outras linguagens de programação. Se esta é a primeira vez que você se depara com esses conceitos, espero que você possa entender cada ponto claramente, pois isso forma a base essencial para o que virá nos próximos capítulos.

No final, você encontrará alguns exercícios práticos, permitindo que você verifique se perdeu algum conceito durante seus estudos. Mas não se preocupe, as perguntas são muito simples e incluem as respostas.

Comentários

Comentários são usados para documentar seu código, tornando-o mais compreensível para você e outros desenvolvedores. Eles são ignorados pelo compilador, o que significa que não afetam como seu programa é executado, apenas a sua legibilidade.

//

#![allow(unused)]
fn main() {
// Este é um comentário de linha única.
}

/* */

#![allow(unused)]
fn main() {
/*
  ...
  Este é um comentário de múltiplas linhas.
  ...
*/
}

///

#![allow(unused)]
fn main() {
/// Comentários de documentação (doc comments):
///  - Geram documentação automaticamente: cargo doc;
///  - São compatíveis com markdown;
///  - Documentam o item seguinte: função, módulo, struct, etc.
}

//!

#![allow(unused)]
fn main() {
//! Comentário de documentação interno (inner doc comment):
//!  - Documenta módulos/crates: lib.rs;
//!  - Colocado no início dos arquivos.
}

/* // /**/ */

#![allow(unused)]
fn main() {
/* Comentários aninhados (nested comments):
    // Rust permite comentários dentro do bloco de comentário.
    /* ... */
*/
}

Print

A macro print! e suas variações são usadas para depuração, informar o usuário e gerar saída formatada.

print!

#![allow(unused)]
fn main() {
// imprime o texto sem quebra de linha
print!("Olá,");
print!("mundo!");
print!("...");
}

println!

#![allow(unused)]
fn main() {
// imprime o texto com quebra de linha
println!("Olá,");
println!("mundo!");
println!("...");
}

eprint!

#![allow(unused)]
fn main() {
// imprime o texto de erro sem quebra de linha
eprint!("ERRO:");
eprint!("Falha ao carregar arquivo!");
}

eprintln!

#![allow(unused)]
fn main() {
// imprime o texto de erro com quebra de linha
eprintln!("ERRO:");
eprintln!("Falha ao carregar arquivo!");
}

Nota: Quando estiver desenvolvendo um programa, pode redirecionar a saída normal para um arquivo usando (>) e as mensagens de erro para o terminal usando (eprint).

Caracteres de Escape

São aqueles que começam com \ e são usados para representar caracteres especiais que não podemos (ou não devemos) digitar literalmente no código, como quebras de linha, tabulações, aspas dentro de strings, etc.

\n

#![allow(unused)]
fn main() {
// quebra de linha
println!("Qual é o seu nome?\nMeu nome é Alice!");
}

\'

#![allow(unused)]
fn main() {
// aspas simples
println!("Qual é o seu nome?\'Meu nome é Alice!\'");
}

\"

#![allow(unused)]
fn main() {
// aspas duplas
println!("Qual é o seu nome?\"Meu nome é Alice!\"");
}

\\

#![allow(unused)]
fn main() {
// barra invertida
println!("Qual é o seu nome?\\Meu nome é Alice!\\");
}

\t

#![allow(unused)]
fn main() {
// tabulação horizontal (tab)
println!("Qual é o seu nome?\tMeu nome é\tAlice!");
}

r

#![allow(unused)]
fn main() {
// permite todas as barra invertidas
println!(r"C:\Users\Alice\Documents");
}

r#...#

#![allow(unused)]
fn main() {
// raw strings (string literal/sem processamento de escape)
println!(r#"
  Qual é o seu nome?
  Meu nome é "Alice!"
"#);
}

\x

#![allow(unused)]
fn main() {
// caractere ASCII de 7 bits - 0x00 e 0x7F
println!("\x53\x6E\x6F\x6F\x70\x79\x21");
}

\u{...}

#![allow(unused)]
fn main() {
// unicode (permite usar emojis ou caracteres especiais)
println!("(\u{25D5}\u{2323}\u{25D5})");
}

\r

#![allow(unused)]
fn main() {
// move o cursor de volta para o início da linha sem avançar para a próxima
print!("Carregando ...\r");
}

Comumente usado para animações de terminal: \r

Variáveis

Variáveis são espaços nomeados na memória que podem armazenar um valor.

#![allow(unused)]
fn main() {
let nome = "Maria";
println!("Qual é o seu nome: {}", nome);
}

#![allow(unused)]
fn main() {
let idade = 29;
println!("Qual sua idade? {}", idade);
}

Saiba mais sobre variáveis.

Mutabilidade

Uma vez que o valor de uma variável é definido, você não pode alterá-lo posteriormente. No entanto, usar mut após let torna a variável criada mutável.

let mut

#![allow(unused)]
fn main() {
let mut nome = "Miguel";
println!("Qual é o seu nome: {}", nome);

nome = "Sophia";
println!("Qual é o seu nome: {}", nome);
}

#![allow(unused)]
fn main() {
let mut idade = 87;
println!("Qual sua idade? {}", idade);

idade = 49;
println!("Qual sua idade? {}", idade);
}

Constante

A constante é uma identificador com valor fixo e imutável, tipo explícito e pode ser declarada em qualquer escopo.

const PI: f32 = 3.14159;

fn main () {
    println!("{:.2}", PI);
}

const ERROR_404: &str = "Erro 404";

fn main () {
    println!("{}", ERROR_404);
}

O tópico de tipos de dados será abordado no próximo capítulo.

Formatação

A macro format! em Rust é usada para melhorar a formatação da saída de dados, utilizando {} como placeholders (espaços reservados) que serão preenchidos com a informação.

{}

#![allow(unused)]
fn main() {
let nome = "Rafael";
let idade = 12;
println!("Oi, eu sou {}, tenho {} anos", nome, idade);
}

#![allow(unused)]
fn main() {
let nome = "Manuela";
let idade = 37;
println!("Oi, eu sou {nome}, tenho {idade} anos");
}

format!

Sempre retorna uma String com o conteúdo formatado.

#![allow(unused)]
fn main() {
let nome = "Arthur";
let idade = 69;

let texto = format!("Oi, eu sou {}, tenho {} anos", nome, idade);
println!("{}", texto);
}

#![allow(unused)]
fn main() {
let nome = "Charlie Brown";
let idade = 8;

let texto = format!("Eu sou o {nome}, tenho {idade} anos");
println!("{}", texto);
}

Para mais informações: std::fmt

Formatação para Debugging

Em Rust, {:?} e {:#?} são especificadores de formato que utilizam o trait Debug para exibir a representação interna de valores. São especialmente úteis para depuração e inspeção durante o desenvolvimento.

{:?}

#![allow(unused)]
fn main() {
// saída compacta
let pessoa: (&str, u8, f32) = ("Laura", 19, 1.77);
println!("{:?}", pessoa);
}

{:#?}

#![allow(unused)]
fn main() {
// saída mais legível
let pessoa: (&str, u8, f32) = ("Pedro", 90, 1.90);
println!("{:#?}", pessoa);
}

{var:?} ou {var:#?}

#![allow(unused)]
fn main() {
let pessoa: (&str, u8, f32) = ("Violet", 28, 1.58);
println!("{pessoa:?}");
}

#![allow(unused)]
fn main() {
let pessoa: (&str, u8, f32) = ("Violet", 28, 1.58);
println!("{pessoa:#?}");
}

Shadowing (Sombreamento)

Você pode declarar uma nova variável com o mesmo nome de uma variável existente, mas a variável anterior é ocultada (shadowed) pela nova.

#![allow(unused)]
fn main() {
let comida = "Pizza";
println!("{}", comida);

let comida = "Biscoitos";
println!("{}", comida);

let comida = "Sorvete";
println!("{}", comida);
}

#![allow(unused)]
fn main() {
let animal = "Cachorro";
println!("{}", animal);

let animal = "Pássaro";
println!("{}", animal);

let animal = "Gato";
println!("{}", animal);
}

#![allow(unused)]
fn main() {
let numero: i8 = 80;
println!("{}", numero);

let numero: f32 = 2.;
println!("{}", numero);
}

Escopo

Envolver um código entre chaves {} cria um novo escopo (bloco de código) que limita a visibilidade das variáveis definidas dentro dele, logo não pode ser acessada fora daquele bloco.

#![allow(unused)]
fn main() {
let nome = "Aurora";
println!("{}", nome);

{
  let nome = "Ravi";
  println!("{}", nome);
}

println!("{}", nome);
}

#![allow(unused)]
fn main() {
let numero = 40;
println!("{}", numero);

{
  let numero = 0;
  println!("{}", numero);
}

println!("{}", numero);
}

Questões - Conceitos Comuns de Programação

01 - Como você escreveria um comentário de linha única em Rust?

Keyboard shortcuts

Rust v1.9 - Book