Rust é uma linguagem de programação de sistemas moderna, projetada para desempenho, segurança e concorrência. Ela oferece aos usuários recursos poderosos enquanto se esforça para eliminar erros comuns de programação, como desreferências de ponteiros nulos e condições de corrida. Rust enfatiza abstrações de custo zero, permitindo que os desenvolvedores escrevam código de alto nível sem sacrificar o desempenho. É particularmente adequada para tarefas onde o controle de baixo nível do hardware e a gestão de memória são necessários, como programação de sistemas, WebAssembly e criação de aplicações de alto desempenho.
Rust foi concebida em 2006 por Graydon Hoare na Mozilla Research. O propósito inicial da linguagem era abordar os desafios de desenvolver software concorrente seguro e criar uma alternativa mais confiável às linguagens de programação de sistemas existentes. Em 2010, a primeira versão pública do Rust foi lançada e rapidamente chamou a atenção por sua abordagem inovadora em segurança de memória e concorrência.
Rust se inspira em várias linguagens de programação, como C++ por seu design orientado a desempenho e linguagens de programação funcional por sua ênfase em imutabilidade e abstrações poderosas. Seu design também reflete princípios de linguagens como Haskell, particularmente em seu robusto sistema de tipos e habilidades de correspondência de padrões.
Desde sua criação, Rust amadureceu em uma linguagem amplamente reconhecida, com uma forte comunidade de desenvolvedores e um crescente ecossistema de bibliotecas. A linguagem tem o apoio oficial da Mozilla e ganhou tração em vários domínios, incluindo desenvolvimento web, sistemas embarcados e desenvolvimento de jogos. O lançamento do Rust 1.0 em 2015 marcou um marco significativo, solidificando sua estabilidade e prontidão para uso em produção. A Rust Foundation, estabelecida em 2021, apoia seu desenvolvimento e governança contínuos.
O modelo de propriedade único do Rust permite que os desenvolvedores gerenciem a memória sem um coletor de lixo. Cada variável em Rust tem um único proprietário, e a propriedade pode ser transferida ou "emprestada" através de referências. Esse recurso ajuda a garantir a segurança da memória, impondo regras de empréstimo rigorosas.
fn main() {
let s1 = String::from("Olá");
let s2 = &s1; // Emprestando s1
println!("{}", s2);
}
A correspondência de padrões em Rust permite que os desenvolvedores desestruturem tipos de dados e gerenciem o fluxo de controle complexo de forma fluida. A instrução match fornece uma maneira poderosa de ramificar a lógica com base em padrões de valor.
fn main() {
let numero = 4;
match numero {
1 => println!("Um"),
2 => println!("Dois"),
_ => println!("Outro"),
}
}
Rust utiliza inferência de tipos, permitindo que o compilador deduza automaticamente os tipos de variáveis, o que simplifica o código e melhora a legibilidade.
fn main() {
let x = 5; // O compilador infere que x é do tipo i32
}
Traits são semelhantes a interfaces em outras linguagens e permitem polimorfismo. Eles definem comportamentos compartilhados que os tipos podem implementar.
trait Falar {
fn falar(&self);
}
struct Cachorro;
impl Falar for Cachorro {
fn falar(&self) {
println!("Au Au!");
}
}
Os tipos Option e Result do Rust fornecem um robusto tratamento de erros e paradigmas de programação seguros contra nulos, permitindo que os desenvolvedores expressem explicitamente a possibilidade de ausência ou erro.
fn dividir(x: f64, y: f64) -> Option<f64> {
if y == 0.0 {
None
} else {
Some(x / y)
}
}
Rust suporta concorrência sem medo através de seu sistema de propriedade, permitindo que múltiplas threads operem em dados com risco mínimo de condições de corrida.
use std::thread;
fn main() {
let handle = thread::spawn(|| {
println!("Olá de uma thread!");
});
handle.join().unwrap();
}
O sistema de macros do Rust permite a geração de código, tornando possível escrever construções sintáticas personalizadas que podem ser reutilizadas em todo o código.
macro_rules! dizer_ola {
() => {
println!("Olá!");
};
}
fn main() {
dizer_ola!();
}
Closures em Rust são funções anônimas que podem capturar variáveis de seu ambiente, tornando-as flexíveis para paradigmas de programação funcional.
fn main() {
let adicionar = |a, b| a + b;
println!("{}", adicionar(5, 7));
}
Rust utiliza um sistema de módulos para organizar o código e controlar a visibilidade. Crates são pacotes de código Rust que podem ser compartilhados e reutilizados.
mod meu_modulo {
pub fn ola() {
println!("Olá do meu_modulo!");
}
}
fn main() {
meu_modulo::ola();
}
Rust possui recursos de documentação integrados, e a ferramenta Rustdoc gera automaticamente documentação a partir de comentários no código-fonte.
/// Esta função soma dois números.
///
/// # Exemplos
///
/// ```
/// let resultado = adicionar(2, 3);
/// assert_eq!(resultado, 5);
/// ```
fn adicionar(a: i32, b: i32) -> i32 {
a + b
}
Rust possui um rico conjunto de ferramentas para desenvolvedores, incluindo seu gerenciador de pacotes, Cargo, que facilita a gestão de dependências, construção e publicação de bibliotecas e aplicações. A biblioteca padrão do Rust fornece amplo suporte em tempo de execução para várias tarefas.
Várias IDEs e editores suportam o desenvolvimento em Rust, incluindo:
Para criar um novo projeto Rust, os desenvolvedores podem usar o Cargo com o seguinte comando:
cargo new meu_projeto
Este comando gera um novo diretório contendo uma estrutura básica de projeto Rust. Para construir o projeto, basta navegar até o diretório do projeto e executar:
cargo build
Rust é utilizado em vários domínios devido a seus recursos de desempenho e segurança. As principais aplicações incluem:
Rust é frequentemente comparado a outras linguagens de programação de sistemas devido à sua ênfase em desempenho e segurança. Aqui estão algumas comparações:
Traduzir código Rust para outras linguagens pode ser desafiador devido ao seu modelo de propriedade único e recursos avançados. No entanto, algumas ferramentas facilitam traduções de fonte para fonte, como: