Go

package main

import "fmt"

func main() {
    // var declaration
    var name string = "Alice"
    var age int = 30

    // Short declaration (preferred inside functions)
    city := "NYC"
    count, err := getCount()

    // Constants
    const Pi = 3.14159
    const (
        StatusOK    = 200
        StatusNotFound = 404
    )

    // Zero values: 0, "", false, nil
    var n int     // 0
    var s string  // ""
    var b bool    // false

    fmt.Println(name, age, city, count, err, n, s, b)
}

import (
    "errors"
    "fmt"
)

// Return error as last value (convention)
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// Custom error type
type NotFoundError struct {
    ID int
}
func (e *NotFoundError) Error() string {
    return fmt.Sprintf("item %d not found", e.ID)
}

// Wrapping errors (Go 1.13+)
if err != nil {
    return fmt.Errorf("fetchUser: %w", err)
}

// Unwrap
var nfe *NotFoundError
if errors.As(err, &nfe) {
    fmt.Println("Not found:", nfe.ID)
}

import "sync"

// Goroutine
go func() {
    fmt.Println("concurrent")
}()

// Channel
ch := make(chan int, 10) // buffered
go func() { ch <- 42 }()
val := <-ch

// WaitGroup
var wg sync.WaitGroup
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(n int) {
        defer wg.Done()
        process(n)
    }(i)
}
wg.Wait()

// Mutex for shared state
var mu sync.Mutex
mu.Lock()
counter++
mu.Unlock()

// select: multiplex channels
select {
case msg := <-ch1:
    handle(msg)
case <-timeout:
    handleTimeout()
}