Go is a statically typed, compiled programming language designed for simplicity and efficiency. One of its core concepts that every Go developer must grasp is the idea of method sets. This concept is pivotal in understanding how methods are attached to types and how they affect interface implementation. In this blog post, we’ll dive deep into method sets in Go, providing clear examples to illuminate their workings and implications.

What are Method Sets?

In Go, a method is a function that executes in the context of a type. A method set, on the other hand, is the collection of all the methods with a receiver of a particular type. The method set determines the interfaces that the type can implement and how the methods can be called.

Go differentiates between two types of receivers: value receivers and pointer receivers. This distinction plays a crucial role in method sets:

• Value receivers operate on copies of the original value. They can be called on both values and pointers of that type.
• Pointer receivers operate on the actual value (not a copy) and can only be called on pointers.

This differentiation leads to an important rule in Go’s method sets:

Examples of Method Sets
To illustrate the concept of method sets, let’s consider some examples.

• The method set of a type T consists of all methods declared with receiver type T.
• The method set of the pointer type *T includes all methods declared with receiver *T or T.
• This rule has a significant impact on interface implementation, as we will see later.

Example 1: Value Receiver

package main

import "fmt"

type Circle struct {
Radius float64
}

// Area method has a value receiver of type Circle
func (c Circle) Area() float64 {
return 3.14 * c.Radius * c.Radius
}

func main() {
c := Circle{Radius: 5}
fmt.Println("Area:", c.Area())

cPtr := &c
// Even though Area has a value receiver, it can be called on a pointer.
fmt.Println("Area through pointer:", cPtr.Area())

}

In this example, Area has a value receiver of type Circle. Hence, it can be called on both a Circle value and a pointer to Circle.

Example 2: Pointer Receiver

package main

import "fmt"

type Square struct {
Side float64
}

// Scale method has a pointer receiver of type *Square
func (s *Square) Scale(factor float64) {
s.Side *= factor
}

func main() {
sq := Square{Side: 4}
// Scale method can be called on a pointer
sqPtr := &sq
sqPtr.Scale(2)
fmt.Println("Scaled side:", sq.Side)

// Scale method can also be called on a value, the compiler implicitly takes the address
sq.Scale(2)
fmt.Println("Scaled side again:", sq.Side)

}

In this case, Scale has a pointer receiver. It can be called on both a Square value and a pointer to Square, with the compiler implicitly taking the address of sq when calling sq.Scale(2).

Interface Implementation and Method Sets

Method sets are crucial when it comes to interface implementation. A type T implements an interface by implementing its methods. However, a pointer type *T can also implement an interface by having methods with either receiver type.

Consider the following interface:

type Shaper interface {
Area() float64
}

For a type T to implement Shaper, it must have an Area method with a value receiver. However, if the Area method had a pointer receiver, then only *T (a pointer to T) would satisfy the Shaper interface.

Conclusion

Understanding method sets in Go is fundamental for effective Go programming, particularly when working with interfaces and method receivers. Remember that the method set of a type determines how methods can be called and what interfaces the type implements.