golang generic tutorial

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.


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:

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 vs non-generics pros and cons

Pros of Generics in Golang

  • Code reuse: With generics, it’s easier to write reusable code that can work with multiple data types.
  • Improved type safety: Generics ensure that the correct types are used, leading to fewer runtime errors and improved code reliability.
  • Simplified code: Generics can reduce the amount of code that needs to be written, making code more manageable and easier to understand.

Cons of Generics in Golang

  • Increased complexity: Generics can be complex to understand, especially for beginners, and can lead to code bloat if not used correctly.
  • Performance impact: Generics can have an impact on performance if not used correctly, and can result in slower code execution.

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

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

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

Yes, you can use generics with built-in types like slices and maps. You can create generic functions that work with slices or maps of any type, as long as they satisfy the constraints.

Generics in Go are still relatively limited compared to other languages. Some limitations include no support for type specialization and no support for code generation based on type parameters.

Yes, you can use generics with existing Go code. However, you may need to refactor your code to take advantage of generics and ensure your code is compatible with the new features.

To effectively use generics in Go, consider the following best practices:

  • Use generics to improve code reuse and maintainability, but be cautious when using them for performance-critical code.
  • Use the smallest constraint possible for type parameters to ensure flexibility and avoid unnecessary limitations.
  • Keep your code simple and avoid overusing generics, which can lead to increased complexity and harder-to-read code.
  • Test and benchmark your generic code to ensure it meets your performance expectations.

Generics in Go are more limited compared to other languages like Java, C#, and Rust. However, they still offer a degree of code reuse and type safety. Go’s generics implementation focuses on simplicity, while still providing useful features for developers.


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.

Similar Posts

Leave a Reply

Your email address will not be published. Required fields are marked *