Introdução 📝

Esse post faz parte de uma série que estou escrevendo chamada "Aprendendo Rust do zero" onde eu tento resumir o que acho ser importante baseado no livro oficial no site do Rust. Nesse aqui gostaria de abordar como criar, compilar e executar o seu projeto utilizando Cargo, como veremos a seguir.

Sumário 📖

1. Instalando Rust
2. Hello, World!
3. Hello, Cargo! - você está aqui
4. Variáveis e Mutabilidade
5. Tipos de dados
6. Funções
7. Comentários Simples
8. Controle de Fluxo

Hello, Cargo! 🙋‍♂️

Se assim como eu você está acostumado a trabalhar com Node.js, provavelmente já conhece as funcionalidades e utilidade do NPM. NPM está para o Node.js assim como Cargo está para a linguagem de programação Rust. Além de ajudar no gerenciamento dos seus pacotes, o Cargo também pode fazer build do seu código, fazer download das bibliotecas que seu código depende para funcionar e também fazer build dessas bibliotecas (No Rust esses pacotes/bibliotecas são chamadas de dependências).

No post anterior fizemos o nosso primeiro pedaço de código, o famoso Hello, World!. Naquele exemplo não havia nenhuma dependência sendo utilizada no projeto, então se fossemos utilizar o Cargo, iriamos usar apenas a parte responsável por fazer a compilação. Em projetos grandes é certo que será necessário adicionar dependências, e se você começar o projeto usando Cargo, adicionar dependências será uma tarefa muito fácil.

Validando a instalação do Cargo ✅

Para validar a instalação e verificar a versão atual instalada do Cargo, execute o comando a seguir:

cargo --version

Se for mostrado um número de versão quer dizer que está tudo certo.

Se aparecer um erro tipo command not found, verifique se sua instalação está de acordo com a documentação oficial.

Criando um projeto com Cargo ✏️

Entre naquele diretório que você criou no primeiro post dessa série (se não tiver criado ainda, crie em um local de sua escolha). Então execute os seguintes comandos:

cargo new hello_cargo
cd hello_cargo

O primeiro comando cria um projeto Rust com os arquivos de configuração necessários dentro de um diretório com o nome que foi escolhido, nesse caso hello_cargo.

Se você navegar até o diretório criado vai notar que o Cargo gerou dois arquivos e um diretório. Um arquivo Cargo.toml e um diretório src com um arquivo chamado main.rs dentro dele.

Ao criar um projeto usando o Cargo, é iniciado também um repositório Git ja contendo um arquivo .gitignore. Se o comando cargo new for executado dentro de um diretório que já tenha um repositório Git iniciado, os arquivos git não serão criados novamente.

Analisando o arquivo Cargo.toml 🔎

Abra o arquivo Cargo.toml em algum editor de texto da sua escolha. Ele deve ser igual ao mostrado a seguir:

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2018"

[dependencies]

A extensão .toml vem de Tom's Obvious, Minimal Language, que é o formato que o Cargo usa para seu arquivo de configuração. É como se fosse o package.json do Node.js.

A primeira linha, [package], significa que as linhas a seguir estão definindo a configuração desse pacote.

As próximas três linhas definem a configuração que o Cargo precisa para poder compilar o projeto: o nome, a versão e a edição do Rust em uso.

A última linha, [dependencies], é onde começa a lista de dependências que seu projeto precisa. Os pacotes listados aqui também são conhecidos como crates.

Analisando o arquivo src/main.rs 🔎

Abra o arquivo main.rs que está dentro do diretório src

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

Ao criarmos o projeto usando Cargo, ele gerou pra gente um arquivo main.rs que mostra um Hello, World! assim como fizemos no post anterior. A diferença aqui é que o Cargo colocou o arquivo dentro do diretório src.

Cargo espera que os arquivos que contenham código que serão compilados, estejam dentro do diretório src. O diretório superior a esse deve ser utilizado somente para arquivos do tipo README, informações de licensa de uso, arquivos de configuração e qualquer outra coisa não relacionada diretamente ao seu código. Usar Cargo te ajuda a manter seu projeto organizado. Com Cargo há um lugar para tudo, e tudo está em seu devido lugar.

Se você iniciou um projeto sem usar o Cargo, é possível começar a usar simplesmente movendo todos os seus arquivos de código para dentro do diretório src e criar um arquivo Cargo.toml apropriado no diretório superior.

Compilando e executando um projeto com Cargo 🛠 🏃‍♂️

Para compilar seu projeto Rust criado com Cargo, basta executar o comando a seguir:

cargo build

Esse comando cria um arquivo executável no subdiretório target dentro do seu projeto: target/debug/hello_cargo ou target\debug\hello_cargo.exe no Windows.

Para executar o programa, basta executar o comando a seguir:

./target/debug/hello_cargo

Se estiver no Windows:

.\target\debug\hello_cargo.exe

Se tudo ocorrer bem a frase Hello, World! deve aparecer no seu terminal. Executar o comando cargo build pela primeira vez também faz com que o Cargo crie um novo arquivo no diretório superior chamado Cargo.lock, lembra do package-lock.json? Mesma ideia! Esse arquivo serve pro Cargo manter um registro correto das versões das dependências utilizadas no seu projeto. Não é necessário modificar esse arquivo manualmente, o Cargo é quem cuida disso por você.

Nós compilamos e executamos o projeto utilizando dois comandos separados, existe porém um "atalho" para fazer o Cargo compilar e executar em um mesmo comando, é o cargo run. É importante mencionar que ao executar esse comando, o Cargo só vai fazer uma nova compilação caso o código tenha sido alterado desde a última compilação.

Caso você tenha um projeto muito grande, ficar compilando ele toda vez para poder verificar se tudo está correto não é uma ideia muito performática. Por isso Cargo disponibiliza o comando chamado cargo check que verifica se o código é compilável sem o peso de fazer a compilação em sí, tornando ele uma ferramenta útil para ser executado de tempo em tempo validando o estado de compilação atual do código.

Compilando para o ambiente de Produção 📦

Quando seu projeto estiver concluído, é possível gerar um build para produção executando o comando cargo build --release, que compila o código com otimizações. Esse comando vai gerar o executável no subdiretório target/release em vez de target/debug. Ativar as otimizações faz com que seu código execute mais rápido, mas ao utilizá-las faz com que o tempo de compilação também aumente, por isso existem dois tipos de perfil de compilação, um para desenvolvimento, onde você pode compilar sempre e de forma rápida e um de produção, onde você não vai ficar compilando repetidamente e pode demorar um pouco mais devido as otimizações aplicadas ao programa, como mencionado anteriormente.

Motivos para usar Cargo 🤔

Em projetos simples provavelmente não estaremos usando tudo o que Cargo pode oferecer, mas ele vai provar o seu valor quando o projeto começar a ficar mais complexo. Gerenciar multiplos crates fica bem mais fácil com a ajuda do Cargo (imagine criar um projeto complexo em Node.js sem npm ou em C# sem o Nuget, por exemplo).

Um outro bom motivo para usar Cargo, é que para compilar qualquer projeto que já utiliza Cargo fica muito simples. Vamos supor que você tenha clonado um projeto escrito em Rust usando Git, pra compilar, nesse cenário hipotético, bastaria executar os seguintes comandos:

git clone example.org/someproject
cd comeproject
cargo build

Para obter mais informações sobre o Cargo, verifique a documentação oficial

Recapitulando o que aprendemos sobre Cargo ⏳

• Para compilar o projeto, cargo build.
• Para compilar e executar em um único comando, cargo run.
• Para verificar se é possível compilar o projeto sem o custo de gerar um arquivo executável, cargo check.
• Em vez de salvar o executável no mesmo diretório do seu código, ele salva em target/debug.

Referência 📚

Para escrever esse post e os possíveis próximos que virão, estou utilizando o livro online recomendado no site oficial do Rust, que você pode encontrar em doc.rust-lang.org/book/title-page.html.