Go Programming Notes

package main
import "fmt"
 
func main() {
    fmt.Println("Hello, World!")
}

go env                    # View all environment variables
go env GOARCH GOOS       # View architecture and OS

// Boolean
bool
 
// String
string
 
// Integers (unsigned)
// Note: ranges assume typical implementation on common architectures
uint      // platform-dependent (32 or 64 bit)
uint8  (0 to 255)
uint16 (0 to 65535)
uint32 (0 to 4294967295)
uint64 (0 to 18446744073709551615)
uintptr // platform-dependent (pointer-sized unsigned int)
 
// Integers (signed)
int    // platform-dependent (32 or 64 bit)
int8   (-128 to 127)
int16  (-32768 to 32767)
int32  (-2147483648 to 2147483647)
int64  (-9223372036854775808 to 9223372036854775807)
 
// Floating point
float32 float64
 
// Aliases
byte    // alias for uint8
rune    // alias for int32 (represents a Unicode code point)
 
// Complex numbers
complex64 complex128

// Method 1: Declare then assign
var name string
name = "John"
 
// Method 2: Declare and initialize
var name string = "John"
 
// Method 3: Multiple variables
var b, c int = 1, 2
 
// Method 4: Type inference
var name = "John"
 
// Method 5: Short declaration (inside functions only)
name := "John"  
// Outside a function, every statement begins with a keyword (var, func, etc.)
// so the := construct is not available

%T // Format specifier to get type of variable

const pi = 3.14
 
// Constants cannot be declared using := syntax
// var name := "test"  // This works for variables
// const name := "test"  // ERROR! Must use: const name = "test"
 
// Numeric constants are high-precision values
const d = 3e20  // 300,000,000,000,000,000,000

const bigNumber = 3e20           // OK - untyped constant
// var x int64 = bigNumber       // ERROR - too big for int64
var y float64 = bigNumber        // OK - fits in float64

fmt.Scan(&a, &name)

fmt.Scanln(&a, &name)

fmt.Scanf("%d %s", &a, &name)

import "bufio"
reader := bufio.NewReader(os.Stdin)
reader.Scan() 
input := reader.Text()
fmt.Println("You typed: %q",input)
 
reader := bufio.NewReader(os.Stdin) 
input, _ := reader.ReadString('\n')  // Reads entire line including spaces, stops on new line

fmt.Print("Hello", " ", "World!")  // Output: Hello World!

fmt.Println("Hello", "World!")  // Output: Hello World!\n

fmt.Printf("Name: %s, Age: %d\n", "Alice", 25)
fmt.Printf("%d %c\n", A[i], A[i])  // %d = ASCII value, %c = character

message := fmt.Sprint("Hello", " ", "World!")
fmt.Println(message)

message := fmt.Sprintln("Hello", "World!")
fmt.Print(message)

message := fmt.Sprintf("Name: %s, Age: %d", "Alice", 25)
fmt.Println(message)

import (
    "os"
    "fmt"
)
func main() {
    fmt.Fprint(os.Stdout, "Hello World!")
}

if a < b {
    // code
} else if a > c {
    // code
} else {
    // code
}
 
// Statement can precede conditional
if num := 9; num < 0 {
    // num is available here and in all subsequent branches
}

if z := a; z > n {
    // z is available in this scope
    fmt.Println(z)
}
// z is not available here

// With maps
if val, ok := m[key]; ok {
    // Key exists, use val
    fmt.Println(val)
} else {
    // Key doesn't exist
    fmt.Println("Key not found")
}
 
// Shorthand
val, ok := m[key]
if !ok {
    fmt.Println("Key not found")
}

switch i {
    case 1:
        // code
    case 2, 3, 4:  // Multiple values
        // code
    case i < 10:   // Conditional expression
        // code
    case 'a', 'e', 'i', 'o', 'u':
        // code
    case "yes":
        // code
    default:
        // code
}
 
// Switch without expression (alternate if-else)
switch {
    case a < 12:
        fmt.Println("It's before noon")
    default:
        fmt.Println("It's after noon")
}

for i, j := 0, len(A)-1; i < j; i, j = i+1, j-1 {
    // code
}

// Slice or Array
for i, v := range slice {
    // i = index, v = value
    fmt.Printf("Index: %d, Value: %d\n", i, v)
}
 
// Map
for k, v := range map {
    // k = key, v = value
    fmt.Printf("Key: %s, Value: %d\n", k, v)
}
 
// String (iterates over runes, not bytes)
for i, c := range "hello" {
    // i = byte index (not rune index!), c = rune
    fmt.Printf("Byte index: %d, Character: %c\n", i, c)
}
 
// Ignore index/key with _
for _, v := range slice {
    fmt.Println(v)
}
 
// Just get index/key
for i := range slice {
    fmt.Println(i)
}

func addTwoNums(a, b int) int {
    return a + b
}
 
result := addTwoNums(1, 2)

// Function literal assigned to variable
hypot := func(x, y float64) float64 {
    return math.Sqrt(x*x + y*y)
}
fmt.Println(hypot(5, 12))
 
// Immediate invocation (no parameters)
func() {
    fmt.Println("Hi!")
}()
 
// Immediate invocation with parameters
func(name string) {
    fmt.Println("Hello,", name)
}("Alice")

func dum(num ...int) {
    fmt.Print(num)  // Equivalent to []int
}
 
func main() {
    dum(2, 4)
    dum(1, 2, 3, 4, 5)
}

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return  // "naked" return
}

// i is used inside the func from outside func
func intSeq() func() int { // the Factory
    i := 0 // Blueprint: "Every machine gets a private memory 'i' starting at 0."
    
    // Blueprint: "The machine we build is a function that does this:"
    return func() int {
        i++         // Pressing the button adds 1 to its private 'i'.
        return i    // Then it returns the new value of 'i'.
    }
}
 
f := intSeq()
fmt.Println(f())  // 1
fmt.Println(f())  // 2
fmt.Println(f())  // 3
 
g := intSeq()
fmt.Println(g())  // 1
fmt.Println(g())  // 2

func fibonacci() func() int {
    f1, f2 := 0, 1
    return func() int {
        f := f1
        f1, f2 = f2, f+f2
        return f
    }
}
 
func main() {
    f := fibonacci()
    for i := 0; i < 10; i++ {
        fmt.Println(f())
    }
}

var fib func(n int) int
 
// Must declare 'fib' variable first, then assign the function
// This is because the function body refers to 'fib' itself
fib = func(n int) int {
    if n < 2 {
        return n
    }
    return fib(n-1) + fib(n-2)  // Calls itself
}
 
fib(10)

func doMath(a int, b int, f func(int, int) int) int {
    return f(a, b)
}
 
func add(a, b int) int {
    return a + b
}
 
doMath(1, 2, add)

func main() {
    fmt.Println("counting")
    for i := 0; i < 3; i++ {
        defer fmt.Println(i)
    }
    fmt.Println("done")
}
// Output:
// counting
// done
// 2
// 1
// 0

func demonstrateArgumentEvaluation() {
    i := 10
    fmt.Printf("1. Declaring 'i' with value: %d\n", i)
    
    defer fmt.Printf("3. Deferred print. Value of 'i' is: %d\n", i)
    
    i = 20
    fmt.Printf("2. After changing 'i', its value is now: %d\n", i)
}
// Output:
// 1. Declaring 'i' with value: 10
// 2. After changing 'i', its value is now: 20
// 3. Deferred print. Value of 'i' is: 10

var a [5]int                    // Declaration
var a = [2]int{1, 2}           // Initialize
var a = [...]int{1, 2}         // Length inferred
a := [5]int{1: 2, 4: 3}        // Initialize specific elements
a := [5]int{1, 2}              // Partially initialized
 
fmt.Println(a[0])              // Access element
fmt.Println(a)                 // Print array
a[0] = 3                       // Change element
len(a)                         // Length
 
// Multi-dimensional
twoD := [2][3]int{
    {1, 2, 3},
    {4, 5, 6},
}

var a []int                    // nil slice
primes := []int{2, 3, 5}       // Slice literal
numbers := make([]int, 5)      // make(type, length)
data := make([]string, 0, 10)  // make(type, length, capacity)
 
len(s)                         // Length
cap(s)                         // Capacity
s = append(s, "e", "f")        // Append
copy(c, s)                     // Copy
 
l := s[2:5]                    // Slice s[2], s[3], s[4]
s[:5]                          // Exclude s[5]
s[2:]                          // Include s[2]
a = a[:n-1]                    // Resize length
 
slices.Equal(t, t2)            // Compare slices
 
// Remove element
a = append(a[:2], a[3:]...)    // Second arg must be unpacked with ...
 
// underlying array is copied, so that's why initializing the capacity while compile time is faster
s:=[]int{}                     // len:0 cap:0
s=append(s,1)                  // len:1 cap:1
s=append(s,2,3,4,5)            // len:5 cap:6 <-1+5

a := []int{1, 2, 3}
b := a
a[0] = 4
// b[0] is now 4 - b references the same underlying array!
 
// To create independent copy:
b := make([]int, len(a))
copy(b, a)

s := []int{2, 3, 5, 7, 11, 13}  // len=6 cap=6
s = s[:4]                        // len=4 cap=6 (capacity unchanged)
s = s[2:]                        // len=2 cap=4 (capacity decreases!)

s := []int{2, 3, 5, 7, 11, 13}
s = s[:0]   // len=0 cap=6
s = s[:4]   // len=4 cap=6 - can reslice up to capacity!

// Create 2D slice (n rows, m columns)
a := make([][]int, n)
for i := 0; i < n; i++ {
    a[i] = make([]int, m)
}
 
// Access elements
for i := 0; i < n; i++ {
    for j := 0; j < m; j++ {
        fmt.Scan(&a[i][j])
    }
}
 
len(a)      // Row length
len(a[0])   // Column length

sort.Ints(s)      // Sort integers ascending
sort.Strings(s)   // Sort strings ascending

// Map literal
scores := map[string]int{
    "Bob":   10,
    "Alice": 9,
}
 
m := make(map[string]int)      // Empty map
m := make(map[string]int, n)   // With initial capacity
 
m["k1"] = 7                    // Set value
len(m)                         // Length
delete(m, "k2")                // Delete key/value
clear(m)                       // Remove all key/values
maps.Equal(n, n2)              // Compare maps
 
// Comma-ok idiom
val, ok := m["k2"]             // ok is true if key exists
if val, ok := m["k2"]; ok {
    // key exists
}

type Vertex struct {
    Lat, Long float64
}
 
var m = map[string]Vertex{
    "Bell Labs": {40.68433, -74.39967},
    "Google":    {37.42202, -122.08408},
}

len(s)                         // Length
A[i] == 'a'                    // Check character
A[:len(A)-1]                   // Slice string
runes := []rune(A)             // Convert to mutable rune slice (The standard Go idiom for building or modifying a string is to first convert it to a mutable slice of runes)
 
// String operations
s := "hey this is sk"
s1 := strings.Split(s, " ")    // ["hey", "this", "is", "sk"] slice of strings [hey this is sk] but for A = " hello world " ["", "", "world", "", "", "hello", "", ""]
strings.Fields(A)              // Handles multiple spaces - specifically designed to handle this. It treats one or more consecutive spaces as a single delimiter and automatically ignores any leading or trailing spaces.
strings.Join(A, " ")           // Join with separator (hello world)
strings.Index(A, B)            // Find substring index, gives index of b in a (aabaa, ba, 2)
 
// Range over strings
for i, c := range "go" {
    // i is index, c is rune
}
 
// UTF-8 operations
import "unicode/utf8"
utf8.RuneCountInString(s)      // Count runes, not bytes

var a rune                     // Rune declaration
A := "hello"
fmt.Printf("%d %c\n", A[i], A[i])  // %d = ASCII, %c = character

var p *int     // Pointer to int
i := 10
p = &i         // Address of i
fmt.Println(*p)// Read i through pointer (dereference)
*p = 21        // Set i through pointer

func sliceChange(a []int) {
    a[0] = 99
}
 
a := []int{1, 2, 3}
sliceChange(a)
fmt.Println(a[0])  // 99 - slice is reference type!

package main
import "fmt"
 
type person struct {
    name string
    age  int
}
 
type secretagent struct {
    person  // Nested struct (embedding)
    ltk     bool
}
 
func main() {
    // Struct literal
    p1 := person{
        name: "Joe",
        age:  28,
    }
    fmt.Println(p1)
    fmt.Println(p1.name)
    
    // Nested struct
    sa1 := secretagent{
        person: person{
            name: "James B",
            age:  35,
        },
        ltk: true,
    }
    fmt.Println(sa1)
    fmt.Println(sa1.age)  // Promoted field
    
    // Anonymous struct
    a := struct {
        name string
    }{
        name: "SK",
    }
    fmt.Println(a)
}

p := &person{name: "Alice"}
fmt.Println(p.name)  // Automatic dereference

func newPerson(name string) *person {
    p := person{name: name}
    p.age = 42
    return &p
}
 
func main() {
    fmt.Println(newPerson("Jon"))  // &{Jon 42}
}

type rect struct {
    width, height int
}
 
// Pointer receiver (can modify)
func (r *rect) area() int {
    return r.width * r.height
}
 
// Value receiver (read-only)
func (r rect) perim() int {
    return 2*r.width + 2*r.height
}
 
func main() {
    r := rect{width: 10, height: 5}
    
    fmt.Println("area: ", r.area())    // (&r).area() behind scenes
    fmt.Println("perim:", r.perim())
    
    rp := &r
    fmt.Println("area: ", rp.area())
    fmt.Println("perim:", rp.perim())  // (*rp).perim() behind scenes
}

type circle struct {
    radius float64
}
 
func (c *circle) area() float64 {
    return 3.14 * c.radius * c.radius
}
 
type shape interface {
    area() float64
}
 
func info(s shape) {
    fmt.Println("Area", s.area())
}
 
func main() {
    c := circle{5}
    fmt.Println(c.area())  // Works: compiler adds &
    info(&c)               // Must pass pointer
    // info(c)             // Won't work with interface!
}

type Person struct {
    Name string
    Age  int
}
 
type ByAge []Person
 
func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
 
func main() {
    people := []Person{
        {"Bob", 31},
        {"John", 42},
        {"Michael", 17},
        {"Jenny", 26},
    }
    
    fmt.Println(people)
    // One can define a set of methods for the slice type, as with ByAge, and call sort.Sort.
    sort.Sort(ByAge(people))
    fmt.Println(people)
}

type Engine struct {
    // Engine fields
}
 
func (e *Engine) Start() {
    fmt.Println("Engine started")
}
 
type Car struct {
    Engine  // Embedding
    // Car-specific fields
}
 
func main() {
    car := Car{}
    car.Start()  // Promoted method
}

package main
 
import "fmt"
 
// 1. Define the Interface (The Contract)
type engine interface {
    milesLeft() uint8
}
 
// 2. Define the Concrete Types
type gasEngine struct {
    mpg     uint8
    gallons uint8
}
 
type electricEngine struct {
    mpkwh uint8
    kwh   uint8
}
 
// 3. Implement the methods (implicitly satisfying the interface)
func (e gasEngine) milesLeft() uint8 {
    return e.gallons * e.mpg
}
 
func (e electricEngine) milesLeft() uint8 {
    return e.kwh * e.mpkwh
}
 
// 4. Use the Interface (Polymorphism)
// This function accepts ANY struct that satisfies the 'engine' interface
func canMakeIt(e engine, miles uint8) {
    if miles <= e.milesLeft() {
        fmt.Println("You can make it there!")
    } else {
        fmt.Println("Need to fuel up first!")
    }
}
 
func main() {
    // Create a specific type (electricEngine)
    var myEngine electricEngine = electricEngine{25, 15}
    
    // Pass it to a function expecting an 'engine' interface
    canMakeIt(myEngine, 50)
    
    // We could also pass a gasEngine here and it would work the same way!
}

type Employee struct {
    Name string
    ID   string
}
 
func (e Employee) Display() {
    fmt.Printf("Name: %s, ID: %s\n", e.Name, e.ID)
}
 
type Manager struct {
    Employee  // Embedding (not inheritance!)
    Reports   []string
}
 
func main() {
    m := Manager{
        Employee: Employee{Name: "Alice", ID: "E123"},
        Reports:  []string{"Bob", "Charlie"},
    }
    
    // Because Employee is embedded, we can access its fields and methods directly
    m.Display()  // Prints: Name: Alice, ID: E123
    
    // This LOOKS like inheritance, but it's composition
    // Manager doesn't inherit from Employee; it contains an Employee
}

func describe(i interface{}) {
    fmt.Printf("(%v, %T)\n", i, i)
}
 
func main() {
    var i interface{}
    describe(i)      // (<nil>, <nil>)
    
    i = 42
    describe(i)      // (42, int)
    
    i = "hello"
    describe(i)      // (hello, string)
}

package main
 
import "fmt"
 
func main() {
	var i interface{} = "hello"
 
	s := i.(string) // .(type) ...
	fmt.Println(s)
 
	s, ok := i.(string)
	fmt.Println(s, ok)
 
	f, ok := i.(float64)
	fmt.Println(f, ok)
 
	f = i.(float64) // panic
	fmt.Println(f)
}

import "fmt"
 
func do(i interface{}) {
	switch v := i.(type) {
	case int:
		fmt.Printf("Twice %v is %v\n", v, v*2)
	case string:
		fmt.Printf("%q is %v bytes long\n", v, len(v))
	default:
		fmt.Printf("I don't know about type %T!\n", v)
	}
}
 
func main() {
	do(21)
	do("hello")
	do(true)
}

func Index[T comparable](s []T, x T) int {
    for i, v := range s {
        if v == x {
            return i
        }
    }
    return -1
}
 
func main() {
    si := []int{10, 20, 15, -10}
    fmt.Println(Index(si, 15))  // 2
    
    ss := []string{"foo", "bar", "baz"}
    fmt.Println(Index(ss, "bar"))  // 1
}

// OLD way (no type safety)
type OldList struct {
    next *OldList
    val  any  // Can be anything
}
 
// NEW way (type safe)
type List[T any] struct {
    next *List[T]
    val  T
}

//       1.        2.      3.
type List[T any] struct {
    next *List[T]  // 4.
    val  T         // 5.
}

// Basic constraint
func addT[T int|float64](a, b T) T {
    return a + b
}
 
// Type set interface
type nums interface {
    int | float64
}
 
func addT[T nums](a, b T) T {
    return a + b
}

type nums interface {
    ~int | ~float64  // Includes custom types with int/float64 as underlying type
}
 
func addT[T nums](a, b T) T {
    return a + b
}
 
type blah int
 
func main() {
    var a blah = 10
    fmt.Println(addT(a, 2))  // Works with ~int
}

package main
import (
    "fmt"
    "sync"
    "runtime"
)
 
var wg sync.WaitGroup
 
func foo() {
    for i := 0; i < 3; i++ {
        fmt.Println("foo:", i)
    }
}
 
func bar() {
    for i := 0; i < 3; i++ {
        fmt.Println("bar:", i)
    }
    wg.Done()
}
 
func main() {
    foo()
    wg.Add(1)
    fmt.Println("OS", runtime.GOOS)
    fmt.Println("ARCH", runtime.GOARCH)
    fmt.Println("CPU", runtime.NumCPU())
    fmt.Println("Goroutines", runtime.NumGoroutine())  // 1
    
    go bar()  // Launch goroutine
    
    fmt.Println("Goroutines", runtime.NumGoroutine())  // 2
    wg.Wait()  // Wait for goroutine to finish
}

foo:  0
foo:  1
foo:  2
OS  linux
ARCH  amd64
CPU  1
Goroutines  1
Goroutines  2
bar:  0
bar:  1
bar:  2

package main
 
import (
	"fmt"
	"runtime"
	"sync"
)
 
func main() {
	fmt.Println("Goroutines:", runtime.NumGoroutine())
 
	counter := 0 // shared memory for all goroutines
 
	var wg sync.WaitGroup
	wg.Add(5)
 
	for i := 0; i < 5; i++ {
		go func() { // function literal/anonymous function
			v := counter
			runtime.Gosched() // pause the current goroutine and give another goroutine a chance to run.
			v++
			counter = v
			wg.Done()
		}()
		fmt.Println("Goroutines:", runtime.NumGoroutine())
	}
	wg.Wait()
	fmt.Println("Goroutines:", runtime.NumGoroutine())
	fmt.Println("count:", counter)
}

go run -race main.go # -race will tell you if there is any race condition (Found: 1 data race)
Goroutines: 1
Goroutines: 2
Goroutines: 3
Goroutines: 4
Goroutines: 5
Goroutines: 6
Goroutines: 1
count: 1

func main() {
	fmt.Println("Goroutines:", runtime.NumGoroutine())
 
	counter := 0
 
	var wg sync.WaitGroup
	var mu sync.Mutex
	wg.Add(5)
 
	for i := 0; i < 5; i++ {
		go func() {
		    mu.Lock() // Lock prevents other goroutines from accessing shared memory
			v := counter
			runtime.Gosched() // pause/yield the current goroutine and give another goroutine a chance to run.
			v++
			counter = v
			mu.Unlock()
			wg.Done()
		}()
		fmt.Println("Goroutines:", runtime.NumGoroutine())
	}
	wg.Wait()
	fmt.Println("Goroutines:", runtime.NumGoroutine())
	fmt.Println("count:", counter)
}

Goroutines: 1
Goroutines: 2
Goroutines: 3
Goroutines: 4
Goroutines: 5
Goroutines: 6
Goroutines: 1
count: 5

func main() {
	c:=make(chan int) // unbuffered channel
	c<- 42 // main goroutine blocks here because it's waiting for a receiver 
	fmt.Println(<-c)
}
// deadlock: all goroutines are asleep

func main() {
    c := make(chan int)
    
    go func() {
        c <- 42  // Send
    }()
    
    fmt.Println(<-c)  // Receive
}

func main() {
    c := make(chan int, 1)  // Buffer size 1
    c <- 42                 // Won't block
    fmt.Println(<-c)
}

package main
 
import "fmt"
 
func ping(pings chan<- string, msg string) {
    pings <- msg
}
 
func pong(pings <-chan string, pongs chan<- string) {
    msg := <-pings
    pongs <- msg
}
 
func main() {
    pings := make(chan string, 1)
    pongs := make(chan string, 1)
    ping(pings, "passed message")
    pong(pings, pongs)
    fmt.Println(<-pongs)
}

$ go run channel-directions.go
passed message

func foo(c chan<- int, wg *sync.WaitGroup) {
    for i := 0; i < 5; i++ {
        c <- i
    }
    close(c)  // Must close or deadlock!
    wg.Done()
}
 
func bar(c <-chan int, wg *sync.WaitGroup) {
    for v := range c {  // Reads until closed
        fmt.Println(v)
    }
    wg.Done()
}

func send(odd, even, quit chan<- int) {
    for i := 1; i <= 5; i++ {
        if i%2 == 0 {
            even <- i
        } else {
            odd <- i
        }
    }
    quit <- 0
}
 
func receive(odd, even, quit <-chan int) {
    for {
        select {
            case v := <-odd:
                fmt.Println("Odd:", v)
            case v := <-even:
                fmt.Println("Even:", v)
            case v := <-quit:
                fmt.Println("Quit:", v)
                return
        }
    }
}
 
func main() {
    odd := make(chan int)
    even := make(chan int)
    quit := make(chan int)
    
    go send(odd, even, quit)
    receive(odd, even, quit)
}

func send(odd, even chan<- int) {
    for i := 1; i <= 5; i++ {
        if i%2 == 0 {
            even <- i
        } else {
            odd <- i
        }
    }
    close(even)
    close(odd)
}
 
func receive(odd, even <-chan int, fanin chan<- int) {
    var wg sync.WaitGroup
    wg.Add(2)
    
    go func() {
        for v := range odd {
            fanin <- v
        }
        wg.Done()
    }()
    
    go func() {
        for v := range even {
            fanin <- v
        }
        wg.Done()
    }()
    
    wg.Wait()
    close(fanin)
}
 
func main() {
    odd := make(chan int)
    even := make(chan int)
    fanin := make(chan int)
    
    go send(odd, even)
    go receive(odd, even, fanin)
    
    for v := range fanin {
        fmt.Println(v)
    }
}

c1 := make(chan string, 1)
go func() {
    time.Sleep(2 * time.Second)
    c1 <- "result 1"
}()
 
select {
case res := <-c1:
    fmt.Println(res)
case <-time.After(1 * time.Second):
    fmt.Println("timeout 1")
}

select {
case msg := <-messages:
    fmt.Println("received message", msg)
default:
    fmt.Println("no message received")
}

for i := 1; i <= 5; i++ {
    wg.Go(func() {
        worker(i)
    })
}

requests := make(chan int, 5)
for i := 1; i <= 5; i++ {
    requests <- i
}
close(requests)
limiter := time.Tick(200 * time.Millisecond)
for req := range requests {
    <-limiter
    fmt.Println("request", req, time.Now())
}

func populate(c1 chan<- int) {
    for i := 1; i <= 5; i++ {
        c1 <- i
    }
    close(c1)
}
 
func fanOutIn(c1, c2 chan int) {
    var wg sync.WaitGroup
    
    for v := range c1 {
        wg.Add(1)
        go func(value int) {
            c2 <- doSomething(value)
            wg.Done()
        }(v)
    }
    
    wg.Wait()
    close(c2)
}
 
func doSomething(v int) int {
    return v + 10
}
 
func main() {
    c1 := make(chan int)
    c2 := make(chan int)
    
    go populate(c1)
    go fanOutIn(c1, c2)
    
    for v := range c2 {
        fmt.Println(v)
    }
}

type error interface {
    Error() string
}

// fmt.Println - simple print
fmt.Println(err)
 
// log.Println - prints with date/time
log.Println(err)
 
// log.Fatalln - exits program
log.Fatalln(err)  // Deferred functions do NOT run
 
// log.Panicln - stops current goroutine
log.Panicln(err)  // Deferred functions run
 
// panic - stops normal execution
panic(err)  // Deferred functions run

import (
    "errors"
    "fmt"
)
 
// errors.New
func isTrue(b bool) (bool, error) {
    if !b {
        return false, errors.New("It was False")
    }
    return true, nil
}
 
// fmt.Errorf
func isTrue(b bool) (bool, error) {
    if !b {
        return false, fmt.Errorf("It was False")
    }
    return true, nil
}

type MyError struct {
	When time.Time
	What string
}
 
func (e *MyError) Error() string {
	return fmt.Sprintf("at %v, %s",
		e.When, e.What)
}
 
func run() error {
	return &MyError{
		time.Now(),
		"it didn't work",
	}
}
 
func main() {
	if err := run(); err != nil {
		fmt.Println(err)
	}
}

_, err := fmt.Println("hello")
if err != nil {
    fmt.Println(err)
}

func main() {
    f, err := os.Create("log.txt")
    if err != nil {
        log.Fatal(err)
    }
    defer f.Close()
    
    log.SetOutput(f)
    
    f2, err := os.Open("no-file.txt")
    if err != nil {
        log.Fatalln(err)  // Writes to log.txt and exits
    }
    defer f2.Close()
}

package main
 
import "fmt"
 
func mayPanic() {
    panic("a problem")
}
 
func main() {
 
    defer func() {
        if r := recover(); r != nil {
 
            fmt.Println("Recovered. Error:\n", r)
        }
    }()
 
    mayPanic()
 
    fmt.Println("After mayPanic()")
}

$ go run recover.go
Recovered. Error:
 a problem

// main.go
func sum(a, b int) int {
    return a + b
}
 
// main_test.go
func TestSum(t *testing.T) {
    if sum(2, 3) != 5 {
        t.Error("Expected", 5, "Got", sum(2, 3))
    }
}

go test    
PASS
ok      test    3.459s
--- FAIL: TestSum (0.00s)
    main_test.go:7: Expected 5 Got 6
FAIL
exit status 1
FAIL    test    4.616s

func TestSum(t *testing.T) {
    // Subtest 1: +ve numbers
    t.Run("Positive", func(t *testing.T) {
        if sum(2, 3) != 5 {
            t.Error("Expected 5")
        }
    })
 
    // Subtest 2: -ve numbers
    t.Run("Negative", func(t *testing.T) {
        if sum(-1, -2) != -3 {
            t.Error("Expected -3")
        }
    })
}

type testcase struct {
    data   []int
    answer int
}
 
func TestSum(t *testing.T) {
    tests := []testcase{
        {
            data:   []int{2, 3},
            answer: 5,
        },
        {
            data:   []int{7, 3},
            answer: 10,
        },
    }
    
    for _, tc := range tests {
        result := sum(tc.data[0], tc.data[1])
        if result != tc.answer {
            t.Errorf("Expected %d, got %d", tc.answer, result)
        }
    }
}

var result int
 
func BenchmarkSum(b *testing.B) {
    for i := 0; i < b.N; i++ {
        result = sum(1, 2, 3, 4, 5)
    }
}

go test -bench .
goos: windows
goarch: amd64
pkg: test
cpu: 12th Gen Intel(R) Core(TM) i5-1245U
BenchmarkSum-12    305967357    4.197 ns/op    0 B/op    0 allocs/op
PASS
ok      test    3.106s

go test -cover
PASS
coverage: 80.0% of statements
ok      test    9.639s

go test -coverprofile=coverage.out
go tool cover -html=coverage.out

go fmt ./...         # Format code automatically
go vet ./...         # Report suspicious constructs
golint ./...         # Report poor coding style (install separately)

fmt     // Formatting I/O
math    // Mathematical functions
strings // String manipulation
sort    // Sorting
time    // Time/date operations
os      // OS interface
io      // I/O primitives
bufio   // Buffered I/O
errors  // Error creation
log     // Logging
sync    // Synchronization primitives

math.Floor(x)      // Greatest integer ≤ x
math.Ceil(x)       // Least integer ≥ x
math.Round(x)      // Nearest integer
math.Pow(x, y)     // x^y
math.Pi            // 3.14159265...
math.MinInt64      // -9,223,372,036,854,775,808

strings.Split(s, " ")      // Split string
strings.Fields(s)          // Split on whitespace (handles multiple spaces)
strings.Join(slice, " ")   // Join with separator
strings.Index(s, substr)   // Find substring

func init() {
    if user == "" {
        log.Fatal("$USER not set")
    }
}

var c rune = 'A'
c++  // 'B'
 
// Example pattern
// n=4
// A
// B B
// C C C
// D D D D

godoc -http :8080  # Run local doc server

strs := []string{"c", "a", "b"}
slices.Sort(strs) // Strings: [a b c]

fruits := []string{"peach", "banana", "kiwi"}
 
lenCmp := func(a, b string) int {
    return cmp.Compare(len(a), len(b))
}
 
slices.SortFunc(fruits, lenCmp)
fmt.Println(fruits) // [kiwi peach banana]

// Defined in fmt package
type Stringer interface {
    String() string
}

package main
 
import "fmt"
 
type Person struct {
    Name string
    Age  int
}
 
func (p Person) String() string {
    return fmt.Sprintf("%s (%d years old)", p.Name, p.Age)
}
 
func main() {
    p := Person{Name: "Arthur Dent", Age: 42}
    fmt.Println(p)  // Arthur Dent (42 years old)
}

// Defined in io package
type Writer interface {
    Write(p []byte) (n int, err error)
}

package main
 
import (
    "bytes"
    "fmt"
    "io"
    "log"
    "os"
)
 
type person struct {
    first string
}
 
// writeOut accepts any type that implements io.Writer
func (p person) writeOut(w io.Writer) {
    w.Write([]byte(p.first))
}
 
func main() {
    p := person{
        first: "Jenny",
    }
 
    // Write to a file
    f, err := os.Create("output.txt")
    if err != nil {
        log.Fatalf("error %s", err)
    }
    defer f.Close()
 
    // Write to a buffer
    var b bytes.Buffer
 
    // Same method works with both file and buffer!
    p.writeOut(f)      // Writes to file
    p.writeOut(&b)     // Writes to buffer
    fmt.Println(b.String())  // Prints: Jenny
}

argsWithProg := os.Args // os.Args provides access to raw command-line arguments. Note that the first value in this slice is the path to the program.
argsWithoutProg := os.Args[1:] // holds the arguments to the program

$ go build command-line-arguments.go
$ ./command-line-arguments a b c d
[./command-line-arguments a b c d]       
[a b c d]

wordPtr := flag.String("word", "foo", "a string") // string flag word with a default value "foo" and a short description.
 
numbPtr := flag.Int("numb", 42, "an int")
forkPtr := flag.Bool("fork", false, "a bool")
 
var svar string
flag.StringVar(&svar, "svar", "bar", "a string var")
 
flag.Parse() // to execute the command-line parsing.
 
fmt.Println("word:", *wordPtr)
fmt.Println("numb:", *numbPtr)
fmt.Println("fork:", *forkPtr)
fmt.Println("svar:", svar)
fmt.Println("tail:", flag.Args())
 
// Command-Line Subcommands
fooCmd := flag.NewFlagSet("foo", flag.ExitOnError)
fooEnable := fooCmd.Bool("enable", false, "enable")

$ ./command-line-flags -word=opt -numb=7 -fork -svar=flag a1 a2 # Trailing positional arguments can be provided after any flags.
word: opt
numb: 7
fork: true
svar: flag
tail: [a1, a2]
 
$ ./command-line-subcommands foo -enable a1 a2 -name=joe # flag package requires all flags to appear before positional arguments (otherwise the flags will be interpreted as positional arguments).
subcommand 'foo'
  enable: true
  tail: [a1 a2 -name=joe]

os.Setenv("FOO", "1")
fmt.Println("FOO:", os.Getenv("FOO"))
fmt.Println("BAR:", os.Getenv("BAR")) // This will return an empty string if the key isn't present in the environment.
 
fmt.Println()
for _, e := range os.Environ() { // list all key/value pairs in the environment. This returns a slice of strings in the form KEY=value.
    pair := strings.SplitN(e, "=", 2)
    fmt.Println(pair[0])
}