Zero Values — Optimization Exercises¶

package main

import "fmt"

type GameState struct {
    Score    int
    Lives    int
    Level    int
    Paused   bool
    GameOver bool
    Player   string
    Inventory []string
    Bonuses   []int
}

func newGame(playerName string) GameState {
    return GameState{
        Lives:  3,           // explicitly non-zero
        Level:  1,           // explicitly non-zero
        Player: playerName,  // explicitly set
        // Score:     0     → omit (zero value is correct)
        // Paused:    false  → omit (zero value is correct)
        // GameOver:  false  → omit (zero value is correct)
        // Inventory: nil   → omit (nil slice works with append)
        // Bonuses:   nil   → omit (nil slice works with append)
    }
}

func main() {
    state := newGame("Alice")
    fmt.Printf("Score: %d, Lives: %d, Level: %d\n",
        state.Score, state.Lives, state.Level)
}

package main

import (
    "fmt"
    "sync"
)

// SafeString is a thread-safe string wrapper.
// Zero value is an empty string. No constructor needed.
// A SafeString must not be copied after first use.
type SafeString struct {
    mu  sync.Mutex  // value type — zero = unlocked, ready to use
    val string
}

func (s *SafeString) Set(val string) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.val = val
}

func (s *SafeString) Get() string {
    s.mu.Lock()
    defer s.mu.Unlock()
    return s.val
}

func main() {
    // No constructor needed!
    var s SafeString
    s.Set("hello")
    s.Set("world")
    fmt.Println(s.Get())  // world

    // Or with initial value directly:
    s2 := SafeString{val: "initial"}
    fmt.Println(s2.Get())  // initial
}

package main

import (
    "fmt"
    "sync"
)

// Counter is a thread-safe named counter.
// Zero value is immediately usable.
// A Counter must not be copied after first use.
type Counter struct {
    mu    sync.Mutex      // value type, zero = unlocked
    count map[string]int64 // nil map — initialized lazily
}

func (c *Counter) Inc(key string) {
    c.mu.Lock()
    defer c.mu.Unlock()
    if c.count == nil {
        c.count = make(map[string]int64)
    }
    c.count[key]++
}

func (c *Counter) Get(key string) int64 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count[key]  // safe: nil map read returns 0
}

func main() {
    var c Counter  // no constructor needed
    c.Inc("requests")
    c.Inc("requests")
    c.Inc("errors")
    fmt.Println(c.Get("requests"), c.Get("errors"))  // 2 1
}

package main

import (
    "bytes"
    "fmt"
)

func buildQuery(params map[string]string) string {
    var buf bytes.Buffer  // zero value = empty buffer, ready to use!
    first := true
    for k, v := range params {
        if !first {
            buf.WriteByte('&')
        }
        buf.WriteString(k)
        buf.WriteByte('=')
        buf.WriteString(v)
        first = false
    }
    return buf.String()
}

// HTMLBuilder uses bytes.Buffer zero value pattern.
// Zero value of HTMLBuilder is ready to use.
// An HTMLBuilder must not be copied after first use.
type HTMLBuilder struct {
    buf bytes.Buffer  // value type, zero = empty buffer
}

func (h *HTMLBuilder) Tag(name, content string) *HTMLBuilder {
    fmt.Fprintf(&h.buf, "<%s>%s</%s>", name, content, name)
    return h
}

func (h *HTMLBuilder) Build() string {
    return h.buf.String()
}

func main() {
    q := buildQuery(map[string]string{"a": "1", "b": "2"})
    fmt.Println(q)

    var html HTMLBuilder
    html.Tag("h1", "Hello").Tag("p", "World")
    fmt.Println(html.Build())
    // <h1>Hello</h1><p>World</p>
}

package main

import (
    "fmt"
    "sync"
)

// MetricsService tracks application metrics.
// Zero value is immediately usable.
// Metrics maps are initialized lazily — only when first used.
type MetricsService struct {
    mu       sync.Mutex
    counters map[string]int64
    gauges   map[string]float64
    timers   map[string][]int64
}

func (m *MetricsService) IncrCounter(name string) {
    m.mu.Lock()
    defer m.mu.Unlock()
    if m.counters == nil {
        m.counters = make(map[string]int64)
    }
    m.counters[name]++
}

func (m *MetricsService) GetCounter(name string) int64 {
    m.mu.Lock()
    defer m.mu.Unlock()
    return m.counters[name]  // safe: nil map read = 0
}

func (m *MetricsService) SetGauge(name string, val float64) {
    m.mu.Lock()
    defer m.mu.Unlock()
    if m.gauges == nil {
        m.gauges = make(map[string]float64)
    }
    m.gauges[name] = val
}

func (m *MetricsService) RecordTimer(name string, ms int64) {
    m.mu.Lock()
    defer m.mu.Unlock()
    if m.timers == nil {
        m.timers = make(map[string][]int64)
    }
    m.timers[name] = append(m.timers[name], ms)
}

func main() {
    var svc MetricsService  // no constructor needed
    svc.IncrCounter("requests")
    svc.IncrCounter("requests")
    fmt.Println(svc.GetCounter("requests"))  // 2
    // gauges and timers maps never allocated (not used)
}

package main

import "fmt"

// findFirst returns the first element matching predicate.
// Returns (value, true) if found, (0, false) if not found.
// Uses Go's comma-ok idiom — no allocation.
func findFirst(items []int, pred func(int) bool) (int, bool) {
    for _, item := range items {
        if pred(item) {
            return item, true  // no heap allocation!
        }
    }
    return 0, false  // zero value of int, false = not found
}

func main() {
    items := []int{1, 2, 3, 4, 5}

    v, found := findFirst(items, func(x int) bool { return x > 3 })
    if !found {
        fmt.Println("Not found")
        return
    }
    fmt.Println("Found:", v)  // Found: 4

    // Not found case:
    v2, found2 := findFirst(items, func(x int) bool { return x > 10 })
    fmt.Println("v2:", v2, "found:", found2)  // v2: 0 found: false
}

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

// Config loads settings once and provides thread-safe access.
// Zero value is usable — settings are loaded on first Get.
type Config struct {
    once     sync.Once
    mu       sync.Mutex
    settings map[string]string
    // loaded bool  ← REMOVED: redundant with sync.Once
}

func (c *Config) load() {
    c.once.Do(func() {
        c.settings = map[string]string{
            "host": "localhost",
            "port": "8080",
        }
    })
}

func (c *Config) Get(key string) string {
    c.load()  // once.Do ensures this runs only once
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.settings[key]
}

// If you truly need IsLoaded, use atomic:
type ConfigV2 struct {
    once     sync.Once
    loaded   atomic.Bool  // atomic.Bool zero value = false
    mu       sync.Mutex
    settings map[string]string
}

func (c *ConfigV2) load() {
    c.once.Do(func() {
        c.settings = map[string]string{"host": "localhost"}
        c.loaded.Store(true)  // atomic write
    })
}

func (c *ConfigV2) IsLoaded() bool {
    return c.loaded.Load()  // atomic read, no mutex needed
}

func main() {
    var cfg Config
    fmt.Println("Host:", cfg.Get("host"))  // lazy load on first access
    fmt.Println("Port:", cfg.Get("port"))  // returns from cache
}

package main

import (
    "fmt"
    "strings"
)

// searchUsers returns matching users, or nil if none found.
// Callers should use len(results) == 0 to check for no results.
func searchUsers(users []string, query string) []string {
    var results []string  // nil slice — no allocation until first match

    lq := strings.ToLower(query)
    for _, u := range users {
        if strings.Contains(strings.ToLower(u), lq) {
            results = append(results, u)  // allocates on first match
        }
    }

    return results  // nil if no matches, slice if some matches
}

func main() {
    users := []string{"Alice", "Bob", "Charlie", "David"}

    found := searchUsers(users, "ali")
    fmt.Println("Found:", found)         // [Alice]

    notFound := searchUsers(users, "xyz")
    fmt.Println("Not found:", notFound)  // []
    fmt.Println("Is nil:", notFound == nil)  // true — no allocation!

    // Correct check (works for both nil and empty):
    if len(notFound) == 0 {
        fmt.Println("No results")
    }
}

package main

import (
    "fmt"
    "strings"
)

// TextProcessor splits and transforms text.
// Zero value uses "," as separator and performs no transformations.
// Use as value type (no pointer needed for most cases).
type TextProcessor struct {
    Separator   string  // "" = use "," (zero value normalized in Process)
    TrimSpaces  bool
    ToLowerCase bool
    MaxLength   int     // 0 = no limit
}

func (p TextProcessor) Process(text string) []string {
    sep := p.Separator
    if sep == "" {
        sep = ","  // normalize zero value
    }

    parts := strings.Split(text, sep)
    var result []string
    for _, part := range parts {
        if p.TrimSpaces {
            part = strings.TrimSpace(part)
        }
        if p.ToLowerCase {
            part = strings.ToLower(part)
        }
        if p.MaxLength > 0 && len(part) > p.MaxLength {
            part = part[:p.MaxLength]
        }
        if part != "" {
            result = append(result, part)
        }
    }
    return result
}

func main() {
    // Zero value usable directly:
    var p TextProcessor
    result := p.Process("hello,world,go")
    fmt.Println(result)  // [hello world go]

    // Struct literal (no constructor needed):
    p2 := TextProcessor{TrimSpaces: true}
    result2 := p2.Process("hello , world , go")
    fmt.Println(result2)  // [hello world go]

    // Value semantics (no pointer):
    p3 := TextProcessor{Separator: "|", ToLowerCase: true}
    result3 := p3.Process("Hello|World|Go")
    fmt.Println(result3)  // [hello world go]
}

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

// TaskRunner runs functions concurrently and waits for completion.
// Zero value is immediately usable.
// A TaskRunner must not be copied after first use.
type TaskRunner struct {
    wg       sync.WaitGroup  // value type — zero = no goroutines pending
    taskCount atomic.Int64   // atomic: no mutex needed for reads
}

func (r *TaskRunner) Run(f func()) {
    r.wg.Add(1)
    r.taskCount.Add(1)
    go func() {
        defer r.wg.Done()
        f()
    }()
}

func (r *TaskRunner) Wait() {
    r.wg.Wait()
}

func (r *TaskRunner) TaskCount() int64 {
    return r.taskCount.Load()
}

func main() {
    var runner TaskRunner  // no constructor needed!

    results := make([]string, 3)
    for i := 0; i < 3; i++ {
        i := i
        runner.Run(func() {
            results[i] = fmt.Sprintf("task-%d", i)
        })
    }

    runner.Wait()
    fmt.Println("Tasks run:", runner.TaskCount())  // 3
    fmt.Println("Results:", results)
}

package main

import "fmt"

// doubleAll: output size = input size — pre-allocate
func doubleAll(nums []int) []int {
    if len(nums) == 0 {
        return nil  // zero case: return nil (idiomatic)
    }
    result := make([]int, len(nums))  // exact size known: no reallocation
    for i, n := range nums {
        result[i] = n * 2  // direct index assignment (faster than append)
    }
    return result
}

// zipCombine: output size = min(len(a), len(b)) — pre-allocate
func zipCombine(a, b []int) []string {
    min := len(a)
    if len(b) < min {
        min = len(b)
    }
    if min == 0 {
        return nil  // zero case
    }
    result := make([]string, 0, min)  // pre-allocate capacity
    for i := 0; i < min; i++ {
        result = append(result, fmt.Sprintf("%d:%d", a[i], b[i]))
    }
    return result
}

// For filtering (size unknown): nil slice is correct
func filterPositive(nums []int) []int {
    var result []int  // size unknown: nil slice is appropriate
    for _, n := range nums {
        if n > 0 {
            result = append(result, n)
        }
    }
    return result
}

func main() {
    nums := make([]int, 10000)
    for i := range nums {
        nums[i] = i
    }

    doubled := doubleAll(nums)
    fmt.Println(len(doubled))  // 10000

    a := []int{1, 2, 3}
    b := []int{4, 5, 6, 7}
    combined := zipCombine(a, b)
    fmt.Println(combined)  // [1:4 2:5 3:6]
}