There was no livestream today, as I was a bit under the weather. I intend to be back live streaming next Monday as usual

Method expressions

If M is in the method set of type T, T.M is a function that is callable as a regular function with the same arguments as M prefixed by an additional argument that is the receiver of the method.

MethodExpr    = ReceiverType "." MethodName .
ReceiverType  = Type .

This might seem a bit mundane at first. But there’s something subtle, going on here, that surprises most people when they first encounter it.

Consider a struct type T with two methods, Mv, whose receiver is of type T, and Mp, whose receiver is of type *T.

type T struct {
	a int
}
func (tv  T) Mv(a int) int         { return 0 }  // value receiver
func (tp *T) Mp(f float32) float32 { return 1 }  // pointer receiver

var t T

The expression

T.Mv

yields a function equivalent to Mv but with an explicit receiver as its first argument; it has signature

func(tv T, a int) int

If you’re like most, you’re so accustomed to calling methods on instantiated values, that you’ve never considered what the full function signature of a method looks like when separated from the receiver—or that the concept even makes sense.

But that’s essentially what we’ve done here:

x := T.Mv

notMv := func(T, int) int {
	return 0
}
x = notMv  // This assignment is valid, because notMv is of the same type as x, aka `func(T, int) int`

That function may be called normally with an explicit receiver, so these five invocations are equivalent:

t.Mv(7)
T.Mv(t, 7)
(T).Mv(t, 7)
f1 := T.Mv; f1(t, 7)
f2 := (T).Mv; f2(t, 7)

Tomorrow we’ll complete the discussion of the second half of the example, with the pointer receiver.

Quotes from The Go Programming Language Specification Version of August 2, 2023