Rust (linguagem de programação)

Rust é uma linguagem de programação multiparadigma compilada desenvolvida pela Mozilla Research. É projetada para ser "segura, concorrente e prática", mas diferente de outras linguagens seguras, Rust não usa coletor de lixo. Possui suporte nativo ao WebAssembly.

Rust
Paradigma	Multiparadigma: concorrente estruturada funcional genérica imperativa
Surgido em	2010 (10–11 anos)
Última versão	1.55.0 (9 de setembro de 2021)
Versão em teste	1.56.0 (9 de setembro de 2021)
Criado por	Graydon Hoare
Estilo de tipagem	estática forte inferida
Principais implementações	rustc
Influenciada por	Alef C++ C# Cyclone Erlang Haskell Limbo Newsqueak OCaml Ruby Scheme Standard ML Swift
Influenciou	Crystal Elm Idris Nim PHP SPARK Swift Verona Zig
Plataforma	Prioridade 1 AArch64 (Linux) i686 x86-64 Prioridade 2 ARM e AArch64 PowerPC e PPC64 i386 i586 MIPS e MIPS64 SPARC RISC S390x asm.js WebAssembly
Sistema operacional	Prioridade 1 Linux Windows macOS Prioridade 2 FreeBSD NetBSD Android iOS Fuchsia Solaris Redox
Licença:	MIT ou Apache 2.0
Extensão do arquivo:	.rs .rlib
Página oficial	www.rust-lang.org

A linguagem apareceu como um projeto pessoal de Graydon Hoare, empregado da Mozilla. A organização começou a apoiar o projeto em 2009 e anunciou-o em 2010. No mesmo ano, os esforços mudaram do compilador original (escrito em OCaml) para um auto-hospedado feito em Rust. Conhecido por rustc, conseguiu compilar-se pela primeira vez em 2011 e utiliza o LLVM como back-end. Foi lançada pela primeira vez uma versão numerada pré-alfa em 2012. Rust 1.0, a primeira versão estável, foi lançada em 15 de maio de 2015.

Foi considerada pelo público a linguagem "mais amada" por cinco anos consecutivos, de acordo com pesquisas conduzidas pelo site Stack Overflow de 2016 a 2021, e está entre as 25 linguagens mais populares, de acordo com pesquisas conduzidas pela RedMonk desde 2018.

Design

Rust se baseia nos seguintes princípios: segurança sem coletor de lixo, concorrência sem disputa de dados e abstração sem overhead. Estes princípios fazem com que Rust seja rápida para ser usada em aplicações de baixo nível como o motor de renderização Servo e também prática para projetos de alto nível.

Em Rust não existem ponteiros nulos ou ponteiros soltos, impossibilitando falhas de segmentação. Rust gerencia memória e recursos automaticamente, sem necessitar de um coletor de lixo. A linguagem impede corridas de dados entre threads pois não é possível que duas threads possam modificar um mesmo valor ao mesmo tempo. Para que uma referência possa ser compartilhada entre várias threads, ela deve ser somente leitura. Existem diversas técnicas seguras de comunicação entre threads.

O princípio de abstração sem overhead vem do C++. Nas palavras de Bjarne Stroustrup: "Você não paga por aquilo que você não usa. E mais: aquilo que você usa, não conseguiria programar melhor à mão". Rust permite um alto grau de abstração através do sistema de traits, que são interfaces que podem ser implementadas separadamente da declaração de um tipo. Tipos genéricos são utilizados extensamente.

O projeto Rust usa o conceito de "canais de lançamento", semelhante ao Mozilla Firefox; são 3 canais: Nightly, Beta e Stable ("estável"). Diariamente é lançada uma nova versão Nightly, e a cada seis semanas a última versão desse canal é promovida para Beta, e só receberá atualizações para corrigir falhas sérias. Simultaneamente, a última versão Beta é promovida para Stable.

Eventualmente a sintaxe da linguagem evolui, e novas palavras-chave podem ser adicionadas. Para evitar a quebra de compatibilidade com códigos antigos, novas edições são lançadas, que projetos antigos podem ativar opcionalmente. Também é possível usar palavras-chave como identificadores, usando a seguinte sintaxe:

// `match` é uma palavra-chave
fn r#match(needle: &str, haystack: &str) -> bool {
    haystack.contains(needle)
}

Enumerações e casamento de padrões

Rust possui enumerações de tipagem forte, e suas variantes podem carregar valores diversos. Casamento de padrões é muito importante em Rust, pois as enumerações são a base do tratamento de erros. Exemplo de declaração de enumerações e o casamento de padrões:

enum Browser {
    Chrome,
    Firefox,
    Safari,
    Edge,
    Ie(u8),
}

let browser = Browser::Ie(11);
match browser {
    Browser::Chrome | Browser::Edge => println!("Chromium"),
    Browser::Ie(version) => println!("Internet Explorer {}", version),
    _ => println!("Outro navegador"),
}

O comando match pode retornar valores e também pode ser usado com outros tipos. Exemplo:

let age = 27u8;
let category = match age {
    // `0..=4` é um padrão inclusivo (inclui 0, 1, 2, 3 e 4)
    0..=4 => "bebê",
    5..=13 => "criança",
    14..=17 => "adolescente",
    18.. => "adulto",
};
println!("Com {} ano(s) você é considerado {}.", age, category);

Inexistência de valor

Rust usa enumerações para representar a inexistência de um valor na forma de enum Option<T> { None, Some(T) }. Exemplo:

let website = Some("https://www.wikipedia.org"); // `website: Option<&str>`
match website {
    None => println!("Website não especificado."),
    Some(addr) => println!("Website: {}", addr),
}

// Forma alternativa (ignora inexistência)
if let Some(addr) = website {
    println!("Website: {}", addr);
}

Existem métodos na biblioteca padrão que simplificam esse tipo de tratamento. Alguns exemplos:

let url1: Option<&str> = None;
let url2: Option<String> = None;

// Fornece um valor reserva
let website = url1.unwrap_or("http://www.example.com");

// Fornece o valor padrão do tipo (string vazia)
let website = url1.unwrap_or_default();

// Constrói um valor reserva através de uma clausura
let domain = "www.example.com";
let website = url2.unwrap_or_else(|| format!("http://{}", domain));

// Aborta (pânico)
let website = url1.unwrap();

// Aborta com uma explicação
let website = url1.expect("endereço inexistente");

Semelhante ao operador ?. em outras linguagens, também existem métodos que permitem trabalhar com o possível valor de forma segura. Alguns exemplos:

let website: Option<&str> = Some("https://www.wikipedia.org");

// Transforma o valor, se houver algum
let len = website.map(|d| d.len()); // `len: Option<usize>`

// Trabalha com o valor, se houver algum. A clausura precisa retornar Option
let domain = website.and_then(|addr| addr.strip_prefix("https://")); // `domain: Option<&str>`

Tratamento de erros

Rust não possui exceções como em C++. Ao invés disso, possui duas representações de erros: recuperáveis e irrecuperáveis. Os erros recuperáveis são os esperados no fluxo normal de um programa, e são comunicados através do retorno de funções na forma de enum Result<T, E> { Ok(T), Err(E) }. Exemplo:

use std::fs;
use std::io::prelude::*;

fn main() {
    match fs::File::open("exemplo.txt") {
        // Se o arquivo existir
        Ok(mut file) => {
            let mut txt = String::new();

            file.read_to_string(&mut txt).unwrap();
            println!("{}", txt);
        }
        // Se o arquivo não existir
        Err(err) => eprintln!("Erro: {}", err),
    }
}

É possível simplificar o código retornando os erros com o operador ?:

use std::fs;
use std::io::{self, prelude::*};

// `type io::Result<T> = Result<T, io::Error>`
fn main() -> io::Result<()> {
    let mut file = fs::File::open("exemplo.txt")?;
    let mut txt = String::new();

    file.read_to_string(&mut txt)?;
    println!("{}", txt);
    Ok(()) // Retorna `()` como sucesso
}

Os erros irrecuperáveis são usados para sinalizar problemas na lógica de um programa, como divisões por zero, e causam o encerramento do programa. Exemplo:

for i in -5..5 {
    println!("{}", 10 / i); // Pânico: divisão por zero
}

panic!("isto não deveria acontecer!"); // Alerta "pânico" manualmente

Em alguns casos óbvios de "pânico", como na divisão por zero, o compilador pode se recusar a compilar o código. Rust permite recuperar de alguns "pânicos" com a função especial std::panic::catch_unwind(), que não deve ser usada para emular o tratamento de exceções de C++.

Genéricos e ownership

Rust possui suporte a programação genérica e o conceito de ownership (posse). Valores podem ter apenas um dono; quando o dono sai de escopo, o valor é destruído. Valores podem ser emprestados (borrowing) ou movidos (move). Em certas ocasiões, como em referências circulares, é necessário especificar o lifetime (tempo de vida) de uma referência. Exemplo de uma árvore binária em Rust:

// `'a` é um lifetime, e `T` é um tipo genérico
#[derive(Debug)]
enum Tree<'a, T> {
    Empty,
    Node(T, &'a Tree<'a, T>, &'a Tree<'a, T>),
}

use Tree::{Empty, Node};

let tree = &Node(5.96, &Empty, &Node(1.0, &Empty, &Empty));

// O primeiro membro é movido; ignora demais membros
if let Node(value, ..) = tree {
    println!("{:?}", value);
}

// Ignora o primeiro membro; o terceiro membro é emprestado
if let Node(_, left, ref right) = tree {
    println!("-> {:?}", left);
    println!("-> {:?}", right);
}

Existe um tempo de vida especial chamado 'static, que indica que a referência é válida até o fim da execução do programa. Todas os literais de strings possuem ele implicitamente:

let hello: &str = "Olá, Mundo!"; // Implicitamente estática
let hello: &'static str = "Olá, Mundo!"; // O mesmo que acima

Rust é mais restrita que outras linguagens; um valor imutável pode ter várias referências, mas um valor mutável pode ter apenas uma. Para o segundo caso, é necessário usar uma das várias estruturas de referência como std::rc::Rc (contagem de referências), std::cell::RefCell (mutabilidade interna), entre outras. Outra possibilidade é o uso de alocação de arena.

Se houver ambiguidade na invocação de um método genérico, o tipo pode ser explicitado com o símbolo turbofish (::<>). Exemplo:

let dollar = "5.96".parse::<f64>().unwrap();
println!("US$ 1.00 = R$ {}", dollar);

Também é possível passar valores constantes como parâmetros genéricos. Exemplo:

struct Array<T, const N: usize> {
    data: [T; N],
}

let arr = Array { data: [0u64; 5] }; // `arr: Array<u64, 5>`

Traços e orientação a objetos

Rust possui suporte a traços (traits) que podem ser implementados por estruturas, enumerações e uniões. Traços podem ser deriváveis, como o Debug, onde é gerado um código padrão para implementar o traço em um objeto marcado com o atributo #[derive(…)]. A implementação padrão é definida através de macros procedurais. Exemplo de traços:

trait Animal {
    // Método estático
    fn type_name() -> &'static str;

    // `&self` é uma referência a instância
    fn flee(&self);
}

trait Feline: Animal {
    // Traços podem fornecer definições padrões para métodos
    fn meow(&self) {
        println!("Miau!");
    }
}

struct Cat<'a> {
    name: &'a str,
}

impl Animal for Cat<'_> {
    fn type_name() -> &'static str {
        "Cat"
    }

    fn flee(&self) {
        println!("{} fugiu.", self.name);
    }
}

impl Feline for Cat<'_> {}

// E o mesmo para `Dog`…

let type_name = Cat::type_name(); // Método estático
let cat = Cat { name: "Charlotte" }; // Nova instância
cat.flee(); // O mesmo que `Animal::flee(&cat);`
cat.meow(); // O mesmo que `Cat::meow(&cat);`

Estruturas, enumerações, uniões e funções podem especificar os traços dos membros/parâmetros de forma estática (genérica):

fn do_flee<T>(animal: &T)
where
    T: Animal,
{
    animal.flee();
}

// Ou o equivalente:
fn do_walk<T: Animal>(animal: &T) {
    animal.flee();
}

// Ou de forma mais compacta (incompatível com o turbofish):
fn do_walk(animal: &impl Animal) {
    animal.flee();
}

Ou de forma dinâmica (trait objects):

fn do_walk(animal: &dyn Animal) {
    animal.flee();
}

Em ambos os casos a instância é passada da mesma maneira:

let cat = Cat { name: "Charlotte" };
let dog = Dog { name: "Duke" };

do_walk(&cat);
do_walk(&dog);

Iteradores e clausuras

Rust possui um literal para representar iteradores, e traz em sua biblioteca padrão métodos para transformá-los, usando clausuras. No exemplo a seguir o programa lista os números primos entre 4 e 20:

let mut numbers = vec![];
// `4..=20` é um iterador inclusivo (inclui 20)
for i in 4..=20 {
    // `2..i` é um iterador exclusivo, ex.: `2..5` inclui 2, 3 e 4.
    // `|x| i % x != 0` é uma clausura que recebe `x` e retorna booliano.
    if (2..i).all(|x| i % x != 0) {
        numbers.push(i);
    }
}
println!("Os números primos entre 4 e 20 são: {:?}", numbers);

Clausuras podem capturar valores do ambiente de três maneiras: emprestando imutavelmente, mutavelmente ou movendo. A última é realizada com a palavra-chave move. Exemplo:

use std::thread;

let msg = "Olá, Mundo!".to_owned();

thread::spawn(move || {
    println!("{}", msg); // `msg` movido aqui
});

As clausuras são representadas por três traços:

• Fn – Empresta valores do ambiente imutavelmente
• FnMut – Empresta valores do ambiente mutavelmente; aceita também instâncias de Fn
• FnOnce – Move os valores do ambiente e pode ser chamada apenas uma vez; aceita também instâncias de Fn e FnMut

Exemplo:

fn convert<F>(num: f64, handler: F) -> f64
where
    F: FnOnce(f64) -> f64, // Assinatura da clausura
{
    handler(num)
}

fn main() {
    let y = convert(499.0, |num| num * 5.96);
    println!("{}", y);
}

Clausuras possuem um tipo único, mesmo que com a mesma assinatura; por esse motivo, para retornar uma clausura de uma função, é necessário usar uma sintaxe especial:

fn convert() -> impl FnOnce(f64) -> f64 {
    move |num| num * 5.96
}

fn main() {
    let f = convert();
    println!("{}", f(499.0));
}

Por fim, é possível passar estruturas tuplas ou variantes de enumerações onde se espera clausuras. Exemplo:

let seq: Box<_> = (1..=5).map(Some).collect();
println!("{:?}", seq); // [Some(1), Some(2), Some(3), Some(4), Some(5)]

Exemplos

Programa Olá Mundo

Ver artigo principal: Programa Olá Mundo

fn main() {
    println!("Olá, Mundo!");
}

Pode ser compilado e executado com o seguinte comando:

$ cargo run

Algoritmo de Trabb Pardo-Knuth

Ver artigo principal: Algoritmo de Trabb Pardo-Knuth

use std::io::{self, prelude::*};

fn f(t: f64) -> f64 {
    t.abs().sqrt() + 5.0 * t.powi(3)
}

fn main() {
    let mut a = [0f64; 11];
    for (t, input) in a.iter_mut().zip(io::stdin().lock().lines()) {
        *t = input.unwrap().parse().unwrap();
    }

    a.iter().enumerate().rev().for_each(|(i, &t)| match f(t) {
        y if y > 400.0 => println!("{} TOO LARGE", i),
        y => println!("{} {}", i, y),
    });
}

Rust lida com transbordamento numérico retornando f64::NAN.

Concorrência

Ver artigo principal: Programação concorrente

Exemplo retirado da documentação oficial:

use std::sync::mpsc::channel;
use std::thread;

fn main() {
    let (tx, rx) = channel();

    let sender = thread::spawn(move || {
        tx.send("Olá, Mundo!".to_owned())
            .expect("não foi possível enviar para o canal");
    });

    let receiver = thread::spawn(move || {
        let value = rx.recv().expect("não foi possível receber do canal");
        println!("{}", value);
    });

    sender.join().expect("o remetente entrou em pânico");
    receiver.join().expect("o destinatário entrou em pânico");
}

Servidor HTTP

Ver artigos principais: Hypertext Transfer Protocol e REST

Exemplo de um web service RESTful (HTTP) usando funções assíncronas e serialização; responde com um JSON ao acessar http://localhost:8080/hello/Mundo:

use actix_web::{get, web, App, HttpServer, Responder};
use serde::Serialize;
use std::time::SystemTime;

#[derive(Serialize)]
struct Hello {
    message: String,
    #[serde(with = "humantime_serde")]
    timestamp: SystemTime,
}

#[get("/hello/{name}")]
async fn hello(name: web::Path<String>) -> impl Responder {
    web::Json(Hello {
        message: format!("Olá, {}!", name),
        timestamp: SystemTime::now(),
    })
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| App::new().service(hello))
        .bind("127.0.0.1:8080")?
        .run()
        .await
}

E as dependências no arquivo Cargo.toml:

[dependencies]
actix-web = "3"
humantime-serde = "1.0"

[dependencies.serde]
version = "1.0"
features = ["derive"]

Interface de linha de comandos

Ver artigo principal: Interface de linha de comandos

Exemplo de uma implementação do echo do Unix:

use clap::{AppSettings::TrailingVarArg, Clap};

#[derive(Clap)]
#[clap(about = "Ecoa o(s) TEXTO(s) para a saída padrão.", setting = TrailingVarArg)]
struct Args {
    #[clap(short = 'n', about = "Não emitir o caractere de nova linha do final")]
    strip_trailing_newline: bool,
    #[clap(value_name = "TEXTO")]
    strings: Vec<String>,
}

fn main() {
    let args = Args::parse();
    let output = args.strings.join(" ");

    print!("{}", output);
    if !args.strip_trailing_newline {
        println!();
    }
}

E as dependências no arquivo Cargo.toml:

[dependencies]
clap = "3.0.0-beta.2"

Interface gráfica

Ver artigos principais: Interface gráfica do usuário e GTK

Exemplo de uma interface gráfica usando GTK 4:

use gtk::glib::{self, clone};
use gtk::{prelude::*, Application, ApplicationWindow, Button};
use std::process;

fn main() {
    // Cria um novo aplicativo
    let app = Application::builder()
        .application_id("com.example.Hello")
        .build();

    // Quando o aplicativo for ativado
    app.connect_activate(|app| {
        // Cria uma nova janela
        let window = ApplicationWindow::new(app);

        // Cria um novo botão
        let button = Button::with_label("Olá, Mundo!");

        // Quando o botão for clicado, fecha a janela
        button.connect_clicked(clone! { @weak window => move |_| window.close() });
        window.set_child(Some(&button));
        window.present();
    });

    process::exit(app.run());
}

E as dependências no arquivo Cargo.toml:

[dependencies.gtk]
version = "0.3"
package = "gtk4"

Ferramentas

Cargo é a ferramenta de produtividade oficial, e usa arquivos TOML para listar dependências e configurações de um projeto. Um projeto pode ser testado usando o comando $ cargo test. A documentação de um projeto pode ser gerada a partir de comentários especiais em Markdown, usando o comando $ cargo doc.

Rust possui uma implementação do Language Server Protocol, o RLS, que fornece autocompletar, formatação e refatoração independente do editor de texto ou ambiente de desenvolvimento integrado. Uma implementação alternativa existe, o rust-analyzer. Os seguintes editores dão suporte ao RLS de forma nativa ou através de extensões/plugins:

• Visual Studio Code – fornecido pela extensão oficial
• Sublime Text – fornecido pelo pacote oficial Rust Enhanced
• Atom – fornecido pelo pacote oficial ide-rust
• Visual Studio – fornecido por uma extensão
• Eclipse – fornecido pelo plugin Corrosion
• GNOME Builder – suporte nativo

Outras ferramentas dão suporte a Rust através de implementações próprias sem o uso do RLS:

• Vim – fornecido pelo plugin oficial rust.vim
• IntelliJ IDEA – fornecido pelo plugin IntelliJ Rust
• Emacs – fornecido pelo plugin oficial rust-mode

Software desenvolvido em Rust

Renderização

• Mozilla Firefox
  • Gecko – motor de renderização do Firefox com componentes do Servo
  • Servo – motor de renderização experimental
• librsvg – um motor de renderização de SVG; é usado pelo GNOME e pelo MediaWiki

Rede

• Discord – um serviço de chat para gamers; usa Rust no servidor e no aplicativo
• Fractal – um mensageiro baseado no protocolo Matrix
• Tor – uma rede anônima; usa Rust em alguns componentes
• OpenDNS – um serviço de DNS
• Cloudflare Workers – CDN com WebAssembly
• Azure IoT Edge – um serviço de inteligência para IoT; o daemon de segurança usa Rust
• npm Registry – um serviço de hospedagem de dependências para JavaScript e Node.js
• Magic Pocket – sistema de armazenamento do Dropbox

Blockchain

• Diem – uma criptomoeda criada pelo Facebook
• OpenEthereum – cliente Ethereum, uma plataforma de blockchain

Sistemas operacionais e componentes

• Android e Linux – suporte experimental para desenvolvimento de drivers e módulos secundários
• Google Fuchsia – usa Rust em alguns componentes
• Microsoft Windows – usa Rust em alguns componentes
• Redox – um sistema operacional tipo Unix com micronúcleo
• GNOME – usa Rust e alguns componentes do Servo no processamento de CSS
• GStreamer – um framework multimídia; usa Rust em alguns plugins
• Stratis – um sistema de arquivos usado pelo Fedora e RHEL

Outros

• 1Password – um gerenciador de senhas
• ripgrep – um substituto moderno do grep; é usado pelo Visual Studio Code
• Deno – um substituto do Node.js desenvolvido pelo criador original
• Xi – um editor de texto usado pelo Google Fuchsia

Ver também

• C++
• Go (linguagem de programação)
• Servo (motor de renderização)
• Swift (linguagem de programação)

Bibliografia

• Klabnik, Steve; Nichols, Carol (6 agosto de 2019) [julho de 2018]. The Rust Programming Language. Covers Rust 2018 (em inglês) 2 ed. [S.l.]: No Starch Press. 526 páginas. ISBN 978-1-7185-0044-0 
• Balbaert, Ivo (7 de novembro de 2017) [27 de maio de 2015]. Rust Essentials. A Quick Guide to Writing Fast, Safe, and Concurrent Systems and Applications (em inglês) 2 ed. [S.l.]: Packt Publishing. 264 páginas. ISBN 978-1-7883-9913-5 

Ligações externas

• Sítio oficial
• Rust no GitHub
• «The Rust Programming Language» (em inglês). Livro oficial 
• «Rust Playground» (em inglês). Experimente Rust online