Understanding Interfaces in Go: The Secret Sauce of Polymorphism

April 11, 2025

Introduction

Interfaces are one of Go's most powerful and elegant features. They enable polymorphism, promote loose coupling, and make code more testable and maintainable. Unlike many other languages, Go's interfaces are implicit, meaning types don't need to explicitly declare that they implement an interface. This design philosophy makes Go interfaces incredibly flexible and encourages good software design patterns.

What Are Interfaces?

An interface in Go is a type that specifies a set of method signatures. Any type that implements all the methods of an interface automatically satisfies that interface. This implicit satisfaction is what makes Go interfaces so powerful and different from interfaces in languages like Java or C#.

Basic Interface Definition:

basic-interface.go

// Define an interface
type Writer interface {
    Write([]byte) (int, error)
}

// Any type with a Write method satisfies this interface
type FileWriter struct {
    filename string
}

func (fw FileWriter) Write(data []byte) (int, error) {
    // Implementation here
    return len(data), nil
}

// FileWriter automatically satisfies the Writer interface
var w Writer = FileWriter{filename: "example.txt"}

The Empty Interface:

empty-interface.go

// The empty interface can hold any type
var anything interface{}

anything = 42
anything = "hello"
anything = []int{1, 2, 3}

// In Go 1.18+, you can use 'any' as an alias
var anything2 any = "world"

Interface Composition

Go allows you to compose interfaces by embedding other interfaces, creating more complex contracts from simpler ones.

interface-composition.go

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

type Writer interface {
    Write([]byte) (int, error)
}

type Closer interface {
    Close() error
}

// Compose interfaces
type ReadWriter interface {
    Reader
    Writer
}

type ReadWriteCloser interface {
    Reader
    Writer
    Closer
}

// This is equivalent to:
type ReadWriteCloser2 interface {
    Read([]byte) (int, error)
    Write([]byte) (int, error)
    Close() error
}

Polymorphism in Action

Interfaces enable polymorphism by allowing different types to be treated uniformly if they implement the same interface.

polymorphism.go

package main

import "fmt"

// Define a Shape interface
type Shape interface {
    Area() float64
    Perimeter() float64
}

// Rectangle type
type Rectangle struct {
    Width, Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

// Circle type
type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * 3.14159 * c.Radius
}

// Function that works with any Shape
func PrintShapeInfo(s Shape) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f
", s.Area(), s.Perimeter())
}

func main() {
    rect := Rectangle{Width: 10, Height: 5}
    circle := Circle{Radius: 3}
    
    // Both types can be used polymorphically
    PrintShapeInfo(rect)   // Area: 50.00, Perimeter: 30.00
    PrintShapeInfo(circle) // Area: 28.27, Perimeter: 18.85
    
    // Store different types in a slice
    shapes := []Shape{rect, circle}
    for _, shape := range shapes {
        PrintShapeInfo(shape)
    }
}

Type Assertions and Type Switches

When working with interfaces, you sometimes need to access the underlying concrete type. Go provides type assertions and type switches for this purpose.

Type Assertions:

type-assertions.go

func processValue(v interface{}) {
    // Type assertion with ok pattern (safe)
    if str, ok := v.(string); ok {
        fmt.Printf("String value: %s
", str)
        return
    }
    
    if num, ok := v.(int); ok {
        fmt.Printf("Integer value: %d
", num)
        return
    }
    
    fmt.Println("Unknown type")
}

// Direct type assertion (can panic if wrong type)
func directAssertion(v interface{}) {
    str := v.(string) // Panics if v is not a string
    fmt.Println(str)
}

Type Switches:

type-switches.go

func processValueSwitch(v interface{}) {
    switch val := v.(type) {
    case string:
        fmt.Printf("String: %s (length: %d)
", val, len(val))
    case int:
        fmt.Printf("Integer: %d (squared: %d)
", val, val*val)
    case float64:
        fmt.Printf("Float: %.2f
", val)
    case bool:
        fmt.Printf("Boolean: %t
", val)
    case nil:
        fmt.Println("Nil value")
    default:
        fmt.Printf("Unknown type: %T
", val)
    }
}

// Usage
processValueSwitch("hello")  // String: hello (length: 5)
processValueSwitch(42)       // Integer: 42 (squared: 1764)
processValueSwitch(3.14)     // Float: 3.14
processValueSwitch(true)     // Boolean: true

Real-World Example: Plugin System

Here's a practical example showing how interfaces can be used to create a flexible plugin system for data processing.

plugin-system.go

package main

import (
    "fmt"
    "strings"
)

// DataProcessor interface defines the contract for data processors
type DataProcessor interface {
    Process(data string) string
    Name() string
}

// UpperCaseProcessor converts text to uppercase
type UpperCaseProcessor struct{}

func (u UpperCaseProcessor) Process(data string) string {
    return strings.ToUpper(data)
}

func (u UpperCaseProcessor) Name() string {
    return "UpperCase"
}

// ReverseProcessor reverses the text
type ReverseProcessor struct{}

func (r ReverseProcessor) Process(data string) string {
    runes := []rune(data)
    for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
        runes[i], runes[j] = runes[j], runes[i]
    }
    return string(runes)
}

func (r ReverseProcessor) Name() string {
    return "Reverse"
}

// TrimProcessor removes leading and trailing whitespace
type TrimProcessor struct{}

func (t TrimProcessor) Process(data string) string {
    return strings.TrimSpace(data)
}

func (t TrimProcessor) Name() string {
    return "Trim"
}

// ProcessingPipeline manages a chain of processors
type ProcessingPipeline struct {
    processors []DataProcessor
}

func NewProcessingPipeline() *ProcessingPipeline {
    return &ProcessingPipeline{
        processors: make([]DataProcessor, 0),
    }
}

func (p *ProcessingPipeline) AddProcessor(processor DataProcessor) {
    p.processors = append(p.processors, processor)
}

func (p *ProcessingPipeline) Process(data string) string {
    result := data
    fmt.Printf("Starting with: &apos;%s&apos;
", result)
    
    for _, processor := range p.processors {
        result = processor.Process(result)
        fmt.Printf("After %s: &apos;%s&apos;
", processor.Name(), result)
    }
    
    return result
}

func main() {
    // Create a processing pipeline
    pipeline := NewProcessingPipeline()
    
    // Add different processors
    pipeline.AddProcessor(TrimProcessor{})
    pipeline.AddProcessor(UpperCaseProcessor{})
    pipeline.AddProcessor(ReverseProcessor{})
    
    // Process some data
    input := "  hello world  "
    result := pipeline.Process(input)
    
    fmt.Printf("
Final result: &apos;%s&apos;
", result)
    
    // Output:
    // Starting with: &apos;  hello world  &apos;
    // After Trim: &apos;hello world&apos;
    // After UpperCase: &apos;HELLO WORLD&apos;
    // After Reverse: &apos;DLROW OLLEH&apos;
    // 
    // Final result: &apos;DLROW OLLEH&apos;
}

Interface Segregation and Design

Following the Interface Segregation Principle, it's better to have many small, focused interfaces than one large interface.

Good Interface Design:

good-interface-design.go

// Small, focused interfaces
type Saver interface {
    Save() error
}

type Loader interface {
    Load() error
}

type Validator interface {
    Validate() error
}

// Compose when needed
type Repository interface {
    Saver
    Loader
    Validator
}

// Types can implement just what they need
type User struct {
    Name  string
    Email string
}

func (u User) Save() error {
    // Save user to database
    return nil
}

func (u User) Load() error {
    // Load user from database
    return nil
}

func (u User) Validate() error {
    if u.Email == "" {
        return fmt.Errorf("email is required")
    }
    return nil
}

// User automatically implements Repository interface

Interface Best Practices:

interface-best-practices.go

// 1. Accept interfaces, return concrete types
func ProcessData(r io.Reader) *ProcessedData {
    // Function accepts interface for flexibility
    // Returns concrete type for clarity
    return &ProcessedData{}
}

// 2. Keep interfaces small and focused
type Stringer interface {
    String() string
}

// 3. Define interfaces where they're used, not where they're implemented
// In package that uses the interface:
type UserService interface {
    GetUser(id int) (*User, error)
}

func HandleUserRequest(service UserService, id int) {
    user, err := service.GetUser(id)
    // Handle user...
}

// 4. Use descriptive names
type EmailSender interface {
    SendEmail(to, subject, body string) error
}

type FileUploader interface {
    UploadFile(filename string, data []byte) error
}

Testing with Interfaces

Interfaces make testing much easier by allowing you to create mock implementations for your dependencies.

testing-with-interfaces.go

package main

import (
    "fmt"
    "testing"
)

// Database interface
type Database interface {
    GetUser(id int) (*User, error)
    SaveUser(user *User) error
}

// User service that depends on Database
type UserService struct {
    db Database
}

func NewUserService(db Database) *UserService {
    return &UserService{db: db}
}

func (s *UserService) UpdateUserEmail(id int, newEmail string) error {
    user, err := s.db.GetUser(id)
    if err != nil {
        return err
    }
    
    user.Email = newEmail
    return s.db.SaveUser(user)
}

// Mock implementation for testing
type MockDatabase struct {
    users map[int]*User
    saveError error
    getError error
}

func NewMockDatabase() *MockDatabase {
    return &MockDatabase{
        users: make(map[int]*User),
    }
}

func (m *MockDatabase) GetUser(id int) (*User, error) {
    if m.getError != nil {
        return nil, m.getError
    }
    
    user, exists := m.users[id]
    if !exists {
        return nil, fmt.Errorf("user not found")
    }
    return user, nil
}

func (m *MockDatabase) SaveUser(user *User) error {
    if m.saveError != nil {
        return m.saveError
    }
    
    m.users[user.ID] = user
    return nil
}

// Test function
func TestUserService_UpdateUserEmail(t *testing.T) {
    // Setup
    mockDB := NewMockDatabase()
    mockDB.users[1] = &User{ID: 1, Name: "John", Email: "john@old.com"}
    
    service := NewUserService(mockDB)
    
    // Test
    err := service.UpdateUserEmail(1, "john@new.com")
    if err != nil {
        t.Fatalf("Expected no error, got %v", err)
    }
    
    // Verify
    user, _ := mockDB.GetUser(1)
    if user.Email != "john@new.com" {
        t.Errorf("Expected email to be &apos;john@new.com&apos;, got &apos;%s&apos;", user.Email)
    }
}

Common Interface Patterns

1. Strategy Pattern:

strategy-pattern.go

type SortStrategy interface {
    Sort([]int) []int
}

type BubbleSort struct{}
func (b BubbleSort) Sort(data []int) []int {
    // Bubble sort implementation
    return data
}

type QuickSort struct{}
func (q QuickSort) Sort(data []int) []int {
    // Quick sort implementation
    return data
}

type Sorter struct {
    strategy SortStrategy
}

func (s *Sorter) SetStrategy(strategy SortStrategy) {
    s.strategy = strategy
}

func (s *Sorter) Sort(data []int) []int {
    return s.strategy.Sort(data)
}

2. Observer Pattern:

observer-pattern.go

type Observer interface {
    Update(event string)
}

type Subject struct {
    observers []Observer
}

func (s *Subject) Attach(observer Observer) {
    s.observers = append(s.observers, observer)
}

func (s *Subject) Notify(event string) {
    for _, observer := range s.observers {
        observer.Update(event)
    }
}

type EmailNotifier struct{}
func (e EmailNotifier) Update(event string) {
    fmt.Printf("Email notification: %s
", event)
}

type SMSNotifier struct{}
func (s SMSNotifier) Update(event string) {
    fmt.Printf("SMS notification: %s
", event)
}

Best Practices

✅ Do:

Keep interfaces small and focused (1-3 methods)
Define interfaces where they're consumed, not implemented
Accept interfaces, return concrete types
Use interfaces to make code testable
Prefer composition over large interfaces
Use descriptive interface names ending in -er when appropriate

❌ Don't:

Create interfaces with too many methods
Define interfaces before you need them
Use interface when you can be more specific
Force interfaces where simple functions would suffice
Create interfaces just for the sake of having interfaces

Conclusion

Interfaces are truly the secret sauce of polymorphism in Go. They enable clean, testable, and maintainable code by promoting loose coupling and clear contracts between components. The implicit satisfaction model makes Go interfaces incredibly flexible and encourages good design patterns.

Remember that interfaces should be discovered, not designed upfront. Start with concrete types, identify common behaviors, and extract interfaces when you see patterns emerging. This approach leads to more natural and useful abstractions that truly serve your code's needs.

Master interfaces, and you'll unlock one of Go's most powerful features for building robust, scalable applications.