11 — Methods & Receivers

type Request struct {
    method  string
    url     string
    headers map[string]string
    body    []byte
    timeout time.Duration
}

type RequestBuilder struct {
    req Request
}

// Pointer receiver — mutates the builder, returns the builder for chaining:
func (b *RequestBuilder) Method(m string) *RequestBuilder {
    b.req.method = m
    return b  // return the builder for fluent chaining
}

func (b *RequestBuilder) URL(u string) *RequestBuilder {
    b.req.url = u
    return b
}

func (b *RequestBuilder) Header(k, v string) *RequestBuilder {
    if b.req.headers == nil {
        b.req.headers = make(map[string]string)
    }
    b.req.headers[k] = v
    return b
}

func (b *RequestBuilder) Timeout(d time.Duration) *RequestBuilder {
    b.req.timeout = d
    return b
}

func (b *RequestBuilder) Build() Request {
    return b.req
}

// Usage — fluent, readable, type-safe:
req := (&RequestBuilder{}).
    Method("POST").
    URL("https://api.example.com/users").
    Header("Content-Type", "application/json").
    Header("Authorization", "Bearer "+token).
    Timeout(30 * time.Second).
    Build()

💡 Tips & Tricks

• Idiom: consistent receivers — if ANY method has a pointer receiver, ALL methods should. Mixing causes method-set confusion (a value doesn't satisfy interfaces requiring pointer-receiver methods) and is flagged by linters.
• Idiom: use value receivers for small, immutable types (Point, Time, Celsius) — copies are cheap and immutability is a feature. Use pointer receivers for large structs or when mutation is needed.
• Idiom: nil receiver methods enable the null-object pattern — func (t *Tree) Find(x int) bool { if t == nil { return false }; ... }. This eliminates nil-checking at every call site, making tree traversal code clean.
• Idiom: receiver names should be short and consistent — func (c Circle) Area(), func (c *Circle) Scale(). Use the same receiver name across all methods of a type. gofmt aligns them.
• Debug: var i Interface = T{} failing with "does not implement Interface (method X has pointer receiver)" means a method is on *T but you're using a value — use &T{} or change the receiver to value.
• Performance: value receivers copy the receiver — for large structs, this is expensive. For small structs (≤ 64 bytes), the copy is cheaper than the pointer indirection (cache locality, no escape).

⚠️ Edge Cases & Gotchas

• Value receiver can't mutate: func (c Circle) Scale() modifies a copy — the original is unchanged. Use *Circle for mutation.
• Pointer receiver on unaddressable value: Counter{}.Inc() (pointer receiver) fails — the literal isn't addressable. Use a variable: c := Counter{}; c.Inc().
• Method set and interfaces: a value type doesn't satisfy interfaces requiring pointer-receiver methods. This is the most common "doesn't implement interface" confusion.
• Pointer-receiver method on map value: m[key].Method() fails if Method is pointer-receiver (map values aren't addressable). Use map[K]*V or copy-out-modify-assign-back.
• No virtual dispatch: shadowing a promoted method is resolved at compile time by the static type, not at runtime. This differs from Java/C++ virtual methods.
• Methods on non-struct named types: type MyInt int; func (m MyInt) IsEven() bool — works. But not on predeclared types (int, string) or unnamed types ([]int).
• Nil receiver panic on value receiver: a value-receiver method called on a nil *T panics (Go tries to dereference nil to copy the value). Only pointer-receiver methods can handle nil.
• fmt doesn't call String() on nested values: fmt.Println(map[int]User{}) prints map[1:{Alice}], not User: Alice — fmt calls String() on the top-level value, not on elements inside containers.

🧠 Quick Quiz

type Counter struct{ n int }
func (c Counter) Value() int { return c.n }
func (c *Counter) Inc() { c.n++ }

func main() {
    c := Counter{}
    c.Inc()
    c.Inc()
    fmt.Println(c.Value())
}