A Tour of Go - Methods and interfaces

Question 1

In Go, what is a method?

Answer 1

A method is a function with a special receiver argument.

The receiver appears in its own argument list between the func keyword and the method name.

You can only declare a method with a receiver whose type is defined in the same package as the method. You cannot declare a method with a receiver whose type is defined in another package (which includes the built-in types such as int).

Question 2

In Go, what is a pointer receiver?

Answer 2

You can declare methods with a pointer receiver - *T. Also, T cannot itself be a pointer.

Methods with pointer receivers can modify the value to which the receiver points.

Question 3

Methods with pointer receivers and pointer indirection

Answer 3

Methods with pointer receivers take either a value or a pointer as the receiver when they are called:

var v Vertex
v.Scale(5)  // OK same as (&v).Scale(5)
p := &v
p.Scale(10) // OK

Question 4

Methods with value receivers and pointer indirection

Answer 4

Methods with value receivers take either a value or a pointer as the receiver when they are called:

var v Vertex
fmt.Println(v.Abs()) // OK
p := &v
fmt.Println(p.Abs()) // OK interpreted as (*p).Abs()

Question 5

Why choose a pointer receiver?

Answer 5

• Modification - the first is so that the method can modify the value that its receiver points to.
• Avoid copying - the second is to avoid copying the value on each method call. This can be more efficient if the receiver is a large struct, for example.
• Don’t mix - In general, all methods on a given type should have either a value or pointer receivers, but not a mixture of both.

Question 6

What is an interface type?

Answer 6

An interface type is defined as a set of method signatures.

A value of interface type can hold any value that implements those methods.

Question 7

Interfaces are implemented implicitly

Answer 7

A type implements an interface by implementing its methods.

There is no explicit declaration of intent, no “implements” keyword.

Implicit interfaces decouple the definition of an interface from its implementation, which could then appear in any package without prearrangement.

Question 8

Under the hood, interface values can be thought of as ….

Answer 8

a tuple of a value and a concrete type:

(value, type)

An interface value holds a value of a specific concrete type.

Calling a method on an interface value executes the method of the same name on its underlying type.

Question 9

Interface values with nil underlying values

Answer 9

If the concrete value inside the interface itself is nil, the method will be called with a nil receiver.

In some languages this would trigger a null pointer exception, but in Go it is common to write methods that gracefully handle being called with a nil receiver (as with the method M in this example.)

Note that an interface value that holds a nil concrete value is itself non-nil.

Question 10

Can you call a method on a nil interface?

Answer 10

No. A nil interface value holds neither value nor concrete type.

Calling a method on a nil interface is a run-time error because there is no type inside the interface tuple to indicate which concrete method to call.

var i T
i.M() // runtime error

Question 11

The empty interface

Answer 11

The interface type that specifies zero methods is known as the empty interface:

interface{}

An empty interface may hold values of any type.

Empty interfaces are used by code that handles values of unknown type.

For example, fmt.Print takes any number of arguments of type interface{}.

Question 12

What is a type assertion?

Answer 12

A type assertion provides access to an interface value’s underlying concrete value.

t := i.(T)

If i does not hold T, the statement will trigger a panic.

Question 13

How do you test a type assertion?

Answer 13

To test whether an interface value holds a specific type, a type assertion can return two values: the underlying value and a boolean that reports whether the assertion succeeded.

t, ok := i.(T)

if i holds a T, then t will be the underlying value and ok will be true.

If not, ok will be false and t will be the zero value of of type T, and no panic occurs.

Question 14

What is a type switch?

Answer 14

A type switch is a construct that permits several type assertions in series.

A type switch is like a regular switch statement, but the cases in a type switch specify types (not values), and those values are compared against the type of the value held by the given interface value.

switch v := i.(type) {
case T:
    // here v has type T
case S:
    // here v has type S
default:
    // no match; here v has the same type as i
}

The declaration in a type switch has the same syntax as a type assertion i.(T), but the specific type T is replaced with the keyword type.

This switch statement tests whether the interface value i holds a value of type T or S. In each of the T and S cases, the variable v will be of type T or S respectively and hold the value held by i. In the default case (where there is no match), the variable v is of the same interface type and value as i.

Question 15

What is a Stringer?

Answer 15

A Stringer is a type that can describe itself as a string. The fmt package (and many others) look for this interface to print values.

type Stringer interface {
    String() string
}

Question 16

Errors

Answer 16

Go programs express error state with error values.

The error type is a built-in interface similar to fmt.Stringer:

type error interface {
    Error() string
}

(As with fmt.Stringer, the fmt package looks for the error interface when printing values.)

Functions ofter return an error value, and calling code should handle errors by testing whether the error equals nil.

A nil error denotes success; a non-nil error denotes failure.