Generics in Golang: Simple and Complete View

Generics are an essential programming feature that enables code reuse and improved type safety. While most programming languages support generics, Golang did not have full support for generics until recently. With the release of Go 1.18, the language now has support for limited generics, and this article is a guide on how to use them.

Prerequisites

Before diving into generics, it’s essential to ensure you have the necessary tools and software. Here’s what you need:

• An installation of Go 1.18 or later. For installation instructions, see Installing Go.
• A tool to edit your code. Any text editor you have will work fine, but if you’re looking for a powerful IDE specifically designed for Go development, you can check out our article on Goland for Go Development: Pros and Cons of Using this Powerful IDE.
• A command terminal. Go works well using any terminal on Linux and Mac, and on PowerShell or cmd in Windows.

Throughout the article, you may find it helpful to refer to these related articles for a deeper understanding:

• A Full guide to Golang Arrays, Slices, and Maps
• Working with Functions in Golang: A Ultimate Guide

Non-generics in Go

Before discussing generics, it’s important to understand non-generic solutions in Go. Non-generic solutions involve writing code that only works with a specific type. For example, if you want to write a function that works with integers, you would need to write a separate function for each type, such as int, uint, int64, etc.

While non-generic solutions can work, they can lead to code bloat and make it harder to write reusable code. This is where generics come in.

Pros and Cons

Before diving into the specifics of generics in Golang, let’s first consider the pros and cons of using generics over non-generic solutions.

Generics in Go 1.18

With the release of Go 1.18, the language now has support for limited generics. Go 1.18 introduces type parameters, which enable generic types and functions. Type parameters are placeholders for types, allowing the same function or type to work with different types of data.

Core Generics features

1. Type parameters: Enable defining generic types and functions for code reuse.
2. Type constraints: Restrict allowed types for type parameters based on interfaces or built-in constraints.
3. Type inference: Automatically determines types based on usage, simplifying generic function calls.
4. Type lists: Specify multiple type parameters for more flexible and reusable generic code.
5. Contracts: Express complex requirements on type parameters using types and interfaces.

Syntax and Features of Go 1.18 Generics

To declare a generic function or type, you use type parameters, which are enclosed in angle brackets [ ]. Here’s an example:

func Max[T comparable](a, b T) T {
  if a > b {
    return a
  }
  return b
}

In this example, the function Max is declared with a type parameter T, which is comparable. The comparable constraint ensures that the type parameter T is a comparable type, such as integers, floats, and strings.

Type Parameters and Constraints

Type parameters in Go are similar to generics in other languages, but with a few differences. In Go, type parameters can be constrained by interfaces or types. Here’s an example:

func Max[T comparable](a, b T) T {
  if a > b {
    return a
  }
  return b
}

In this example, the type parameter T is constrained by the comparable constraint, which ensures that the type parameter T is a comparable type, such as integers, floats, and strings. You can also constrain type parameters by creating custom constraints with contracts using type lists.

Constrains table

Constraint	Description
any	Matches any type, including both built-in and user-defined types.
comparable	Matches types that can be compared using == and !=. Examples include basic types like int, float64, string, and user-defined types.
signed	Matches signed integer types, such as int, int8, int16, int32, and int64.
unsigned	Matches unsigned integer types, such as uint, uint8, uint16, uint32, and uint64.
numeric	Matches all numeric types, including int, float64, complex128, and their variations.
interface	Matches types that implement a specific interface. The constraint is defined by the interface’s method set.

Variance in Golang

In Go, type parameters work with any type that satisfies the constraints and can be used in both input and output positions in function signatures. This flexibility allows you to create generic functions that can handle various types, as long as they meet the specified constraints.

Creating Generic Functions

Creating generic functions and data structures is straightforward in Go. Here’s an example of a generic function:

func Map[T, U any](arr []T, f func(T) U) []U {
  out := make([]U, len(arr))
  for i, v := range arr {
    out[i] = f(v)
  }
  return out
}

In this example, we define a generic Map function that takes an array and a function that maps one type to another. We then call this function with an array of integers and a function that converts integers to strings.

Creating Generic Collections and Data Structures

Generic collections are data structures that can hold elements of any type, as long as they satisfy certain constraints. Using generics, you can create reusable and type-safe collections such as lists, stacks, or queues. Here’s an example of a generic stack:

type Stack[T any] struct {
  data []T
}

func (s *Stack[T]) Push(value T) {
  s.data = append(s.data, value)
}

func (s *Stack[T]) Pop() (T, bool) {
if len(s.data) == 0 {
var zero T
return zero, false
}
value := s.data[len(s.data)-1]
s.data = s.data[:len(s.data)-1]
return value, true
}

In this example, we define a generic Stack data structure that can hold values of any type that satisfies the any constraint. We provide Push and Pop methods for adding and removing elements from the stack.

Generic Interfaces

Generic interfaces are interfaces that include one or more type parameters. They allow you to define more flexible and reusable interfaces that can adapt to various data types. Here’s an example of a generic interface:

type Transformer[T any] interface {
    Transform(T) T
}

In this example, we define a Transformer interface with a type parameter T. The Transform method takes an input of type T and returns a value of the same type. By using a generic interface, we can implement this interface for multiple data types.

Performance Considerations

Generics can have an impact on performance if not used correctly. Here are some tips for optimizing generic code:

• Be cautious when using generics for performance-critical code, as it may introduce overhead. Consider using interfaces or other techniques for such cases.
• Avoid using reflection or runtime-type assertions.
• Use the smallest constraint possible for type parameters. – Avoid creating large data structures with generic types.

Frequently asked questions

Conclusion

Generics in Golang are an important feature that enables code reuse and improved type safety. With the release of Go 1.18, the language now has limited support for generics, which makes it easier to write reusable code. By understanding the syntax and features of generics in Golang, you can take advantage of this powerful feature in your code.

We hope this guide has helped get you started with generics in Golang. For more information on related topics, check out our guide How to protect the system from cascading failures: Circuit Breaker in Golang.