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.