Go cheat sheet

package main
 
import (
	"cmp"
	"fmt"
	"maps"
	"slices"
	"strings"
)
 
func main() {
	text := "the cat sat on the mat and the cat slept"
 
	counts := map[string]int{}
	for _, word := range strings.Fields(text) {
		counts[word]++
	}
 
	words := slices.Collect(maps.Keys(counts))
	slices.SortFunc(words, func(a, b string) int {
		return cmp.Or(
			cmp.Compare(counts[b], counts[a]), // most frequent first
			strings.Compare(a, b),             // then A to Z
		)
	})
 
	for _, word := range words[:3] {
		fmt.Printf("%-5s %d\n", word, counts[word])
	}
	// the   3
	// cat   2
	// and   1
}

package main
 
import (
	"fmt"
	"math"
)
 
type Shape interface {
	Area() float64
}
 
type Circle struct{ R float64 }
type Rect struct{ W, H float64 }
 
func (c Circle) Area() float64 { return math.Pi * c.R * c.R }
func (r Rect) Area() float64   { return r.W * r.H }
 
// String makes Rect a fmt.Stringer, so Println and %v use it.
func (r Rect) String() string { return fmt.Sprintf("%gx%g rectangle", r.W, r.H) }
 
func Total(shapes ...Shape) float64 {
	sum := 0.0
	for _, s := range shapes {
		sum += s.Area()
	}
	return sum
}
 
func describe(s Shape) string {
	switch v := s.(type) {
	case Circle:
		return fmt.Sprintf("circle of radius %g", v.R)
	case fmt.Stringer:
		return v.String()
	default:
		return fmt.Sprintf("%T", v)
	}
}
 
func main() {
	shapes := []Shape{Circle{R: 1}, Rect{W: 3, H: 4}}
	for _, s := range shapes {
		fmt.Printf("%-18s %6.2f\n", describe(s), s.Area())
	}
	fmt.Printf("%-18s %6.2f\n", "total", Total(shapes...))
	// circle of radius 1   3.14
	// 3x4 rectangle       12.00
	// total               15.14
}

package main
 
import (
	"errors"
	"fmt"
	"io/fs"
	"os"
	"strconv"
	"strings"
)
 
type ConfigError struct {
	Line int
	Msg  string
}
 
func (e *ConfigError) Error() string {
	return fmt.Sprintf("line %d: %s", e.Line, e.Msg)
}
 
func parsePort(text string) (int, error) {
	for i, line := range strings.Split(text, "\n") {
		key, value, ok := strings.Cut(line, "=")
		if !ok || strings.TrimSpace(key) != "port" {
			continue
		}
		port, err := strconv.Atoi(strings.TrimSpace(value))
		if err != nil {
			return 0, &ConfigError{Line: i + 1, Msg: "port is not a number"}
		}
		return port, nil
	}
	return 80, nil
}
 
func loadPort(path string) (int, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		return 0, fmt.Errorf("load config: %w", err)
	}
	port, err := parsePort(string(data))
	if err != nil {
		return 0, fmt.Errorf("load config %s: %w", path, err)
	}
	return port, nil
}
 
func main() {
	os.WriteFile("bad.conf", []byte("host = localhost\nport = eighty\n"), 0o644)
	defer os.Remove("bad.conf")
 
	for _, path := range []string{"missing.conf", "bad.conf"} {
		_, err := loadPort(path)
		fmt.Println(err)
 
		if errors.Is(err, fs.ErrNotExist) {
			fmt.Println("  -> no file, using the defaults")
		}
		if ce, ok := errors.AsType[*ConfigError](err); ok {
			fmt.Println("  -> fix line", ce.Line)
		}
	}
	// load config: open missing.conf: no such file or directory
	//   -> no file, using the defaults
	// load config bad.conf: line 2: port is not a number
	//   -> fix line 2
}

package main
 
import (
	"context"
	"fmt"
	"slices"
	"sync"
	"time"
)
 
func worker(ctx context.Context, jobs <-chan int, results chan<- string) {
	for n := range jobs {
		select {
		case <-ctx.Done():
			return // timed out: stop taking work
		case <-time.After(10 * time.Millisecond): // pretend to work
		}
		results <- fmt.Sprintf("%d squared is %d", n, n*n)
	}
}
 
func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
 
	jobs := make(chan int)
	results := make(chan string)
 
	var wg sync.WaitGroup
	for range 3 {
		wg.Go(func() { worker(ctx, jobs, results) })
	}
 
	go func() {
		defer close(jobs) // lets each worker's range loop end
		for n := 1; n <= 5; n++ {
			select {
			case jobs <- n:
			case <-ctx.Done():
				return
			}
		}
	}()
 
	go func() {
		wg.Wait()
		close(results) // lets the range below end
	}()
 
	var lines []string
	for line := range results {
		lines = append(lines, line)
	}
	slices.Sort(lines) // workers finish in any order
	for _, line := range lines {
		fmt.Println(line)
	}
	fmt.Println("error:", ctx.Err())
	// 1 squared is 1
	// 2 squared is 4
	// 3 squared is 9
	// 4 squared is 16
	// 5 squared is 25
	// error: <nil>
}

package main
 
import (
	"fmt"
	"strings"
)
 
type Stack[T any] struct {
	items []T
}
 
func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
 
func (s *Stack[T]) Pop() (T, bool) {
	var zero T
	if len(s.items) == 0 {
		return zero, false
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, true
}
 
// Map declares its own type parameter U: a generic method.
func (s *Stack[T]) Map[U any](f func(T) U) []U {
	out := make([]U, 0, len(s.items))
	for _, v := range s.items {
		out = append(out, f(v))
	}
	return out
}
 
func main() {
	var words Stack[string]
	words.Push("go")
	words.Push("gopher")
	fmt.Println(words.Map(strings.ToUpper)) // [GO GOPHER]
 
	lengths := words.Map(func(s string) int { return len(s) })
	fmt.Println(lengths) // [2 6]
 
	top, ok := words.Pop()
	fmt.Println(top, ok) // gopher true
	words.Pop()
	_, ok = words.Pop()
	fmt.Println(ok) // false: empty, and no panic
	// words.Push(42)  // cannot use 42 (untyped int constant) as string value
}