Unlocking Go's Power: Struct Composition and Elegant Sorting

Struct composition in Go allows developers to create complex types by combining simpler ones, promoting composition over inheritance for more flexible and maintainable code. This post explores struct composition, its differences from inheritance, and provides practical examples. Additionally, we examine Go's sorting mechanism, which utilizes interfaces and methods to demonstrate the power of composition for creating flexible and reusable code.

What is Struct Composition?

Struct composition involves embedding one struct within another without explicitly naming it as a field. This technique promotes the fields and methods of the embedded struct to the outer struct, making them accessible as if they were part of the outer struct itself.

Basic Struct Composition

Let's start with a basic example to understand how struct composition works.

In this example, PairWithLength embeds the Pair struct. The fields X and Y from Pair are promoted to PairWithLength, allowing direct access without additional dot notation.

Field and Method Promotion

When a struct is embedded, its fields and methods are promoted to the embedding struct. This means you can call methods of the embedded struct directly on the outer struct.

Here, the Sum method defined for Pair is accessible through PairWithLength due to method promotion.

Composition vs. Inheritance

A key distinction between composition and inheritance is that composition allows for more flexible code structures without creating rigid parent-child relationships. Inheritance implies a strict hierarchy, whereas composition emphasizes the assembly of complex types from simple, reusable components.

To illustrate, consider the following example demonstrating the limitations of inheritance and the flexibility of composition.

In this code, both Pair and PairWithLength can implement the FileNamer interface due to method promotion. This demonstrates how composition allows PairWithLength to adopt the FileNamer interface without inheriting from Pair.

Embedding Non-Struct Types

In Go, you can also embed non-struct types, such as slices, within structs. This can be useful for creating composite types with embedded behavior.

In this example, the Sum method of IntSlice is accessible through MyStruct due to embedding, illustrating the versatility of composition.

Practical Example: Sorting with Composition

A practical use case for composition is implementing sorting for a custom type. Let's see how this works by embedding a slice and using Go's sort package.

In this example, the People type embeds a slice of Person and implements the sort.Interface. This allows us to sort People by age using Go's sort package, demonstrating the power and flexibility of struct composition.

The Basics of Go's Sort Interface

In Go, the sort package provides a general-purpose interface for sorting, which requires three methods:

1. Len() int: Returns the length of the collection.
2. Swap(i, j int): Swaps the elements with indexes i and j.
3. Less(i, j int) bool: Reports whether the element with index i should sort before the element with index j.

These methods allow Go's sort function to operate on any collection that implements this interface. Let's start with a simple example using a slice of strings.

In this example, sort.Strings sorts a slice of strings in place. Under the hood, it uses a type sort.StringSlice, which implements the sort.Interface by providing the required methods.

Implementing Custom Sorting

Now, let's create a custom type and sort it using the sort package. We'll define an Organ type and sort a slice of Organ by name and weight.

Understanding Composition in Go

Composition in Go allows us to build complex types by combining simpler ones. Unlike inheritance, composition involves embedding types within other types, promoting their methods. This approach can be more flexible and powerful.

In the example above, ByName and ByWeight both embed a slice of Organ. By doing so, they inherit the Len and Swap methods from the slice type, and we only need to define the Less method for each sorting criterion.

Reversing Sort Order

The sort package also provides a way to reverse the sorting order using the sort.Reverse function, which wraps an existing sort.Interface.

For our custom type, we can apply sort.Reverse in a similar manner.

Advanced Composition Example: Stack with Encapsulation

Let's explore another powerful use of composition by creating a stack data structure that encapsulates its internal workings.

Conclusion

Struct composition in Go offers a flexible alternative to inheritance, enhancing code maintainability and fostering better design practices. By promoting fields and methods from embedded types, developers can create complex, reusable types without rigid class hierarchies. Go's sorting mechanism, built on interfaces and methods, further illustrates the power of composition, enabling the creation of robust and maintainable applications. This post's examples highlight the elegance and efficiency of Go's design principles.