Meia hora aprendendo Rust - Parte 1

Rodolfo Ghiggi — Sat, 11 Jun 2022 01:20:04 +0000

Esta é uma tradução livre do post escrito por Amos que você pode ler aqui. Como o artigo é bem extenso vou quebrar ele em pelo menos duas partes, esta é a parte 1.

A tradução foi autorizada por Amos através de mensagem direta no Twitter.

Para adquirir fluência em uma linguagem de programação é preciso ler muito. Mas como ler muito se ainda não sabemos o que aquele linguagem significa?

Neste artigo, em vez de focar em um ou dois conceitos, tentarei analisar o maior número possível de trechos de Rust e explicar o que significam as palavras-chave e os símbolos que eles contêm.

Pronto? Vamos lá!

Palavra chave let

let é utilizado pra criar uma variável:

let x; // declara "x"
x = 42; // define o valor 42 para "x"

Isso também pode ser escrito em apenas uma linha:

let x = 42;

Você pode definir explicitamente o tipo da variável utilizando : , que é uma anotação de tipo:

let x: i32; // `i32` é um valor inteiro de 32 bits com sinal
x = 42;


// também há i8, i16, i32, i64, i128
//    além disso há u8, u16, u32, u64, u128 para valores sem sinal

Isso também pode ser escrito em apenas uma linha:

let x: i32 = 42;

O compilador de Rust impede o uso de variáveis não inicializadas.

let x;
foobar(x); // error: borrow of possibly-uninitialized variable: `x`
x = 42;

E o fato de ele fazer isso é muito bom:

let x;
x = 42;
foobar(x); // a variável `x` pode ser utilizada aqui

O sublinhado(underline ou underscore) _ é um nome especial, ou melhor uma falta de nome, basicamente significa jogar algo fora:

// isso não faz nada pois 42 é uma constante
let _ = 42;

// isso chama a função `get_thing` mas joga o seu resultado fora
let _ = get_thing();

Nomes que começam com sublinhado são nomes válidos, mas o compilador não alerta sobre a não utilização dessas variáveis:

// nós podemos usar `_x` eventualmente, quando queremos nos 
// livrar do aviso do compilador sobre variável não utilizada.
let _x = 42;

É possível inicializar variáveis separadamente utilizado o mesmo nome — você pode sobrescrever uma variável:

let x = 13;
let x = x + 3;
// usando `x` depois desta linha, refere-se apenas ao segundo `x`,
// o primeiro `x` não existe mais.

Tuplas

O Rust possui tuplas, que você pode considerar como “coleções de valores fixos de tipos diferentes”.

let pair = ('a', 17);
pair.0; // isso é'a'
pair.1; // isso é 17

Se você realmente precisar, pode definir os tipos dos valores da tupla:

let pair: (char, i32) = ('a', 17);

Tuplas podem ser desconstruídas, ou seja, os seus valores podem ser atribuídos a variáveis individuais:

let (some_char, some_int) = ('a', 17);
// agora, `some_char` é 'a', e `some_int` é17

Isso é bem útil quando uma função retorna uma tupla:

let (left, right) = slice.split_at(middle);

Obviamente, ao desconstuir uma tulpa pode-se descartar parte dela utilizando _ :

let (_, right) = slice.split_at(middle);

Ponto e vírgula

O ponto e vírgula ; define o fim da instrução:

let x = 3;
let y = 5;
let z = y + x;

Isso significa que uma instrução pode conter várias linhas:

let x = vec![1, 2, 3, 4, 5, 6, 7, 8]
    .iter()
    .map(|x| x + 3)
    .fold(0, |x, y| x + y);

Omitir o ponto e vírgula no final da função é o mesmo que retornar:

fn fair_dice_roll() -> i32 {
    return 4;
}

fn fair_dice_roll() -> i32 {
    4
}

Funções

fn declara uma função:

fn greet() {
    println!("Olá!");
}

E esta função retorna um inteiro com sinal, a seta -> indica o tipo de retorno:

fn fair_dice_roll() -> i32 {
    4
}

Blocos {}

O par de chaves é utilizado para declarar um bloco que possui seu próprio escopo:

// Isso imprime "in", e depois "out"
fn main() {
    let x = "out";
    {
        // este é outro `x`
        let x = "in";
        println!(x);
    }
    println!(x);
}

Blocos também são expressões, o que significa que eles avaliam um valor:

// isso:
let x = 42;

// é equivalente a:
let x = { 42 };

Dentro de um bloco, podemos ter várias instruções:

let x = {
    let y = 1; // primeira instrução
    let z = 2; // segunda instrução
    y + z // isso é o que o bloco avaliará e colocará o resultado em `x`
};

Condicionais

Condicionais if também são expressões:

fn fair_dice_roll() -> i32 {
    if feeling_lucky {
        6
    } else {
        4
    }
}

Um match também é uma expressão:

fn fair_dice_roll() -> i32 {
    match feeling_lucky {
        true => 6,
        false => 4,
    }
}

O match é exaustivo: pelo menos um dos cados precisa bater:

fn print_number(n: Number) {
    match n {
        Number { value: 1, .. } => println!("One"),
        Number { value: 2, .. } => println!("Two"),
        Number { value, .. } => println!("{}", value),
        // Se este último caso não existir você receberá um erro do compilador
    }
}

Se isso for ruim para você, pode-se usar o _ para “pegar todos” os padrões:

fn print_number(n: Number) {
    match n.value {
        1 => println!("One"),
        2 => println!("Two"),
        _ => println!("{}", n.value),
    }
}

Acessando valores

Ponto . normalmente é utilizado para acessar o valor de um campo:

let a = (10, 20);
a.0; // isso é 10

let amos = get_some_struct();
amos.nickname; // isso é "fasterthanlime"

Ou para chamar uma função:

let nick = "fasterthanlime";
nick.len(); // isso é 14

Os dois pontos duplos :: , são parecidos, mas eles acessam os namespaces (não sabia exatamente como traduzir isso, então deixei assim).

Neste exemplo, std é uma biblioteca, cmp é um módulo (~ um arquivo de código), e min é uma função:

let least = std::cmp::min(3, 8); // isso é 3

A diretiva use pode ser utilizada para “trazer para o escopo” nomes de outros namespaces:

use std::cmp::min;

let least = min(7, 1); // isso é 1

Diretiva `use`

Na diretiva use as chaves {} possuem outro significado: elas são “ globs”. Se quisermos importar as funções min e max , podemos fazer assim:

// isso funciona:
use std::cmp::min;
use std::cmp::max;

// isso também:
use std::cmp::{min, max};

// e isso também!
use std::{cmp::min, cmp::max}

O curinga (*) permite importar tudo de um namespace:

// isso importa `min` e `max` e muitas outras coisas
use std::cmp::*;

Tipos também são namespaces

Tipos também são namespaces, e os seus métodos podem ser chamados normalmente:

let x = "amos".len(); // isso é 4
let x = str::len("amos"); // isso também é 4

str é um tipo primitivo, mas muitos tipos não primitivos, também estão no escopo por padrão:

// `Vec` é uma estrutura regular, não um tipo primitivo
let v = Vec::new();

// este é exatamente o mesmo código, mas com o caminho completo para `Vec`
let v = std::vec::Vec::new();

Isso funciona porque o Rust insere automaticamente no início de cada módulo:

use std::prelude::v1::*;

(Que por sua vez, reexporta muitos símbolos, como Vec, String, Option e Result).

Estruturas

Estruturas são declaradas através da palavra chave struct:

struct Vec2 {
    x: f64, // 64 bits com ponto flutuante, também conhecido como "double precision"
    y: f64,
}

Elas podem ser inicializadas através de estruturas literais:

let v1 = Vec2 { x: 1.0, y: 3.0 };
let v2 = Vec2 { y: 2.0, x: 4.0 };
// a ordem não importa, apenas os nomes

Existe um atalho para inicializar o resto dos campos a partir de outra estrutura:

let v3 = Vec2 {
    x: 14.0,
    ..v2
};

Isso é chamado de “sintaxe de atualização de estrutura”, só pode acontecer na última posição e não pode ser seguido por uma vírgula.

Observe que podemos inicializar todos os campos:

let v4 = Vec2 { ..v3 };

Estruturas, assim como as tuplas, também podem ser desconstruídas:

Assim como isto é um padrão válido:

let (left, right) = slice.split_at(middle);

Isso também:

let v = Vec2 { x: 3.0, y: 6.0 };
let Vec2 { x, y } = v;
// `x` agora é 3.0, `y` é `6.0`

E isso também:

let Vec2 { x, .. } = v;
// isso descarta o valor de `v.y`

Você pode declarar funções nas suas estrutuas:

struct Number {
    odd: bool,
    value: i32,
}

impl Number {
    fn is_strictly_positive(self) -> bool {
        self.value > 0
    }
}

E utilizá-las como de costume:

fn main() {
    let minus_two = Number {
        odd: false,
        value: -2,
    };
    println!("positive? {}", minus_two.is_strictly_positive());
    // isso imprime "positive? false"
}

`let` em condicionais

O let também pode ser usado em condicionais if:

struct Number {
    odd: bool,
    value: i32,
}

fn main() {
    let one = Number { odd: true, value: 1 };
    let two = Number { odd: false, value: 2 };
    print_number(one);
    print_number(two);
}

fn print_number(n: Number) {
    if let Number { odd: true, value } = n {
        println!("Odd number: {}", value);
    } else if let Number { odd: false, value } = n {
        println!("Even number: {}", value);
    }
}

// isso imprime:
// Odd number: 1
// Even number: 2

Os casos do match também são padrões como if let:

fn print_number(n: Number) {
    match n {
        Number { odd: true, value } => println!("Odd number: {}", value),
        Number { odd: false, value } => println!("Even number: {}", value),
    }
}
// isso imprime o mesmo de antes

Variáveis são imutáveis por padrão

Variáveis são imutáveis por padrão, então você não pode alterá-las:

fn main() {
    let n = Number {
        odd: true,
        value: 17,
    };
    n.odd = false; // error: cannot assign to `n.odd`,
                   // as `n` is not declared to be mutable
}

E elas também não podem receber valores assim:

fn main() {
    let n = Number {
        odd: true,
        value: 17,
    };
    n = Number {
        odd: false,
        value: 22,
    }; // error: cannot assign twice to immutable variable `n`
}

A palavra chave mut declara a variável como mútavel:

fn main() {
    let mut n = Number {
        odd: true,
        value: 17,
    }
    n.value = 19; // tudo certo
}

DEV Community: Rodolfo Ghiggi

Meia hora aprendendo Rust - Parte 1

Palavra chave let

Tuplas

Ponto e vírgula

Funções

Blocos {}

Condicionais

Acessando valores

Diretiva `use`

Tipos também são namespaces

Estruturas

`let` em condicionais

Variáveis são imutáveis por padrão

Referências

DEV Community: Rodolfo Ghiggi

Meia hora aprendendo Rust - Parte 1

Palavra chave let

Tuplas

Ponto e vírgula

Funções

Blocos {}

Condicionais

Acessando valores

Diretiva use

Tipos também são namespaces

Estruturas

let em condicionais

Variáveis são imutáveis por padrão

Referências

Diretiva `use`

`let` em condicionais