Go or Rust: a detailed comparison and which language to choose

package main

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

// count words in several texts at once: a goroutine per text
func main() {
	texts := []string{"oak table and oak chair", "pine shelf", "walnut desk for the office"}
	counts := make([]int, len(texts))

	var wg sync.WaitGroup
	for i, t := range texts {
		wg.Go(func() { // Go 1.25+: WaitGroup.Go starts a goroutine and counts it
			counts[i] = len(strings.Fields(t))
		})
	}
	wg.Wait()
	fmt.Println(counts) // [5 2 5]
}

use std::thread;

// the same in Rust: scoped threads; the compiler proves there are no data races
fn main() {
    let texts = ["oak table and oak chair", "pine shelf", "walnut desk for the office"];
    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("too many items")

// an error is an ordinary value: it is returned and checked explicitly
func parseQty(s string) (int, error) {
	n, err := strconv.Atoi(s)
	if err != nil {
		return 0, fmt.Errorf("quantity %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("limit exceeded")
			continue
		}
		fmt.Println(n, err)
	}
	// 3 <nil>
	// 0 quantity "abc": strconv.Atoi: parsing "abc": invalid syntax
	// limit exceeded
}

use std::num::ParseIntError;

enum QtyError {
    NotANumber(ParseIntError),
    TooBig,
}

// Result: the error is part of the type, and the compiler will not let you ignore it
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!("limit exceeded"),
            Err(QtyError::NotANumber(e)) => println!("not a number: {e}"),
        }
    }
    // 3
    // not a number: invalid digit found in string
    // limit exceeded
}

package main

import "fmt"

// an interface is satisfied implicitly: it is enough to have the right method
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
}

// a trait is implemented explicitly, and the compiler checks every implementation
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![("Courier", Box::new(Courier { base: 300.0 })), ("Pickup", Box::new(Pickup))];
    for (name, o) in &options {
        println!("{name}: {:.0}", o.price(2.0));
    }
    // Courier: 400
    // Pickup: 0
}