Tmp

User-Defined Type Method Set

Method Set associated with the Values of a Type

The method set associated with the values of a type consists of all methods declared with a value receiver of that type.

The specification defines the method set of a type as the method set associated with the values of the type.

Method Set associated with the Pointers of a Type

The method set associated with the pointers of a type T consists of both all methods declared with a pointer receiver *T and with a value receiver T.

The method set associated with the pointers of a type always includes the method set associated with the values of the type. This is because given a pointer, we can always infer the value pointed by that address, so the methods associated with the value will naturally "work". The reverse is not true - given a value, not always we can get an address for it, and because we are not able to get an pointer, we cannot assume that the methods associated with the pointer will work. This is an example that demonstrates that we cannot always get an address for a value.

Another way of expressing this is that pointer receiver method are less general than the value receiver methods: value receiver methods can always be used, pointer receiver methods can't always be used.

Also see:

Receivers and Interfaces

When does a Type/Pointer Type Implement an Interface?

Note that notion of a type implementing an interface and its corresponding pointer type implementing the same interface both make sense, and they are subtly different.

According to the language specification, a user-defined type T implements an interface if its method set (all methods declared with a value receiver of type T) is a superset of the interface.

By extrapolation, a pointer type implements an interface when the method set associated with pointers to that type is a superset of the interface. As per User-Defined Type Method Set section, the method set associated with the pointer of a type include implicitly the method set associated with the value of the type.

For more details about value and pointer receivers, see:

Value and Pointer Receivers

For more details about pointer types see:

Pointer Types

Example

The example that follows shows how a type B implements interface A:

//
// The interface A declares an interface method set containing a single method m()
//
type A interface {
    m()
}

//
// At this point, the type B is not yet linked to the interface A in any way. 
// Its method set is empty, so it does not implement interface A, it does not 
// implement any interface.
//
type B struct {
    i int
}

//
// We make B implement interface A by declaring B as a value receiver for m(). 
// This means B's method set includes now m() and it is a superset of A's method 
// set.
//
func (b B) m() {
    // simply reports the value of i
    fmt.Println(b.i)
}

...

//
// B now implements A, so B instances can be assigned to A variables
//
var a A
a = B{1}
a.m()

//
// *B now also implements A, because the method set of the pointer type 
// includes the methods declared agains the value  so *B instances 
// can be assigned to A variables
//
var a2 A
a2 = &B{2}
a2.m()

...

A Variation of the Example

Note that if in the example above we declare

func (b *B) m() {
    ...
}

instead of

func (b B) m() {
    ...
}

then the a = B{1} assignment would fail to compile with:

./main.go:23: cannot use B literal (type B) as type A in assignment:
	B does not implement A (m method has pointer receiver)

This is because the type B does not implement the interface, because m() is not in the type B method set.

However, if we try:

var a A
a = &B{1}
a.m() 

it works in both cases, because the method set associated with the B pointers include both func (b B) m() ... and func (b *B) m() ... so the pointer type B implements the interface.

Passing Interfaces to Functions

Interfaces can be used as arguments to functions. Passing an interface instance insures that the function body can rely on the fact the interface methods are available on the passed instance.

With the example above, we declare a function f() that expects an interface A and we pass a B instance when invoking the function:

...

type A interface {
    m()
}

func (b B) m() {
    ...
}

func f(a A) {
    a.m()
}

...
b := B{1}
f(b)
...

Note that the B instance can be passed by value (as in the example above) or by reference (as in the example below). Both cases work for reasons explained in the Method Set associated with the Pointers of a Type section:

...
b := B{1}
f(&b)
...

or (same thing)

...
bPtr := new(B)
f(bPtr)
...

Interfaces as Fields

Interfaces can be used as fields in structs.

Implementation Details

An interface variable is a two-word data structure.

The first word contains a pointer to an internal table called iTable, which contains type information about the stored value: the concrete type of the value that has been stored and a list of methods associated with the value. The second word is a reference to the stored value.

The combination of type information and pointer binds the relationship between the two values.

DEPLETE: Go Concepts - The Type System