Começando com Rust

Vamos colocar o Rust para rodar no seu computador e criar seu primeiro programa. Se preferir não instalar nada por enquanto, você pode acompanhar no Rust Playground e voltar a esta página depois.

Passo 1: instale o Rust com o rustup

A forma oficial de instalar o Rust é uma ferramenta chamada rustup. Ela instala o compilador do Rust e a ferramenta de build cargo, e mantém tudo atualizado.

Acesse rustup.rs e siga as instruções para o seu sistema:

• Windows: baixe e execute o rustup-init.exe e aceite as opções padrão.

• macOS / Linux: cole isto no seu terminal:

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

Nota

No Windows, o Rust precisa das ferramentas de build do C++. Se o instalador pedir, deixe que ele instale as “Visual Studio C++ Build Tools”. O Rust usa essas ferramentas para fazer a linkagem dos seus programas.

Passo 2: confira se funcionou

Feche e abra o terminal de novo e rode:

rustc --version
cargo --version

Você deve ver números de versão como rustc 1.xx.0. Se aparecerem, está tudo pronto.

• rustc é o compilador do Rust (ele transforma seu código em um programa).
• cargo é a ferramenta completa do Rust para compilar, rodar, testar e gerenciar projetos. Você vai usar o cargo para quase tudo.

Passo 3: crie seu primeiro projeto

Em vez de criar os arquivos na mão, deixe o cargo montar um projeto para você:

cargo new hello_rust
cd hello_rust

Isso cria uma pasta chamada hello_rust com tudo o que um projeto Rust precisa:

hello_rust/
├── Cargo.toml      # configurações e dependências do projeto
└── src/
    └── main.rs     # seu código fica aqui

• Cargo.toml descreve seu projeto (o nome, a versão e as bibliotecas que ele usa).
• src/main.rs é o arquivo inicial. O cargo até já coloca um Hello World nele para você.

Passo 4: rode o programa

De dentro da pasta do projeto, rode:

cargo run

Você vai ver o cargo compilar o projeto e depois imprimir:

Hello, world!

Pronto: você acabou de compilar e rodar um programa em Rust.

Entendendo o código

Abra o src/main.rs e você vai encontrar:

fn main() {
    println!("Hello, world!");
}

• fn main() { ... } define a função principal. Todo programa em Rust começa a rodar por aqui.
• println!("...") imprime uma linha de texto na tela.

Experimente mudar a mensagem e rodar cargo run de novo:

fn main() {
    println!("Olá do meu primeiro programa em Rust!");
}

Saída:

Olá do meu primeiro programa em Rust!

▶ Experimente você mesmo

cargo run ou cargo build

Dois comandos que você vai usar o tempo todo:

Comando	O que faz
cargo run	Compila e roda o programa (o ideal durante o desenvolvimento)
cargo build	Só compila; o programa vai para target/debug/
cargo build --release	Compila uma versão otimizada e mais rápida para distribuir

Quando algo dá errado: lendo os erros do compilador

Você vai ver erros do compilador, todo dia, mesmo depois de anos de Rust. Isso não é sinal de que você é ruim nisso. É o compilador fazendo o trabalho dele. Vamos provocar um erro de propósito para que ele assuste menos da primeira vez.

Tire o ! do println! no src/main.rs:

fn main() {
    println("Hello, world!");
}

Rode cargo run e você vai ver:

error[E0423]: expected function, found macro `println`
 --> src/main.rs:2:5
  |
2 |     println("Hello, world!");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro
  |
2 |     println!("Hello, world!");
  |            +

A mensagem vem em inglês, como todas as do compilador. Leia de cima para baixo:

1. A primeira linha diz o que está errado: o Rust esperava uma função (expected function), mas println é uma macro (você vai entender o que isso significa na próxima página).
2. --> src/main.rs:2:5 diz onde: arquivo src/main.rs, linha 2, coluna 5.
3. As marcas ^^^^^^^ apontam para o trecho exato do código.
4. A parte help: muitas vezes mostra a correção. Aqui ela até marca o ! que falta com um +.

Coloque o ! de volta e tudo volta a funcionar:

fn main() {
    println!("Hello, world!");
}

Saída:

Hello, world!

▶ Experimente você mesmo

Uma verificação mais rápida

O cargo check procura erros sem gerar um programa para rodar. Em projetos maiores ele é bem mais rápido que o cargo build, então muita gente roda esse comando o tempo todo enquanto escreve código. O código E0423 também serve para pesquisar: rustc --explain E0423 mostra uma explicação mais longa, com exemplos (em inglês).

Passo 5: configure seu editor (recomendado)

Para ter a melhor experiência, instale a extensão rust-analyzer no seu editor. Ela oferece autocompletar, mensagens de erro no próprio código e dicas de tipo enquanto você digita.

• VS Code: instale a extensão rust-analyzer
• A maioria dos outros editores (JetBrains, Neovim etc.) também tem suporte ao rust-analyzer.

Dica

Deixe as mensagens de erro do compilador sempre à vista enquanto aprende. Os erros do Rust são famosos por ajudar muito: normalmente explicam o que deu errado e como corrigir.

Prática

1. Três linhas

Faça seu programa imprimir três linhas: seu nome, sua comida favorita e Acabei de rodar Rust!. Dica: um println! imprime uma linha, então use três.

Ver solução

fn main() {
    println!("Meu nome é Ana");
    println!("Eu gosto de pizza");
    println!("Acabei de rodar Rust!");
}

Saída:

Meu nome é Ana
Eu gosto de pizza
Acabei de rodar Rust!

▶ Experimente você mesmo

2. Um pequeno banner

Imprima um pequeno banner como o de baixo, com uma linha de sinais = acima e abaixo de um título. Depois quebre o programa de propósito apagando um !, rode cargo run, leia o erro e corrija. Dica: as linhas de = são só texto dentro do println!, como qualquer outra mensagem.

Ver solução

fn main() {
    println!("==============");
    println!("  OLÁ, RUST");
    println!("==============");
}

Saída:

==============
  OLÁ, RUST
==============

▶ Experimente você mesmo

Resumo

• Instale o Rust com o rustup pelo site rustup.rs.
• Confira com rustc --version e cargo --version.
• Crie um projeto com cargo new e rode com cargo run.
• Um projeto tem um Cargo.toml (configurações) e um src/main.rs (seu código).
• Leia os erros do compilador de cima para baixo: o quê, onde e, muitas vezes, um help: com a correção.
• Instale o rust-analyzer no editor para ter uma experiência bem mais tranquila.

Teste o que aprendeu

Teste o que aprendeu

1. Qual ferramenta instala o compilador do Rust e o cargo, e mantém os dois atualizados?

rustup cargo rustc

2. Qual arquivo descreve o nome, a versão e as dependências de um projeto Rust?

src/main.rs target/debug/ Cargo.toml

3. Qual comando só compila o programa, sem rodá-lo?

cargo run cargo build cargo new

Pontuação: 0 / 3

Para saber mais

• Installation — The Rust Book (em inglês): como instalar em cada plataforma, atualizar com rustup update e resolver problemas.
• Hello, Cargo! — The Rust Book (em inglês): um olhar mais de perto em cargo new, cargo build, cargo run e cargo check.
• First Steps with Cargo — The Cargo Book (em inglês): o que o cargo new cria e o que significa cada linha do Cargo.toml.
• The rustup book (em inglês): como instalar toolchains extras, atualizar o Rust e alternar entre stable e nightly.
• rust-analyzer (em inglês): guias de configuração para VS Code, Neovim, Emacs e outros editores.