What's the difference between passing in a value or passing in an address into an interface in Go?

Let's say we have a simple interface and implementation:

type Vertex struct {
	X int
	Y int
}

type Abser interface {
	Abs() float64
}

func (v Vertex) Abs() float64 {
	sum := float64(v.X + v.Y)
	return math.Sqrt(sum)
}

Now I have an interface variable:

var abser Abser

I want to set a vertex to it. I am able to set the value of one, or the address of one:

v := Vertex{1, 1}
abser = v
abser = &v

What is the difference between the two? Why does setting the address of a Vertex work? How does this tie in with how interfaces work under the hood? I'm still quite new to Go so any help would be much appreciated 🙏

In the Go type system, a method defined using a value-receiver for type T is defined for both T and *T, that is:

func (v Vertex) Abs() float64 {...}

This works for both v and *v. The method itself always receives a copy of v.

A method defined for *T is only defined for *T and not for T. That is:

func (v *Vertex) SetX(newx float64) {v.X=newx}

The method SetX will only work when the receiver is addressable. This is necessary so that you don't write code that loses data. For instance:

m:=map[string]Vertex{}
m["a"]=Vertex{}
m["a"].SetX(1) // This fails! m["a"] is not addressable

If the above case did not fail, then SetX would set a copy of m["a"], and the effects would be lost, because the updated copy is not put back into the map.

Going back to interfaces: your Abser interface is implemented by any type that implements Abs() float64. Based on the above discussion, both Vertex and *Vertex implement Abser.

Let's say you defined Vertex.Abs as:

func (v *Vertex) Abs() float64 {...}

Then, only *Vertex implements Abser, so :

abser = v // This would fail
abser = &v // This would work

First, in Go, everything is pass by value.

Pointers are passed by value - a copy of the pointer is used.

Slices are passed by value - the pointer to the underlying array, the integer value of the length and the integer value of the capacity are copied.

Interfaces are also passed by value - a copy of the interface value is used.

It helps if you think about it this way.

Now, let's focus on interfaces:

An interface value consists of two parts:

1. A pointer to an interface table
2. A pointer to the actual value

So when you pass an interface, you're essentially copying two pointers.

Now, for a type to satisfy an interface, it needs to have the methods the interface requires. If any of the methods use a pointer receiver (like func (v *Vertex) Abs() float64 {...} in your example), then you will need a pointer to the value to satisfy the interface and that is why you need to take the address of it.

Let's say none of the methods required a pointer receiver (say func (v Vertex) Abs() float64 {...}). Then you wouldn't need to specify the address because you would just pass it without taking its address.

I hope that answers your question.