Go (Golang)

func worker(id int, jobs <-chan int, results chan<- int, wg *sync.WaitGroup) {
	defer wg.Done()
	for j := range jobs {
		results <- j * j
	}
}

func main() {
	jobs := make(chan int, 100)
	results := make(chan int, 100)
	var wg sync.WaitGroup

	for w := 1; w <= 3; w++ {
		wg.Add(1)
		go worker(w, jobs, results, &wg)
	}

	for j := 1; j <= 9; j++ {
		jobs <- j
	}
	close(jobs)

	wg.Wait()
	close(results)

	for r := range results {
		fmt.Println(r)
	}
}

select {
case res := <-resultCh:
	fmt.Println("wynik:", res)
case <-time.After(2 * time.Second):
	fmt.Println("timeout: brak odpowiedzi w 2s")
}

var ErrNotFound = errors.New("resource not found")

type ValidationError struct {
	Field string
}

func (e *ValidationError) Error() string {
	return fmt.Sprintf("invalid field: %s", e.Field)
}

func fetch(id int) error {
	if id < 0 {
		return &ValidationError{Field: "id"}
	}
	if id == 0 {
		return fmt.Errorf("fetch failed: %w", ErrNotFound)
	}
	return nil
}

func main() {
	err := fetch(0)

	if errors.Is(err, ErrNotFound) {
		fmt.Println("nie znaleziono zasobu")
	}

	var valErr *ValidationError
	if errors.As(err, &valErr) {
		fmt.Println("błąd walidacji pola:", valErr.Field)
	}
}

func validate(name string, age int) error {
	var errs error
	if name == "" {
		errs = errors.Join(errs, errors.New("name is required"))
	}
	if age < 0 {
		errs = errors.Join(errs, errors.New("age must not be negative"))
	}
	return errs // nil, jeśli obie walidacje przeszły
}

type Writer interface {
	Write(p []byte) (n int, err error)
}

type UpperWriter struct {
	w io.Writer
}

func (u UpperWriter) Write(p []byte) (int, error) {
	return u.w.Write(bytes.ToUpper(p))
}

func main() {
	var w Writer = UpperWriter{w: os.Stdout}
	w.Write([]byte("hello\n"))
}

type MyError struct{}

func (e *MyError) Error() string { return "boom" }

func mayFail(fail bool) *MyError {
	if fail {
		return &MyError{}
	}
	return nil
}

func do() error {
	var err *MyError = mayFail(false)
	return err // interfejs niosący (typ=*MyError, wartość=nil) - to NIE jest nil interfejsu
}

func main() {
	if err := do(); err != nil {
		fmt.Println("err != nil, mimo że logicznie nic się nie stało:", err)
	}
}

func closeAll() error {
	f1, err := os.Open("a.txt")
	if err != nil {
		return fmt.Errorf("opening a.txt: %w", err)
	}
	defer f1.Close()

	f2, err := os.Open("b.txt")
	if err != nil {
		return fmt.Errorf("opening b.txt: %w", err)
	}
	defer f2.Close()

	fmt.Println("praca z plikami")
	return nil
	// kolejność zamykania: najpierw f2.Close(), potem f1.Close() (LIFO)
}

func process(items []int) (err error) {
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("process: recovered from panic: %v", r)
		}
	}()

	for _, i := range items {
		fmt.Println(100 / i) // panikuje przy i == 0 (dzielenie int przez zero)
	}
	return nil
}

func recoverMiddleware(next http.Handler) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		defer func() {
			if rec := recover(); rec != nil {
				log.Printf("panic w handlerze: %v", rec)
				http.Error(w, "internal server error", http.StatusInternalServerError)
			}
		}()
		next.ServeHTTP(w, r)
	})
}

func fetchWithTimeout(ctx context.Context, url string) ([]byte, error) {
	ctx, cancel := context.WithTimeout(ctx, 3*time.Second)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
	if err != nil {
		return nil, fmt.Errorf("building request: %w", err)
	}

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

	return io.ReadAll(resp.Body)
}

func worker(ctx context.Context, jobs <-chan int) {
	for {
		select {
		case <-ctx.Done():
			fmt.Println("worker: zatrzymano,", ctx.Err())
			return
		case j, ok := <-jobs:
			if !ok {
				return
			}
			fmt.Println("przetwarzam:", j)
		}
	}
}

var counter int

func incBroken() {
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			counter++ // odczyt-modyfikacja-zapis bez ochrony: wyścig danych
		}()
	}
	wg.Wait()
	fmt.Println(counter) // niedeterministyczny wynik, zwykle < 1000
}

func incSafe() {
	var counter int64
	var wg sync.WaitGroup
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			atomic.AddInt64(&counter, 1)
		}()
	}
	wg.Wait()
	fmt.Println(atomic.LoadInt64(&counter)) // zawsze dokładnie 1000
}

func leaky() {
	ch := make(chan int) // niebuforowany
	go func() {
		ch <- computeExpensiveValue() // blokuje się w nieskończoność, gdy nikt nie odbiera
	}()
	// funkcja wraca bez odbioru z ch -> gorutyna wisi w pamięci na zawsze
}

func notLeaky(ctx context.Context) {
	ch := make(chan int, 1) // buforowany: wysyłka się nie zablokuje
	go func() {
		select {
		case ch <- computeExpensiveValue():
		case <-ctx.Done():
		}
	}()
}

import "cmp"

func Sum[T cmp.Ordered](nums []T) T {
	var total T
	for _, n := range nums {
		total += n
	}
	return total
}

type Numeric interface {
	~int | ~int64 | ~float32 | ~float64
}

func Average[T Numeric](nums []T) float64 {
	var sum T
	for _, n := range nums {
		sum += n
	}
	return float64(sum) / float64(len(nums))
}

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
	}
	n := len(s.items) - 1
	v := s.items[n]
	s.items = s.items[:n]
	return v, true
}