A lasanha deliciosa do Lucian

Em Rust, atribuir um valor a um nome é chamado de vinculação. As vinculações são imutáveis, a menos que sejam declaradas com a palavra-chave mut. Como Rust é uma linguagem de tipagem estática, cada vinculação tem um tipo conhecido em tempo de compilação.

As vinculações são definidas mais comumente com a palavra-chave let. Especificar o tipo de uma vinculação é opcional para a maioria delas, já que a inferência de tipos do Rust geralmente consegue inferir o tipo a partir do valor. Uma vinculação se parece com isto:

// Automatically inferred type
let fingers = 10;

Funções são itens. Enquanto as vinculações normalmente se referem a um valor específico, os itens se referem a uma unidade de organização de código, geralmente uma função ou um módulo, que fica disponível durante todo o tempo de vida do programa. Uma função retorna automaticamente o resultado de sua última expressão. Uma função pode ter zero ou mais parâmetros, que são vinculações com o tempo de vida da chamada da função.

A inferência de tipos é teoricamente possível para funções, mas foi desativada como uma escolha intencional de design da linguagem. Isso significa que você precisa gastar um pouco mais de tempo ao escrever o código para especificar com precisão quais são os tipos de entrada e saída de uma função, mas você economiza esse tempo ao ler o código, porque todos os tipos de entrada e saída estão definidos explicitamente.

fn add(x: i32, y: i32) -> i32 {
  x + y
}

Para invocar uma função, escreva o nome dela seguido de parênteses. Se a função exigir parâmetros, é preciso especificar um argumento para cada um dentro dos parênteses.

let five = add(2, 3);

Se o tipo de uma vinculação não puder ser inferido, o compilador vai reportar um erro. Para corrigir isso, adicione uma anotação de tipo explícita à vinculação.

// Explicit type annotation
let fingers: i32 = 10;

Os itens em Rust podem ser usados antes ou depois de serem definidos, porque têm tempo de vida estático. Já as vinculações só podem ser usadas depois de serem definidas. Usar uma vinculação antes de defini-la resulta em um erro de compilação.

fn main() {
    // `fn add` hasn't yet been defined, but that's perfectly ok
    dbg!(add(3, 4));
}

fn add(x: i32, y: i32) -> i32 {
  x + y
}

// this won't compile; `a` is used before its binding is defined
let b = a;
let a = x + y;

Rust usa chaves ({}) para definir um escopo. Uma vinculação definida dentro de um escopo não consegue escapar dele.

let a = 1;
dbg!(a); // 1
{
    // Here, we re-bind `a` to a new value, which is still immutable.
    // This technique is called _shadowing_. The new binding is constrained to
    // this anonymous scope. Outside this scope, the previous binding still
    // applies.
    let a = 2;
    let b = 3;
    dbg!(a, b); // 2, 3
}
// can't use `b` anymore because it is out of scope
// dbg!(b);

// The shadowed `a` in the inner scope above has fallen out of scope,
// leaving us with our original binding.
dbg!(a); // 1

Os itens de Rust costumam ser organizados em módulos. Cada crate é implicitamente um módulo, mas pode definir submódulos internos de profundidade arbitrária. Um módulo agrupa funcionalidades relacionadas e é definido com a palavra-chave mod.

mod calc_i32 {
    fn add(a: i32, b: i32) -> i32 { a + b }
    fn sub(a: i32, b: i32) -> i32 { a - b }
    fn mul(a: i32, b: i32) -> i32 { a * b }
    fn div(a: i32, b: i32) -> i32 { a / b }
}

Rust dá suporte a dois tipos de comentários. A palavra-chave // indica um comentário de uma linha; tudo que vier depois dela até o fim da linha é ignorado. As palavras-chave /* e */ indicam um comentário de várias linhas; tudo que estiver entre essas duas palavras-chave é ignorado. É idiomático e uma boa prática preferir comentários de uma linha.

Rust também dá suporte a comentários de documentação, que aparecem na documentação gerada pelo cargo doc. Os comentários de documentação externos são formados com a palavra-chave ///, que age de forma idêntica à palavra-chave //. Eles se aplicam ao item que vem depois deles, como uma função:

/// The `add` function produces the sum of its arguments.
fn add(x: i32, y: i32) -> i32 { x + y }

Os comentários de documentação internos são formados com a palavra-chave //!, que age de forma idêntica à palavra-chave //. Eles se aplicam ao item que os contém, como um módulo:

mod my_cool_module {
    //! This module is the bee's knees.
}

Os comentários de documentação podem ter qualquer comprimento e conter markdown, que é renderizado na documentação gerada.