Mastering Generic Functional Patterns in Go: Map, Filter, and Reduce

For years, the Go programming language was defined by its simplicity and explicit control flow. While this paradigm has made Go incredibly successful for systems programming and concurrency, it has often stood in contrast to the concise, declarative style found in functional languages like Haskell, Scala, or even JavaScript. Developers migrating from these ecosystems frequently miss the elegance of higher-order functions such as map, filter, and reduce.

However, with the introduction of type parameters (generics) in Go 1.18, the landscape has shifted. We are no longer bound to writing repetitive boilerplate for each data type. In this post, we will explore how to implement robust, generic versions of these functional programming patterns in Go, enhancing code reusability while maintaining the type safety Go is known for.

The Power of Generics in Go

Before diving into specific implementations, it is crucial to understand the problem generics solve in this context. Prior to Go 1.18, implementing a generic map function required interfaces like interface{} or writing multiple overloaded functions for different types (e.g., MapInt, MapString). This approach was verbose and lacked compile-time type safety for the transformation logic.

With generics, we can define a single function that accepts a slice of any type T and a transformation function. This allows the compiler to verify that our operations are valid for the specific types involved, catching errors before the code ever runs.

Implementing Map

The map function applies a given function to each element of a collection, returning a new collection with the results. In our generic implementation, we need a source slice of type T and a transformation function that accepts T and returns a potentially different type U.

func Map[T, U any](slice []T, fn func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = fn(v)
    }
    return result
}

This implementation is straightforward but powerful. Consider a scenario where you have a slice of integers representing user IDs, and you need to convert them into a slice of formatted strings. Using our generic map:

ids := []int{1, 2, 3}
formatted := Map(ids, func(id int) string {
    return fmt.Sprintf("User-%d", id)
})
// Result: []string{"User-1", "User-2", "User-3"}

Implementing Filter

While map transforms elements, filter selects them. It retains only those elements for which the predicate function returns true. Since the output type matches the input type, the signature is slightly simpler.

func Filter[T any](slice []T, fn func(T) bool) []T {
    var result []T
    for _, v := range slice {
        if fn(v) {
            result = append(result, v)
        }
    }
    return result
}

A practical use case involves cleaning data. Suppose you have a list of temperatures and want to keep only those within a safe operating range:

temps := []float64{10, 20, 30, 40, 50}
safeTemps := Filter(temps, func(t float64) bool {
    return t < 45
})
// Result: []float64{10, 20, 30, 40}

The Versatility of Reduce

Also known as fold or accumulate, reduce is often the most complex of the three. It combines all elements of a collection into a single value. Unlike map and filter, reduce requires an initial accumulator value. This allows us to sum numbers, concatenate strings, or build complex objects.

func Reduce[T, U any](slice []T, fn func(U, T) U, initial U) U {
    acc := initial
    for _, v := range slice {
        acc = fn(acc, v)
    }
    return acc
}

To calculate the total price of items in a cart, we might define a struct for the item:

type Item struct { Price float64 }
items := []Item{{10.0}, {20.0}, {5.5}}
total := Reduce(items, func(acc float64, item Item) float64 {
    return acc + item.Price
}, 0.0)
// Result: 35.5

Conclusion

By leveraging Go's generic capabilities, we can bring the elegance and expressiveness of functional programming to our Go codebases. While Go is not a functional language, adopting these patterns can lead to cleaner, more modular, and highly testable code. The key is to use these abstractions judiciously—prioritizing readability and maintainability without sacrificing the performance and clarity that make Go unique.

As you incorporate map, filter, and reduce into your projects, remember that simplicity remains paramount. Use these tools to eliminate repetition and clarify intent, ensuring your Go applications remain both powerful and easy to understand.