Blog / Go Language Spec

Implementing interfaces

April 12, 2023

Basic interfaces

…

More than one type may implement an interface. For instance, if two types S1 and S2 have the method set

func (p T) Read(p []byte) (n int, err error)
func (p T) Write(p []byte) (n int, err error)
func (p T) Close() error

(where T stands for either S1 or S2) then the File interface is implemented by both S1 and S2, regardless of what other methods S1 and S2 may have or share.

This is the formal definition of Go’s version of Duck typing, which we’ve already discussed.

The explanation continues…

Every type that is a member of the type set of an interface implements that interface. Any given type may implement several distinct interfaces. For instance, all types implement the empty interface which stands for the set of all (non-interface) types:

interface{}

For convenience, the predeclared type any is an alias for the empty interface.

It’s not always obvious which types implement a given interface, and this can trip up many newcomers. Some IDEs will let you find types that implement a given interface, but for some common interfaces this is next to worthless. Consider perhaps the most common interface type, the io.Reader. There are dozens of implementations of this interface in the standard library alone. Likely hundreds or thousands in any reasonably sized project.

And most types don’t overtly advertise that they satisfy any particular interface. Consider the os.File type. This type has a number of methods defined on it: Close() error, Chdir() error, Name() string, Read([]byte) (int, error), and many others.

But what interfaces does it implement? Well, several, actually. It’s an io.Reader by virtue of implementing the Read() method. It’s also an io.ReadCloser because it implements both the Read() method and the Close() method. It’s also a an io.Writer and io.WriteCloser, and even a io.ReadWriteCloser, and many others. It can even implement user-defined interfaces. Do you want a ChdirReader interface?

type ChdirReader interface {
  Chdir() error
  Read([]byte) (int, error)
}

Fine, create that type, and os.File will automatically implement it, because it has those methods.

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

Share this

Related Content

Interface method names

Basic interfaces … The name of each explicitly specified method must be unique and not blank. interface { String() string String() string // illegal: String not unique _(x int) // illegal: method must have non-blank name } These rules likely look familiar, from our discussion of struct field names, which must also be unique. But there’s a difference: The blank methods are not permitted! Why is that? Well, in effect, the blank identifier is write-only.

Basic interfaces

Basic interfaces In its most basic form an interface specifies a (possibly empty) list of methods. The type set defined by such an interface is the set of types which implement all of those methods, and the corresponding method set consists exactly of the methods specified by the interface. Interfaces whose type sets can be defined entirely by a list of methods are called basic interfaces. // A simple File interface.

Interface and methods

Interface types … An interface type is specified by a list of interface elements. An interface element is either a method or a type element, where a type element is a union of one or more type terms. A type term is either a single type or a single underlying type. Prior to Go 1.18, interfaces were made up strictly of methods. The introduction of generics complicated things significantly. As such, we’ll talk first about methods, and get to the concept of type elements in a few days.