Stage 1 · Code

Methods, Interfaces & Errors

Interfaces

Write polymorphic Go code by defining small interfaces and satisfying them implicitly — no declarations required.

8 min readProgramming Foundations (Go)Code

What is an Interface?

An interface is a set of method signatures. Any type that implements all those methods satisfies the interface — no explicit declaration needed. This is Go's mechanism for polymorphism.

Godefining-and-using-an-interface.go

33 linesLn 1, Col 1Go

`Circle` and `Rectangle` both satisfy `Shape` without ever mentioning the `Shape` interface. The `printShape` function works with both because Go checks method signatures at compile time — not at runtime like a dynamic language.

Implicit Satisfaction

Go interfaces are implicitly satisfied — you implement an interface by having the right methods, not by writing implements Shape. This decouples the definition of a type from the interfaces it satisfies.

Design to small interfaces

Go's standard library favours tiny interfaces: io.Reader has one method, io.Writer has one method, fmt.Stringer has one method. Small interfaces are easier to implement, easier to compose, and easier to test. If your interface has more than three methods, consider whether it should be two interfaces.

Gointerface-satisfied-by-any-type.go

36 linesLn 1, Col 1Go

Neither `Server` nor `User` mentions `Describer`. The interface is satisfied purely by having the right method signature. This means you can make third-party types satisfy your interfaces without modifying them.

Common Standard Interfaces

The Go standard library defines small, composable interfaces used everywhere. Implementing these makes your types work with the entire ecosystem of standard library functions.

Interface	Method(s)	What it enables
`fmt.Stringer`	`String() string`	Custom print output with `fmt.Print`
`io.Reader`	`Read(p []byte) (n int, err error)`	Works with `io.Copy`, `json.NewDecoder`, etc.
`io.Writer`	`Write(p []byte) (n int, err error)`	Works with `fmt.Fprintf`, `io.Copy`, etc.
`error`	`Error() string`	Can be returned as an error value
`sort.Interface`	`Len, Less, Swap`	Sortable with `sort.Sort`

Goimplementing-fmt.stringer.go

21 linesLn 1, Col 1Go

Any type with a `String() string` method is automatically formatted using that method by all `fmt` print functions. You never need to import `fmt` in the type's package — the interface is checked dynamically.

The Empty Interface

any (an alias for interface{}) has no methods, so every type satisfies it. Use it when a function genuinely needs to accept values of any type, but avoid it otherwise — it gives up compile-time type safety.

Goany-and-type-switches.go

28 linesLn 1, Col 1Go

A **type switch** extracts the concrete type from an `any` value and lets you handle each case separately. `val` in each case branch has the concrete type, not `any`.

Type Assertions

A type assertion v.(T) extracts the concrete value of type T from an interface. Use the two-value form v, ok := i.(T) to check safely — the one-value form panics if the type is wrong.

Gosafe-type-assertions.go

24 linesLn 1, Col 1Go

The two-value assertion `s.(FileSaver)` returns the concrete value and a boolean. If `ok` is false, `fs` is the zero value of `FileSaver` and the inner block is skipped safely. The single-value form `s.(FileSaver)` would panic if `s` is not a `FileSaver`.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.