09 — Structs

// Structs are comparable with == ONLY if all fields are comparable.
// Slices, maps, and functions are NOT comparable — a struct containing
// them can't use ==.

type Point struct{ X, Y int }
p1 := Point{1, 2}
p2 := Point{1, 2}
fmt.Println(p1 == p2)  // true — all fields comparable

type WithSlice struct {
    Name string
    Tags []string  // slice — not comparable
}
// w1 == w2  // compile error: struct containing []string cannot be compared

// ✅ Use reflect.DeepEqual for structs with non-comparable fields:
import "reflect"
w1 := WithSlice{Name: "a", Tags: []string{"x"}}
w2 := WithSlice{Name: "a", Tags: []string{"x"}}
fmt.Println(reflect.DeepEqual(w1, w2))  // true

// ⚠️ reflect.DeepEqual is slow (reflection + recursion). For hot paths,
// implement a custom Equals method:
func (w WithSlice) Equals(other WithSlice) bool {
    if w.Name != other.Name { return false }
    return slices.Equal(w.Tags, other.Tags)
}

// Comparable structs can be MAP KEYS:
m := map[Point]string{{0, 0}: "origin", {1, 1}: "diagonal"}

💡 Tips & Tricks

• Performance: order struct fields from largest to smallest (int64 before bool) to minimize padding. Use the fieldalignment linter to detect wasted space. For hot-path structs (one per request), saving 8-16 bytes × millions of requests = significant memory.
• Idiom: design zero values to be usable (sync.Mutex{}, bytes.Buffer{}, Counter{}) — eliminates constructor boilerplate. Reserve constructors for required fields that have no sensible zero value (DSN, API keys).
• Idiom: use named-field literals (User{ID: 1, Name: "Alice"}) — they're robust to field additions and self-documenting. Positional literals break silently when a field is inserted in the middle.
• Idiom: embed interfaces for decoration (type LoggingService struct { Logger; inner Service }) — the embedded interface promotes its methods, letting the outer struct delegate or wrap.
• Idiom: use struct{} as the map value for sets — map[string]struct{} uses 0 bytes per entry (vs 1 byte for bool). For large sets, this saves meaningful memory.
• Safety: reflect.DeepEqual is slow and can be surprising (it compares unexported fields too). For production code, implement a custom Equals method using slices.Equal for slice fields.

⚠️ Edge Cases & Gotchas

• Field order affects struct size: padding between misaligned fields wastes memory. struct{ a bool; b int64 } = 16 bytes; struct{ b int64; a bool } = 12 bytes (with 4 trailing padding to align to 8). Use fieldalignment to optimize.
• Embedding promotes fields AND methods: d.X and d.Speak() both work. If the outer struct defines a method with the same name, it shadows (not overrides) — no virtual dispatch.
• Embedding a pointer: type S struct { *T } leaves the field as nil unless initialized. Promoted method calls on a nil embedded pointer panic. Initialize in the literal or constructor.
• Ambiguous embedding: embedding two types with the same field/method name → c.X is a compile error. Disambiguate with c.A.X / c.B.X.
• Embedding is not inheritance: a Dog embedding Animal is not an Animal for interface purposes. Embedding is composition; interfaces provide polymorphism.
• Positional literals break on field insertion: Point{1, 2} still compiles if you add Z int (it gets 0), but the intent is lost. Named literals survive.
• Struct with non-comparable fields can't use ==: a struct with a slice/map/func field can't be compared with == (compile error). Use reflect.DeepEqual or a custom method.
• struct{} is 0 bytes: all struct{}{} values may share the same address. Don't take &struct{}{} and compare addresses — they may be equal even for "different" values.
• Struct tags are raw strings: the json:"x" db:"y" format is a convention. go vet checks json tag syntax but not custom tags. Malformed tags are silently ignored by the consuming package.
• omitempty checks for zero value: json:"x,omitempty" omits the field if it's 0, "", false, or nil. For a field where 0 is a valid value, omitempty will incorrectly omit it — use a *int (nil = omit, 0 = include).

🧠 Quick Quiz

type S struct {
    A int64
    B bool
    C int64
    D bool
}
type T struct {
    A int64
    C int64
    B bool
    D bool
}
fmt.Println(unsafe.Sizeof(S{}), unsafe.Sizeof(T{}))