package main

import (
    "bytes"
    "fmt"
    "sync"
)

func main() {
    // 1. Basic Types
    // Variables declared without initialization get a default "zero value".
    var i int
    var f float64
    var b bool
    var s string
    
    // Prints: 0, 0, false, "" (empty string)
    fmt.Printf("int: %d, float: %f, bool: %t, string: %q\n", i, f, b, s)

    // 2. Pointers and Reference Types
    // The zero value is 'nil' for pointers, slices, maps, channels, interfaces, and functions.
    var ptr *int
    var slc []int
    var mp map[string]int
    
    fmt.Println("pointer is nil:", ptr == nil)
    fmt.Println("slice is nil:", slc == nil)
    fmt.Println("map is nil:", mp == nil)

    // 3. "Make the zero value useful"
    // Many Go types are designed to be used without explicit initialization.
    
    // Example A: sync.Mutex
    // A zero-value Mutex is an unlocked mutex. You don't need "NewMutex()".
    var mu sync.Mutex
    mu.Lock()
    fmt.Println("Mutex locked successfully")
    mu.Unlock()

    // Example B: bytes.Buffer
    // A zero-value Buffer is an empty buffer ready to write to.
    var buf bytes.Buffer
    buf.WriteString("Hello, Zero Value!")
    fmt.Println(buf.String())
    
    // Example C: Slices
    // A nil slice is functionally equivalent to an empty slice for most operations.
    // You can append to it without 'make'.
    var names []string
    names = append(names, "Alice")
    fmt.Println("Appended to nil slice:", names)
}