Biblioteca Padrão do Rust: visão geral completa dos principais módulos e funcionalidades

Biblioteca Padrão do Rust: uma visão geral completa

A biblioteca padrão do Rust (std) é um conjunto de módulos fundamentais que fornecem ao desenvolvedor tudo o que é necessário para criar aplicações robustas, rápidas e seguras. Ao contrário de muitas outras linguagens, o Rust dá ênfase especial à segurança de memória e ao paralelismo sem um coletor de lixo. Neste artigo, vamos analisar detalhadamente os principais componentes da std com exemplos de código.

1. Módulos principais da biblioteca padrão

A biblioteca é dividida em vários grupos lógicos. Vamos considerar os mais importantes.

1.1. Módulo std::collections

Contém estruturas de dados para armazenar e gerenciar coleções de elementos. As mais populares:

• Vec<T> — array dinâmico (análogo ao ArrayList em Java).
• HashMap<K, V> — tabela hash para armazenar pares chave-valor.
• HashSet<T> — conjunto de valores únicos.
• BTreeMap e BTreeSet — coleções ordenadas baseadas em árvore rubro-negra.

use std::collections::HashMap;

fn main() {    let mut scores = HashMap::new();    scores.insert(String::from("Alice"), 100);    scores.insert(String::from("Bob"), 90);

    for (name, score) in &scores {        println!("{}: {}", name, score);    }}

1.2. Módulo std::io

Responsável pela entrada e saída: leitura do teclado, trabalho com arquivos, entrada/saída bufferizada. As traits principais: Read e Write.

use std::io::{self, BufRead};

fn main() -> io::Result<()> {    let stdin = io::stdin();    for line in stdin.lock().lines() {        println!("Você digitou: {}", line?);    }    Ok(())}

1.3. Módulo std::thread

Permite criar e gerenciar threads de execução. O Rust garante a segurança dos dados entre threads através do sistema de ownership e das traits Send e Sync.

use std::thread;

fn main() {    let handle = thread::spawn(|| {        for i in 1..10 {            println!("Thread: {}", i);        }    });

    for i in 1..5 {        println!("Thread principal: {}", i);    }

    handle.join().unwrap();}

2. Trabalhando com strings e texto

Em Rust, existem dois tipos de string:

• String — string mutável e proprietária (armazenada no heap).
• &str — slice de string imutável (referência a uma sequência UTF-8).

fn main() {    let mut hello = String::from("Olá, ");    hello.push_str("mundo!");    println!("{}", hello); // Saída: Olá, mundo!

    let slice: &str = &hello[0..4];    println!("Slice: {}", slice); // Saída: Olá}

3. Tratamento de erros

Em vez de exceções, o Rust usa duas enums:

• Option<T> — para casos em que o valor pode estar ausente (Some ou None).
• Result<T, E> — para operações que podem falhar (Ok ou Err).

use std::fs::File;use std::io::Read;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let mut file = File::open(path)?;    let mut contents = String::new();    file.read_to_string(&mut contents)?;    Ok(contents)}

fn main() {    match read_file("test.txt") {        Ok(content) => println!("Conteúdo: {}", content),        Err(e) => eprintln!("Erro: {}", e),    }}

4. Iterators e closures

Os iterators em Rust são lazy e poderosos. Eles permitem processar sequências de dados sem loops explícitos.

fn main() {    let numbers = vec![1,
```