Methods and Receivers

package main

import (
	"fmt"
	"strings"
)

type Author struct{ Name string }

type Book struct {
	Title   string
	Authors []Author
	Pages   int
}

// Summary has a value receiver: it gets its own copy of the Book.
func (b Book) Summary() string {
	names := make([]string, 0, len(b.Authors))
	for _, a := range b.Authors {
		names = append(names, a.Name)
	}
	return fmt.Sprintf("%s by %s (%d pages)", b.Title, strings.Join(names, ", "), b.Pages)
}

// Retitle has a pointer receiver: it can change the caller's Book.
func (b *Book) Retitle(t string) { b.Title = t }

func main() {
	b := Book{Title: "Dune", Authors: []Author{{"Frank Herbert"}}, Pages: 412}
	fmt.Println(b.Summary())
	b.Retitle("Dune (reissue)") // b is addressable: the compiler writes (&b).Retitle(...)
	fmt.Println(b.Summary())

	p := &b
	fmt.Println(p.Summary()) // the compiler writes (*p).Summary()
}

Dune by Frank Herbert (412 pages)
Dune (reissue) by Frank Herbert (412 pages)
Dune (reissue) by Frank Herbert (412 pages)

package main

import "fmt"

type Counter struct{ n int }

func (c Counter) IncValue()    { c.n++ } // increments a copy
func (c *Counter) IncPointer() { c.n++ } // increments the original

func main() {
	var c Counter
	c.IncValue()
	c.IncValue()
	fmt.Println("after IncValue x2:  ", c.n)
	c.IncPointer()
	c.IncPointer()
	fmt.Println("after IncPointer x2:", c.n)
}

after IncValue x2:   0
after IncPointer x2: 2

package main

import (
	"fmt"
	"reflect"
)

type Book struct{ Title string }

func (b Book) Summary() string      { return b.Title }
func (b Book) Short() string        { return b.Title[:1] }
func (b *Book) Retitle(t string)    { b.Title = t }
func (b *Book) Reset()              { b.Title = "" }
func (b *Book) Both(t string) error { b.Title = t; return nil }

func names(t reflect.Type) []string {
	var out []string
	for m := range t.Methods() {
		out = append(out, m.Name)
	}
	return out
}

func main() {
	fmt.Println("method set of Book:  ", names(reflect.TypeFor[Book]()))
	fmt.Println("method set of *Book: ", names(reflect.TypeFor[*Book]()))
}

method set of Book:   [Short Summary]
method set of *Book:  [Both Reset Retitle Short Summary]

package main

import (
	"fmt"
	"reflect"
)

type E struct{}

func (E) ByValue()    {}
func (*E) ByPointer() {}

type Embeds struct{ E }     // embeds E
type EmbedsPtr struct{ *E } // embeds *E

func names(t reflect.Type) []string {
	var out []string
	for m := range t.Methods() {
		out = append(out, m.Name)
	}
	return out
}

func main() {
	fmt.Println("Embeds:      ", names(reflect.TypeFor[Embeds]()))
	fmt.Println("*Embeds:     ", names(reflect.TypeFor[*Embeds]()))
	fmt.Println("EmbedsPtr:   ", names(reflect.TypeFor[EmbedsPtr]()))
	fmt.Println("*EmbedsPtr:  ", names(reflect.TypeFor[*EmbedsPtr]()))
}

Embeds:       [ByValue]
*Embeds:      [ByPointer ByValue]
EmbedsPtr:    [ByPointer ByValue]
*EmbedsPtr:   [ByPointer ByValue]

package main

import "fmt"

type Book struct{ Title string }

func (b *Book) Retitle(t string) { b.Title = t }

func newBook() Book { return Book{Title: "Emma"} }

func main() {
	newBook().Retitle("Persuasion")
	books := map[string]Book{"emma": {Title: "Emma"}}
	books["emma"].Retitle("Persuasion")
	fmt.Println(books)
}

main.go:12:12: cannot call pointer method Retitle on Book
main.go:14:16: cannot call pointer method Retitle on Book

package main

import "fmt"

type Base struct{ ID int }

func (b Base) Describe() string { return fmt.Sprintf("base %d", b.ID) }
func (b *Base) SetID(id int)    { b.ID = id }

type Loan struct {
	Base
	Member string
}

// Loan overrides nothing: it declares its own method with the same name,
// which shadows the promoted one (embedding is not inheritance).
func (l Loan) Describe() string { return "loan of " + l.Member + " / " + l.Base.Describe() }

func main() {
	l := Loan{Base{1}, "ada"}
	l.SetID(7) // promoted pointer method; l is addressable
	fmt.Println(l.Describe())
	fmt.Println(l.Base.Describe())
}

loan of ada / base 7
base 7

package main

import "fmt"

type Author struct{ Name string }

// DisplayName treats a nil *Author as "anonymous" instead of crashing.
func (a *Author) DisplayName() string {
	if a == nil {
		return "anonymous"
	}
	return a.Name
}

// Initial dereferences the receiver without checking.
func (a *Author) Initial() string { return a.Name[:1] }

// Plain has a value receiver.
func (a Author) Plain() string { return a.Name }

// Node is a linked list of titles whose methods accept the empty list (nil).
type Node struct {
	Title string
	Next  *Node
}

func (n *Node) Len() int {
	if n == nil {
		return 0
	}
	return 1 + n.Next.Len()
}

func try(label string, f func() string) {
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("%s: panic: %v\n", label, r)
		}
	}()
	fmt.Printf("%s: %s\n", label, f())
}

func main() {
	var a *Author
	fmt.Println(a.DisplayName())
	a = &Author{Name: "Ursula K. Le Guin"}
	fmt.Println(a.DisplayName(), a.Initial())

	var list *Node
	fmt.Println("empty list:", list.Len())
	list = &Node{"Dune", &Node{"Emma", nil}}
	fmt.Println("two nodes: ", list.Len())

	var missing *Author
	try("pointer method, no nil check", missing.Initial)
	try("value method through nil pointer", func() string { return missing.Plain() })
}

anonymous
Ursula K. Le Guin U
empty list: 0
two nodes:  2
pointer method, no nil check: panic: runtime error: invalid memory address or nil pointer dereference
value method through nil pointer: panic: runtime error: invalid memory address or nil pointer dereference

package main

import "fmt"

type Counter struct{ n int }

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

func main() {
	c := &Counter{}

	val := c.Value // method value: receiver *c is copied NOW
	inc := c.Inc   // method value: receiver &c is bound, so it sees the original
	inc()
	inc()
	fmt.Println("bound Value:", val(), " live Value:", c.Value())

	// Method expressions: the receiver becomes the first parameter.
	f := Counter.Value  // func(Counter) int
	g := (*Counter).Inc // func(*Counter)
	g(c)
	fmt.Println("expression:", f(*c))
	fmt.Printf("%T\n%T\n", f, g)

	// (*T).Method also exists for value methods.
	h := (*Counter).Value // func(*Counter) int
	fmt.Println(h(c))
}

bound Value: 0  live Value: 2
expression: 3
func(main.Counter) int
func(*main.Counter)
3

package main

import (
	"fmt"
	"strings"
)

type Store interface {
	Len() int
	Put(string)
}

type memStore struct{ titles []string }

func (m *memStore) Len() int     { return len(m.titles) }
func (m *memStore) Put(t string) { m.titles = append(m.titles, t) }

func main() {
	// Method expression on an interface type: the receiver is the first argument.
	length := Store.Len // func(Store) int
	var s Store = &memStore{}
	s.Put("Dune")
	fmt.Println(length(s))
	fmt.Printf("%T\n", length)

	// Method value from an interface value: bound to the dynamic value at evaluation time.
	put := s.Put
	put("Emma")
	fmt.Println(s.Len())

	// A common real use: passing a method value where a func is expected.
	r := strings.NewReplacer("a", "4", "e", "3")
	titles := []string{"banana", "emma"}
	fmt.Println(strings.Join(mapStrings(titles, r.Replace), ", "))
}

func mapStrings(in []string, f func(string) string) []string {
	out := make([]string, len(in))
	for i, s := range in {
		out[i] = f(s)
	}
	return out
}

1
func(main.Store) int
2
b4n4n4, 3mm4

package main

import "fmt"

type Counter struct{ n int }

func (c Counter) Show(label string)    { fmt.Println(label, c.n) }
func (c *Counter) Report(label string) { fmt.Println(label, c.n) }
func (c *Counter) Inc()                { c.n++ }

func main() {
	c := Counter{}

	// defer evaluates the receiver and the arguments immediately: a value
	// receiver is copied here, so the later increments are not seen.
	defer c.Show("deferred value method:")
	// A pointer-receiver call binds &c, so it sees the final value.
	defer c.Report("deferred pointer method:")

	c.Inc()
	c.Inc()
	c.Show("end of main:")

	// A method value is an ordinary func value and can be stored.
	handlers := []func(){c.Inc, c.Inc}
	for _, h := range handlers {
		h()
	}
	c.Show("after handlers:")
}

end of main: 2
after handlers: 4
deferred pointer method: 4
deferred value method: 0

package main

import "fmt"

type Store interface{ Len() int }

type Author struct{ Name string }

func (a Author) Plain() string { return a.Name }

func try(label string, f func()) {
	defer func() { fmt.Printf("%s: recovered: %v\n", label, recover()) }()
	f()
}

func main() {
	try("method value from a nil interface", func() {
		var s Store
		f := s.Len // evaluated here, not when f is called
		_ = f
	})
	try("value-method value through a nil pointer", func() {
		var p *Author
		f := p.Plain // copies *p now, so it dereferences nil now
		_ = f
	})
}

method value from a nil interface: recovered: runtime error: invalid memory address or nil pointer dereference
value-method value through a nil pointer: recovered: runtime error: invalid memory address or nil pointer dereference

package main

import (
	"fmt"
	"math"
	"sort"
	"strings"
)

type Celsius float64

func (c Celsius) Fahrenheit() float64 { return float64(c)*9/5 + 32 }
func (c Celsius) String() string      { return fmt.Sprintf("%.1f°C", float64(c)) }

// Titles is a defined slice type; methods can be attached to it.
type Titles []string

func (t Titles) Sorted() Titles {
	out := append(Titles(nil), t...)
	sort.Strings(out)
	return out
}

func (t *Titles) Add(s string) { *t = append(*t, s) }

// Tags is a defined map type.
type Tags map[string]int

func (t Tags) Count(tag string) int { return t[tag] }

// Handler is satisfied by anything with Serve; HandlerFunc lets a plain
// function be one, the same trick net/http uses.
type Handler interface{ Serve(q string) string }

type HandlerFunc func(string) string

func (f HandlerFunc) Serve(q string) string { return f(q) }

func main() {
	c := Celsius(21.5)
	fmt.Println(c, c.Fahrenheit(), math.Round(c.Fahrenheit()))

	var t Titles
	t.Add("Emma")
	t.Add("Dune")
	fmt.Println(t, t.Sorted())

	tags := Tags{"scifi": 3}
	fmt.Println(tags.Count("scifi"), tags.Count("poetry"))

	var h Handler = HandlerFunc(strings.ToUpper)
	fmt.Println(h.Serve("dune"))
}

21.5°C 70.7 71
[Emma Dune] [Dune Emma]
3 0
DUNE

package main

import (
	"fmt"
	"sync"
)

type Registry struct {
	mu    sync.Mutex
	count int
}

// Wrong: the value receiver copies the mutex on every call.
func (r Registry) Count() int {
	r.mu.Lock()
	defer r.mu.Unlock()
	return r.count
}

func main() {
	r := &Registry{count: 3}
	fmt.Println(r.Count())
}

main.go:14:9: Count passes lock by value: example.com/shelf/e11.Registry contains sync.Mutex

package main

import (
	"fmt"
	"strconv"
)

// Stack is a generic type: its methods repeat the type parameter in the
// receiver but cannot add type parameters of their own... until Go 1.27.
type Stack[T any] struct{ items []T }

func (s *Stack[T]) Push(v T) { s.items = append(s.items, v) }

func (s *Stack[T]) Len() int { return len(s.items) }

// Go 1.27: a method may declare its own type parameters.
func (s *Stack[T]) Map[U any](f func(T) U) *Stack[U] {
	out := &Stack[U]{}
	for _, v := range s.items {
		out.Push(f(v))
	}
	return out
}

type Shelf struct{ titles []string }

func (s *Shelf) Convert[T any](f func(string) T) []T {
	var out []T
	for _, t := range s.titles {
		out = append(out, f(t))
	}
	return out
}

func main() {
	var s Stack[int]
	s.Push(1)
	s.Push(22)
	strs := s.Map(strconv.Itoa)
	fmt.Println(strs.Len(), strs.items)

	sh := &Shelf{titles: []string{"Dune", "Emma", "Ubik"}}
	fmt.Println(sh.Convert(func(t string) int { return len(t) }))
}

2 [1 22]
[4 4 4]

package main

// An interface method cannot declare type parameters.
type Mapper interface {
	Map[T any](f func(string) T) []T
}

func main() {}

main.go:5:5: interface method must have no type parameters
main.go:5:28: undefined: T

package main

import "fmt"

type Eacher interface{ Each(f func(string)) }

type Shelf struct{ titles []string }

// A generic method has its own type parameter list...
func (s *Shelf) Each[T any](f func(string)) {
	for _, t := range s.titles {
		f(t)
	}
}

func main() {
	// ...so it cannot be used to satisfy an interface method.
	var e Eacher = &Shelf{titles: []string{"Dune"}}
	fmt.Println(e)
}

main.go:18:17: cannot use &Shelf{…} (value of type *Shelf) as Eacher value in variable declaration: *Shelf does not implement Eacher (wrong type for method Each)
		have Each[T any](func(string))
		want Each(func(string))

module example.com/old

go 1.26

main.go:17:24: generic method requires go1.27 or later (-lang was set to go1.26; check go.mod)
main.go:27:25: generic method requires go1.27 or later (-lang was set to go1.26; check go.mod)