Opa mano, eu fiquei animado ao ver o seu post sobre aprender Golang. Mas vou compartilhar algo bem interessante sobre Rust. Vou te mostrar como Rust pode te ajudar de uma forma um pouco melhor que o Golang (na minha opinião)
Golang é bacana e tudo, mas o tratamento de erros às vezes pode ser um pouco vago. Dá uma olhada nesse código Golang:
package main
import (
"fmt"
"errors"
)
func divide(a, b float64) (float64, error) {
if b == 0 {
return 0, errors.New("Divisão por zero")
}
return a / b, nil
}
func main() {
result, err := divide(10, 0)
if err != nil {
fmt.Println("Erro:", err)
return
}
fmt.Println("Resultado:", result)
}
Aqui estamos utilizando um tipo de erro simples. Mas e quando precisamos lidar com erros de tipos diferentes? É aí que Rust se destaca com seu "pattern matching" e os tipos "Result" e "Option".
Dá uma olhada nesse trecho de código em Rust:
fn divide(a: f64, b: f64) -> Result<f64, String> {
if b == 0.0 {
return Err("Divisão por zero".to_string());
}
Ok(a / b)
}
fn main() {
let result = divide(10.0, 0.0);
match result {
Ok(val) => println!("Resultado: {}", val),
Err(err) => println!("Erro: {}", err),
}
}
Nesse exemplo, estamos usando "Result" para representar sucesso ou erro, e o "match" para fazer uma correspondência com os resultados. Isso traz uma clareza incrível ao lidar com diferentes cenários de erro.
E quanto ao "Option", ele é bastante útil em situações em que um valor pode ser nulo. Enquanto Golang utiliza o conhecido "nil", em Rust a abordagem é diferente. Olha só esse pedaço:
fn find_element(arr: &[i32], target: i32) -> Option<usize> {
for (index, &value) in arr.iter().enumerate() {
if value == target {
return Some(index);
}
}
None
}
fn main() {
let arr = [1, 2, 3, 4, 5];
let target = 3;
match find_element(&arr, target) {
Some(index) => println!("Encontrado no índice: {}", index),
None => println!("Elemento não encontrado"),
}
}
Nesse caso, estamos utilizando "Option" para expressar a possibilidade de um valor nulo. Isso ajuda a escrever um código que lida explicitamente com essa situação, evitando surpresas desagradáveis.
Eu, particularmente, até gosto do Golang. Acho uma linguagem muito bem feita e bem aquitetada. Mas eu sinceramente recomendo pelo menos dar uma chance ao Rust.
Independentemente da sua escolha, continue na jornada de aprendizado e não hesite em buscar mais informações.