Implementing Polymorphic Interfaces

1. What is an Interface? The Contract

In Go, an interface is a type that defines a set of method signatures. Think of it as a contract. Any type that provides definitions for all the methods in the contract is said to "satisfy" or "implement" the interface.

The key difference from many other languages is that this implementation is implicit. You don't need to explicitly declare that a type implements an interface (e.g., struct MyType implements MyInterface). If your type has the methods defined in the interface, it automatically fulfills the contract. This "if it walks like a duck and quacks like a duck, it is a duck" philosophy makes Go's interfaces incredibly lightweight and flexible.

Let's start with a foundational article that introduces this concept.

The syntax for defining an interface is straightforward:

// A Shape interface defines the behavior expected of a shape.
type Shape interface {
    Area() float64
    Perimeter() float64
}

This Shape interface declares a contract. Any type, to be considered a Shape, must have both an Area() method that returns a float64 and a Perimeter() method that also returns a float64.

The image below provides a great visual summary of this concept.

2. Achieving Polymorphism with Interfaces

The true power of interfaces comes from polymorphism—the ability for a single piece of code to work with values of multiple different types. A function can accept an interface type as an argument. When you call that function, you can pass in any concrete type that satisfies the interface. The function doesn't know or care about the specific type; it only interacts with the methods defined in the interface contract.

Let's see this in action with a complete example.

The magic happens in this function:

func calculateNetIncome(ic []Income) {
    var netincome int = 0
    for _, income := range ic {
        // At this point, Go knows the concrete type of 'income'
        // and calls the correct method for that type.
        fmt.Printf("Income From %s = $%d\n", income.source(), income.calculate())
        netincome += income.calculate()
    }
    // ...
}

When this function is called with a slice containing both FixedBilling and TimeAndMaterial objects, Go's runtime determines the actual (concrete) type of each element in the slice and calls the appropriate method.

3. The Power of Extensibility

The polymorphic design we just saw has a huge benefit: your system is now incredibly easy to extend. Imagine your organization adds a new revenue stream. With an interface-based design, you can add support for this new stream without touching the core calculateNetIncome function at all.

This principle is directly applicable to the DevOps tools you want to build. You could write a core deployment function that operates on a Deployer interface. Then you could create KubernetesDeployer, EC2Deployer, and LocalDockerDeployer structs. Your core logic would work with all of them seamlessly.

// StockDividend represents income from stock dividends.
type StockDividend struct {
    ticker           string
    dividendPerShare int
    shareCount       int
}

// calculate returns the total dividend amount.
func (sd StockDividend) calculate() int {
    return sd.dividendPerShare * sd.shareCount
}

// source returns the stock's ticker symbol.
func (sd StockDividend) source() string {
    return sd.ticker
}

func main() {
    // ... existing projects
    dividend1 := StockDividend{ticker: "GOOG", dividendPerShare: 1, shareCount: 100}
    
    incomeStreams := []Income{project1, project2, project3, bannerAd, popupAd, dividend1}
    calculateNetIncome(incomeStreams)
}

4. A Practical Refactoring Scenario

So far, we've designed a system with interfaces from the ground up. But often, you'll need to refactor existing, more rigid code to make it more flexible. This is a common and practical task.

The following video shows a great example of this. An API handler has a hardcoded notification mechanism. The presenter refactors it to use an interface, allowing different notification systems (e.g., email, Slack, or just logging) to be swapped in and out. This is a form of dependency injection, a crucial pattern for building testable and modular applications.

This example highlights the core benefit for you as a tool-builder. Your main command logic can remain stable, while the specific implementations of how it interacts with external systems can be easily changed or mocked for testing.

Conclusion

Today you've learned about Go's interfaces, one of its most defining features. They provide a powerful way to write abstract code that is flexible, extensible, and decoupled from concrete details.

Key Takeaways:

• An interface is a contract defining a set of method signatures.
• A type implicitly implements an interface if it has all the methods in the contract.
• Interfaces enable polymorphism: a function can operate on any type that satisfies a given interface, leading to flexible and reusable code.
• Using interfaces allows you to decouple your application's core logic from its dependencies (like databases, notifiers, or API clients), making your code easier to maintain and test.

Next Up

You've now seen how to define your own interfaces. But one of the best ways to learn idiomatic Go is to see how interfaces are used in the standard library. In the next lesson, we will do just that by exploring two of the most important interfaces in all of Go: io.Reader and io.Writer. You'll learn how they are used to build composable, streaming data pipelines—an essential skill for writing efficient CLI tools and services.