Implementing an interface

It feels like it’s been a month since we started on interfaces. Today we’re covering the final section on this topic!

Implementing an interface

A type T implements an interface I if

T is not an interface and is an element of the type set of I; or

T is an interface and the type set of T is a subset of the type set of I.

A value of type T implements an interface if T implements the interface.

All three of these points should be pretty intuitive, especially if you’ve read the rest of the interface posts, but let’s give an example of each just to be sure.

T is not an interface and is an element of the type set of I

type Float interface {
	~float32 | ~float64
}

type myFloat float64 // myFloat implements Float; it is not
                     // an interface, and it is an element
                     // of the type set of Float.

type Fooer interface {
	Foo()
}

type myFooer struct {} // myFooer implements Fooer; it is not
                       // an interface, and it is an element
                       // of the type set of Fooer by virtue of
                       // the fact that it implements the Foo()
                       // method

func (f *myFooer) Foo() {}

T is an interface and the type set of T is a subset of the typset of I

type FooBarer interface {
	Foo()
	Bar()
}

var fb FooBarer
var f Fooer = fb // FooBarer implements Fooer, because
                 // it is an interface, and has a type set
                 // that is a subset of FooBarer's type set.

A value of type T implements an interface if T implements the interface.

This just extends the type implementation rules to values of that type.

Quotes from The Go Programming Language Specification Version of December 15, 2022

Related Content

Unions of type sets

General interfaces … Union elements denote unions of type sets: // The Float interface represents all floating-point types // (including any named types whose underlying types are // either float32 or float64). type Float interface { ~float32 | ~float64 } Here we see our first example of a union of type sets. The example shows an interface of all types with an underlying float type. The equivalent for integer types is a bit longer, due to the large number of distinct integer types in Go, but would look like:

Recursive interfaces

Check out this week’s episode of the Cup o’ Go podcast: What the ʕ◔ϖ◔ʔ? New merch, TDD book interview with Adelina Simion, and more You can probably guess Go’s rules about recursively embedding interfaces. In short: It’s not allowed. General interfaces … An interface type T may not embed a type element that is, contains, or embeds T, directly or indirectly. // illegal: Bad may not embed itself type Bad interface { Bad } // illegal: Bad1 may not embed itself using Bad2 type Bad1 interface { Bad2 } type Bad2 interface { Bad1 } // illegal: Bad3 may not embed a union containing Bad3 type Bad3 interface { ~int | ~string | Bad3 } // illegal: Bad4 may not embed an array containing Bad4 as element type type Bad4 interface { [10]Bad4 } Note however, that, an interface method may refer to the interface itself.

Interfaces as type constraints

If you’ve been playing around with interface types while reading about them for the last couple of weeks, you have probably noticed something: Many of the interface types described don’t work as variables. Here we see why: General interfaces … Interfaces that are not basic may only be used as type constraints, or as elements of other interfaces used as constraints. They cannot be the types of values or variables, or components of other, non-interface types.

Implementing an interface

May 9, 2023