Go или Rust: подробное сравнение и какой язык выбрать

package main

import (
	"fmt"
	"strings"
	"sync"
)

// считаем слова в нескольких текстах сразу: по горутине на текст
func main() {
	texts := []string{"дубовый стол и дубовый стул", "сосновая полка", "ореховый стол для домашнего офиса"}
	counts := make([]int, len(texts))

	var wg sync.WaitGroup
	for i, t := range texts {
		wg.Go(func() { // Go 1.25+: WaitGroup.Go запускает горутину и учитывает её
			counts[i] = len(strings.Fields(t))
		})
	}
	wg.Wait()
	fmt.Println(counts) // [5 2 5]
}

use std::thread;

// то же на Rust: потоки в области видимости; компилятор доказывает, что гонок данных нет
fn main() {
    let texts = ["дубовый стол и дубовый стул", "сосновая полка", "ореховый стол для домашнего офиса"];
    let mut counts = [0; 3];

    thread::scope(|s| {
        for (count, text) in counts.iter_mut().zip(texts) {
            s.spawn(move || *count = text.split_whitespace().count());
        }
    });
    println!("{counts:?}"); // [5, 2, 5]
}

package main

import (
	"errors"
	"fmt"
	"strconv"
)

var ErrTooBig = errors.New("слишком много товаров")

// ошибка — обычное значение: её возвращают и проверяют явно
func parseQty(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("количество %q: %w", s, err)
	}
	if n > 100 {
		return 0, ErrTooBig
	}
	return n, nil
}

func main() {
	for _, in := range []string{"3", "abc", "500"} {
		n, err := parseQty(in)
		if errors.Is(err, ErrTooBig) {
			fmt.Println("превышен лимит")
			continue
		}
		fmt.Println(n, err)
	}
	// 3 <nil>
	// 0 количество "abc": strconv.Atoi: parsing "abc": invalid syntax
	// превышен лимит
}

use std::num::ParseIntError;

enum QtyError {
    NotANumber(ParseIntError),
    TooBig,
}

// Result: ошибка — часть типа, и компилятор не даст её проигнорировать
fn parse_qty(s: &str) -> Result<u32, QtyError> {
    let n: u32 = s.parse().map_err(QtyError::NotANumber)?;
    if n > 100 {
        return Err(QtyError::TooBig);
    }
    Ok(n)
}

fn main() {
    for input in ["3", "abc", "500"] {
        match parse_qty(input) {
            Ok(n) => println!("{n}"),
            Err(QtyError::TooBig) => println!("превышен лимит"),
            Err(QtyError::NotANumber(e)) => println!("не число: {e}"),
        }
    }
    // 3
    // не число: invalid digit found in string
    // превышен лимит
}

package main

import "fmt"

// интерфейс выполняется неявно: достаточно иметь нужный метод
type Shipping interface {
	Price(kg float64) float64
}

type Courier struct{ Base float64 }
type Pickup struct{}

func (c Courier) Price(kg float64) float64 { return c.Base + 50*kg }
func (Pickup) Price(float64) float64       { return 0 }

func main() {
	options := []Shipping{Courier{Base: 300}, Pickup{}}
	for _, o := range options {
		fmt.Printf("%T: %.0f\n", o, o.Price(2))
	}
	// main.Courier: 400
	// main.Pickup: 0
}

// трейт реализуется явно, и компилятор проверяет каждую реализацию
trait Shipping {
    fn price(&self, kg: f64) -> f64;
}

struct Courier {
    base: f64,
}
struct Pickup;

impl Shipping for Courier {
    fn price(&self, kg: f64) -> f64 {
        self.base + 50.0 * kg
    }
}
impl Shipping for Pickup {
    fn price(&self, _kg: f64) -> f64 {
        0.0
    }
}

fn main() {
    let options: Vec<(&str, Box<dyn Shipping>)> =
        vec![("Курьер", Box::new(Courier { base: 300.0 })), ("Самовывоз", Box::new(Pickup))];
    for (name, o) in &options {
        println!("{name}: {:.0}", o.price(2.0));
    }
    // Курьер: 400
    // Самовывоз: 0
}