Next steps: Go since the book

if err != nil {
	return fmt.Errorf("load config %s: %w", path, err)
}

type Stack[T any] struct{ items []T }
 
func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }
 
var ints Stack[int]
var words Stack[string]

func (s *Stack[T]) All() iter.Seq[T] {
	return func(yield func(T) bool) {
		for i := len(s.items) - 1; i >= 0; i-- {
			if !yield(s.items[i]) {
				return // the caller's loop hit break
			}
		}
	}
}
 
for v := range stack.All() { ... }

min(3, 1, 2)          // 1, built-in since 1.21
max(a, b)
clear(m)              // empty a map (or zero a slice)
for i := range 10 {}  // 0..9
slices.Contains(s, x)
slices.Index(s, x)
slices.Reverse(s)
maps.Clone(m)

package main
 
import (
	"cmp"
	"errors"
	"fmt"
	"iter"
	"maps"
	"slices"
	"strings"
)
 
var ErrEmpty = errors.New("empty stack")
 
type ValidationError struct{ Field string }
 
func (e *ValidationError) Error() string { return "invalid " + e.Field }
 
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, error) {
	var zero T
	if len(s.items) == 0 {
		return zero, ErrEmpty
	}
	v := s.items[len(s.items)-1]
	s.items = s.items[:len(s.items)-1]
	return v, nil
}
 
func (s *Stack[T]) All() iter.Seq[T] {
	return func(yield func(T) bool) {
		for i := len(s.items) - 1; i >= 0; i-- {
			if !yield(s.items[i]) {
				return
			}
		}
	}
}
 
func Max[T cmp.Ordered](first T, rest ...T) T {
	m := first
	for _, x := range rest {
		m = max(m, x)
	}
	return m
}
 
func Map[T, U any](xs []T, f func(T) U) []U {
	out := make([]U, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}
 
func register(name string) error {
	if name == "" {
		return fmt.Errorf("register: %w", &ValidationError{Field: "name"})
	}
	return nil
}
 
func main() {
	var s Stack[string]
	for _, w := range []string{"a", "b", "c"} {
		s.Push(w)
	}
	for w := range s.All() {
		fmt.Print(w, " ")
		if w == "b" {
			break
		}
	}
	fmt.Println()
 
	for range 3 {
		s.Pop()
	}
	_, err := s.Pop()
	wrapped := fmt.Errorf("undo: %w", err)
	fmt.Println(wrapped, "| is ErrEmpty:", errors.Is(wrapped, ErrEmpty))
 
	var ve *ValidationError
	if err := register(""); errors.As(err, &ve) {
		fmt.Println(err, "| field:", ve.Field)
	}
 
	fmt.Println(Max(3, 9, 4), Max("go", "rust"), min(2.5, 1.5))
	fmt.Println(Map([]string{"go", "dsa"}, strings.ToUpper))
 
	ages := map[string]int{"rina": 31, "adi": 24, "budi": 27}
	fmt.Println(slices.Sorted(maps.Keys(ages)))
	clear(ages)
	fmt.Println(len(ages))
}

c b 
undo: empty stack | is ErrEmpty: true
register: invalid name | field: name
9 rust 1.5
[GO DSA]
[adi budi rina]
0