With what we’ve learned so far about interfaces, we can now draw some general conclusions about the precise definitions of an interfce’s type set. The spec summarizes nicely.

General interfaces

… Together with method specifications, these elements enable the precise definition of an interface’s type set as follows:

• The type set of the empty interface is the set of all non-interface types.
• The type set of a non-empty interface is the intersection of the type sets of its interface elements.
• The type set of a method specification is the set of all non-interface types whose method sets include that method.
• The type set of a non-interface type term is the set consisting of just that type.
• The type set of a term of the form ~T is the set of all types whose underlying type is T.
• The type set of a union of terms t1|t2|…|tn is the union of the type sets of the terms.

The first point in this list deserves some additional discussion, because it may not be obvious at first, but interfaces match only non-interface types. This isn’t necissarily obvious, because code like the following works:

	var x error = errors.New("foo") // `x` is of interface type `error`
	var y any = x                   // `y` is of interface type `any`

The variable y, which is of interface type any, appears to match x, which is of an interface type (error). However, what it’s actually matching isn’t the interface type, but the underlying type returned by errors.New, which is of type *errors.errorString, as we can see from the source code.

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