{"id":1092,"date":"2026-08-17T00:45:11","date_gmt":"2026-08-17T00:45:11","guid":{"rendered":"https:\/\/www.devopsschool.com\/tutorials\/?p=1092"},"modified":"2026-08-17T00:45:12","modified_gmt":"2026-08-17T00:45:12","slug":"go-tutorials-generics","status":"publish","type":"post","link":"https:\/\/www.devopsschool.com\/tutorials\/go-tutorials-generics\/","title":{"rendered":"Go Tutorials: Generics"},"content":{"rendered":"\n

1. What are Generics?<\/h2>\n\n\n\n

Generics let you write one piece of code that works with multiple types while keeping Go’s compile-time type safety.<\/strong><\/p>\n\n\n\n

Suppose you want a function that checks whether a slice contains a value.<\/p>\n\n\n\n

Without generics, you might write:<\/p>\n\n\n\n

ContainsInt(...)\nContainsString(...)\nContainsFloat(...)\n<\/code><\/pre>\n\n\n\n
With generics, you can write:<\/p>\n\n\n\n
Contains(...)\n<\/code><\/pre>\n\n\n\n
once and use it with different types.<\/p>\n\n\n\n
The main idea is:<\/p>\n\n\n\n
\n
Write the algorithm once. Let the type vary.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
\n\n\n\n
2. Why do we need Generics?<\/h1>\n\n\n\n
Imagine these two functions:<\/p>\n\n\n\n
func ContainsInt(items []int, target int) bool {\n    \/\/ ...\n}\n\nfunc ContainsString(items []string, target string) bool {\n    \/\/ ...\n}\n<\/code><\/pre>\n\n\n\n
The logic is identical.<\/p>\n\n\n\n
Only the type changes.<\/p>\n\n\n\n
Generics remove this duplication.<\/p>\n\n\n\n
Instead, we can say:<\/p>\n\n\n\n
func Contains[T comparable](items []T, target T) bool\n<\/code><\/pre>\n\n\n\n
Here T<\/code> means:<\/p>\n\n\n\n
\n
“There will be a type here, but I don’t need to know exactly which type while writing this function.”<\/p>\n<\/blockquote>\n\n\n\n
T<\/code> might later become:<\/p>\n\n\n\n
int\nstring\nfloat64\nbool\n<\/code><\/pre>\n\n\n\n
depending on how the function is called.<\/p>\n\n\n\n
\n\n\n\n
3. Complete Copy-Paste Example<\/h1>\n\n\n\n
Save this as:<\/p>\n\n\n\n
main.go\n<\/code><\/pre>\n\n\n\n
Then run:<\/p>\n\n\n\n
go run main.go\n<\/code><\/pre>\n\n\n\n
package main\n\nimport \"fmt\"\n\n\/\/ Contains is a generic function.\n\/\/\n\/\/ T is a TYPE PARAMETER.\n\/\/\n\/\/ \"comparable\" means T must support:\n\/\/     ==\n\/\/     !=\n\/\/\n\/\/ Examples of comparable types:\n\/\/     int\n\/\/     string\n\/\/     float64\n\/\/     bool\n\/\/\n\/\/ items []T means:\n\/\/     a slice containing values of type T\n\/\/\n\/\/ target T means:\n\/\/     the value we are searching for must also be type T\n\/\/\n\/\/ bool means:\n\/\/     the function returns true or false\nfunc Contains[T comparable](items []T, target T) bool {\n\n\t\/\/ item automatically has type T.\n\tfor _, item := range items {\n\n\t\t\/\/ This works because T is \"comparable\".\n\t\tif item == target {\n\t\t\treturn true\n\t\t}\n\t}\n\n\treturn false\n}\n\nfunc main() {\n\n\t\/\/ -------------------------\n\t\/\/ Example 1: int\n\t\/\/ -------------------------\n\n\tnumbers := []int{10, 20, 30, 40}\n\n\tfmt.Println(Contains(numbers, 20))\n\t\/\/ Output: true\n\n\tfmt.Println(Contains(numbers, 99))\n\t\/\/ Output: false\n\n\n\t\/\/ -------------------------\n\t\/\/ Example 2: string\n\t\/\/ -------------------------\n\n\tnames := []string{\"Alice\", \"Bob\", \"Charlie\"}\n\n\tfmt.Println(Contains(names, \"Bob\"))\n\t\/\/ Output: true\n\n\tfmt.Println(Contains(names, \"David\"))\n\t\/\/ Output: false\n}\n<\/code><\/pre>\n\n\n\n
Output<\/h3>\n\n\n\n
true\nfalse\ntrue\nfalse\n<\/code><\/pre>\n\n\n\n
\n\n\n\n
4. How does it work?<\/h1>\n\n\n\n
The most important line is:<\/p>\n\n\n\n
func Contains[T comparable](items []T, target T) bool\n<\/code><\/pre>\n\n\n\n
Break it into pieces.<\/p>\n\n\n\n
Part<\/th>Meaning<\/th><\/tr><\/thead>
func<\/code><\/td>Create a function<\/td><\/tr>
Contains<\/code><\/td>Function name<\/td><\/tr>
[T comparable]<\/code><\/td>Declare generic type T<\/code><\/td><\/tr>
T<\/code><\/td>Placeholder for a real type<\/td><\/tr>
comparable<\/code><\/td>Restricts T to types supporting ==<\/code> and !=<\/code><\/td><\/tr>
items []T<\/code><\/td>Slice containing T values<\/td><\/tr>
target T<\/code><\/td>Value of the same type T<\/td><\/tr>
bool<\/code><\/td>Function returns true or false<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
The generic-specific part is:<\/p>\n\n\n\n
[T comparable]\n<\/code><\/pre>\n\n\n\n
You can mentally read it as:<\/p>\n\n\n\n
\n
“This function works with some type called T<\/code>, as long as values of T can be compared.”<\/p>\n<\/blockquote>\n\n\n\n
\n\n\n\n
5. What is T<\/code>?<\/h1>\n\n\n\n
T<\/code> is simply a type parameter<\/strong>.<\/p>\n\n\n\n
It is a placeholder for a real type.<\/p>\n\n\n\n
For example:<\/p>\n\n\n\n
Contains(numbers, 20)\n<\/code><\/pre>\n\n\n\n
numbers<\/code> is:<\/p>\n\n\n\n
[]int\n<\/code><\/pre>\n\n\n\n
So Go understands:<\/p>\n\n\n\n
T = int\n<\/code><\/pre>\n\n\n\n
Therefore, conceptually, the function behaves like:<\/p>\n\n\n\n
func Contains(items []int, target int) bool\n<\/code><\/pre>\n\n\n\n
But then we call:<\/p>\n\n\n\n
Contains(names, \"Bob\")\n<\/code><\/pre>\n\n\n\n
names<\/code> is:<\/p>\n\n\n\n
[]string\n<\/code><\/pre>\n\n\n\n
So now Go understands:<\/p>\n\n\n\n
T = string\n<\/code><\/pre>\n\n\n\n
Conceptually:<\/p>\n\n\n\n
func Contains(items []string, target string) bool\n<\/code><\/pre>\n\n\n\n
You wrote one function<\/strong>, but Go can safely use it with different types.<\/p>\n\n\n\n
\n\n\n\n
6. Type inference<\/h1>\n\n\n\n
Notice that we wrote:<\/p>\n\n\n\n
Contains(numbers, 20)\n<\/code><\/pre>\n\n\n\n
We did not<\/strong> write:<\/p>\n\n\n\n
Contains[int](numbers, 20)\n<\/code><\/pre>\n\n\n\n
Both forms are possible:<\/p>\n\n\n\n
Contains[int](numbers, 20)\n<\/code><\/pre>\n\n\n\n
But normally you don’t need to specify int<\/code>.<\/p>\n\n\n\n
Go looks at:<\/p>\n\n\n\n
numbers\n<\/code><\/pre>\n\n\n\n
and sees:<\/p>\n\n\n\n
[]int\n<\/code><\/pre>\n\n\n\n
so it automatically determines:<\/p>\n\n\n\n
T = int\n<\/code><\/pre>\n\n\n\n
This is called type inference<\/strong>.<\/p>\n\n\n\n
\n\n\n\n
7. What is comparable<\/code>?<\/h1>\n\n\n\n
Look again:<\/p>\n\n\n\n
[T comparable]\n<\/code><\/pre>\n\n\n\n
comparable<\/code> is a built-in Go constraint.<\/p>\n\n\n\n
It means:<\/p>\n\n\n\n
\n
T must be a type that can be compared using ==<\/code> and !=<\/code>.<\/p>\n<\/blockquote>\n\n\n\n
For example:<\/p>\n\n\n\n
10 == 20\n<\/code><\/pre>\n\n\n\n
valid.<\/p>\n\n\n\n
\"Alice\" == \"Bob\"\n<\/code><\/pre>\n\n\n\n
valid.<\/p>\n\n\n\n
true == false\n<\/code><\/pre>\n\n\n\n
valid.<\/p>\n\n\n\n
Therefore these types work well with our function:<\/p>\n\n\n\n
int\nstring\nbool\nfloat64\n<\/code><\/pre>\n\n\n\n
Our function contains:<\/p>\n\n\n\n
if item == target\n<\/code><\/pre>\n\n\n\n
So Go needs to know that T<\/code> supports ==<\/code>.<\/p>\n\n\n\n
That is why we use:<\/p>\n\n\n\n
comparable\n<\/code><\/pre>\n\n\n\n
instead of:<\/p>\n\n\n\n
any\n<\/code><\/pre>\n\n\n\n
\n\n\n\n
8. What is any<\/code>?<\/h1>\n\n\n\n
Another very common generic constraint is:<\/p>\n\n\n\n
any\n<\/code><\/pre>\n\n\n\n
Example syntax:<\/p>\n\n\n\n
func Something[T any](value T)\n<\/code><\/pre>\n\n\n\n
any<\/code> means:<\/p>\n\n\n\n
\n
T can be any type.<\/p>\n<\/blockquote>\n\n\n\n
The difference is:<\/p>\n\n\n\n
Constraint<\/th>Meaning<\/th><\/tr><\/thead>
T any<\/code><\/td>T can be practically any Go type<\/td><\/tr>
T comparable<\/code><\/td>T must support ==<\/code> and !=<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
Our function needs:<\/p>\n\n\n\n
item == target\n<\/code><\/pre>\n\n\n\n
Therefore:<\/p>\n\n\n\n
comparable\n<\/code><\/pre>\n\n\n\n
is the correct choice.<\/p>\n\n\n\n
\n\n\n\n
9. Visual Model<\/h1>\n\n\n\n
flowchart LR\n    A[\"Contains(numbers, 20)\"] --> B[\"Go sees []int\"]\n    B --> C[\"T = int\"]\n\n    D[\"Contains(names, 'Bob')\"] --> E[\"Go sees []string\"]\n    E --> F[\"T = string\"]\n\n    C --> G[\"Same Contains function\"]\n    F --> G\n<\/code><\/pre>\n\n\n\n
Think of T<\/code> as an empty type slot.<\/p>\n\n\n\n
First call:<\/p>\n\n\n\n
T \u2192 int\n<\/code><\/pre>\n\n\n\n
Second call:<\/p>\n\n\n\n
T \u2192 string\n<\/code><\/pre>\n\n\n\n
Same algorithm.<\/p>\n\n\n\n
Different types.<\/p>\n\n\n\n
\n\n\n\n
10. Why not just use any<\/code> everywhere?<\/h1>\n\n\n\n
Before generics, code sometimes accepted values using:<\/p>\n\n\n\n
interface{}\n<\/code><\/pre>\n\n\n\n
Modern Go has the equivalent alias:<\/p>\n\n\n\n
any\n<\/code><\/pre>\n\n\n\n
You could write something like:<\/p>\n\n\n\n
func Something(value any)\n<\/code><\/pre>\n\n\n\n
but now the function does not preserve much information about the actual type.<\/p>\n\n\n\n
Generics are different.<\/p>\n\n\n\n
Consider:<\/p>\n\n\n\n
func Contains[T comparable](items []T, target T)\n<\/code><\/pre>\n\n\n\n
The compiler knows that:<\/p>\n\n\n\n
items contains T\ntarget is T\n<\/code><\/pre>\n\n\n\n
The two values must therefore agree on their type.<\/p>\n\n\n\n
That relationship is one of the major benefits of generics.<\/p>\n\n\n\n
\n\n\n\n
11. Normal Functions vs any<\/code> vs Generics<\/h1>\n\n\n\n
Feature<\/th>Concrete Function<\/th>any<\/code> \/ interface{}<\/code><\/th>Generics<\/th><\/tr><\/thead>
Works with multiple types<\/td>\u274c<\/td>\u2705<\/td>\u2705<\/td><\/tr>
Preserves type relationships<\/td>\u2705<\/td>\u274c<\/td>\u2705<\/td><\/tr>
Compile-time type checking<\/td>\u2705<\/td>Limited for operations on underlying values<\/td>\u2705<\/td><\/tr>
Often requires type assertions<\/td>\u274c<\/td>\u2705<\/td>\u274c<\/td><\/tr>
Avoids duplicate algorithms<\/td>\u274c<\/td>\u2705<\/td>\u2705<\/td><\/tr>
Good choice for reusable algorithms<\/td>Sometimes<\/td>Sometimes<\/td>\u2705<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
For example, if an algorithm should work identically for:<\/p>\n\n\n\n
[]int\n[]string\n[]float64\n<\/code><\/pre>\n\n\n\n
generics are often a natural solution.<\/p>\n\n\n\n
\n\n\n\n
12. When should you use Generics?<\/h1>\n\n\n\n
Use generics when the same algorithm<\/strong> needs to work with several types.<\/p>\n\n\n\n
Good examples include:<\/p>\n\n\n\n
Contains\nMin\nMax\nFilter\nMap\nStack\nQueue\nSet\n<\/code><\/pre>\n\n\n\n
For example:<\/p>\n\n\n\n
Contains int\nContains string\nContains float64\n<\/code><\/pre>\n\n\n\n
is a strong signal that generics may help.<\/p>\n\n\n\n
Instead of:<\/p>\n\n\n\n
ContainsInt()\nContainsString()\nContainsFloat()\n<\/code><\/pre>\n\n\n\n
you can have:<\/p>\n\n\n\n
Contains()\n<\/code><\/pre>\n\n\n\n
\n\n\n\n
13. When should you NOT use Generics?<\/h1>\n\n\n\n
Don’t use generics simply because they exist.<\/p>\n\n\n\n
If your function only works with strings:<\/p>\n\n\n\n
func NormalizeUsername(name string) string\n<\/code><\/pre>\n\n\n\n
there is usually no reason to change it to:<\/p>\n\n\n\n
func NormalizeUsername[T ...]\n<\/code><\/pre>\n\n\n\n
Keep the concrete version.<\/p>\n\n\n\n
A useful rule is:<\/p>\n\n\n\n
\n
Use generics when the algorithm is the same but the data type changes.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
\n\n\n\n
14. Where are Generics commonly used?<\/h1>\n\n\n\n
You will commonly encounter generics in:<\/p>\n\n\n\n
Reusable utility functions\nCollections\nStacks\nQueues\nSets\nData structures\nAlgorithms\nLibraries\nContainer types\nReusable APIs\n<\/code><\/pre>\n\n\n\n
For example, a stack could hold:<\/p>\n\n\n\n
Stack[int]\n\nStack[string]\n\nStack[User]\n<\/code><\/pre>\n\n\n\n
while sharing one stack implementation.<\/p>\n\n\n\n
\n\n\n\n
15. The syntax you really need to remember<\/h1>\n\n\n\n
Start with this pattern:<\/p>\n\n\n\n
func FunctionName[T constraint](value T) {\n}\n<\/code><\/pre>\n\n\n\n
Example:<\/p>\n\n\n\n
func Print[T any](value T) {\n\tfmt.Println(value)\n}\n<\/code><\/pre>\n\n\n\n
Or when comparison is required:<\/p>\n\n\n\n
func Contains[T comparable](items []T, target T) bool {\n}\n<\/code><\/pre>\n\n\n\n
The important pattern is:<\/p>\n\n\n\n
[T constraint]\n<\/code><\/pre>\n\n\n\n
where:<\/p>\n\n\n\n
T\n\u2502\n\u2514\u2500\u2500 type parameter\n\nconstraint\n\u2502\n\u2514\u2500\u2500 tells Go what T is allowed to be\n<\/code><\/pre>\n\n\n\n
\n\n\n\n
16. Mental Model<\/h1>\n\n\n\n
Whenever you see:<\/p>\n\n\n\n
[T comparable]\n<\/code><\/pre>\n\n\n\n
don’t make it complicated.<\/p>\n\n\n\n
Read it as:<\/p>\n\n\n\n
\n
“T represents a type.”<\/p>\n<\/blockquote>\n\n\n\n
Then:<\/p>\n\n\n\n
items []T\n<\/code><\/pre>\n\n\n\n
means:<\/p>\n\n\n\n
\n
“items is a slice of that type.”<\/p>\n<\/blockquote>\n\n\n\n
And:<\/p>\n\n\n\n
target T\n<\/code><\/pre>\n\n\n\n
means:<\/p>\n\n\n\n
\n
“target must be that same type.”<\/p>\n<\/blockquote>\n\n\n\n
So:<\/p>\n\n\n\n
func Contains[T comparable](items []T, target T) bool\n<\/code><\/pre>\n\n\n\n
means:<\/p>\n\n\n\n
\n
Create a Contains function that works with any comparable type, where the slice and target use the same type.<\/strong><\/p>\n<\/blockquote>\n\n\n\n
\n\n\n\n
17. Generics in one picture<\/h1>\n\n\n\n
WITHOUT GENERICS\n\n[]int     \u2500\u2500\u2192 ContainsInt()\n[]string  \u2500\u2500\u2192 ContainsString()\n[]float64 \u2500\u2500\u2192 ContainsFloat()\n\n\nWITH GENERICS\n\n[]int      \u2500\u2510\n[]string    \u251c\u2500\u2500\u2192 Contains[T]()\n[]float64   \u2518\n<\/code><\/pre>\n\n\n\n
One implementation.<\/p>\n\n\n\n
Multiple types.<\/p>\n\n\n\n
\n\n\n\n
18. What \/ Why \/ When \/ How \/ Where Summary<\/h1>\n\n\n\n
Question<\/th>Answer<\/th><\/tr><\/thead>
What?<\/strong><\/td>Generics let functions and types work with multiple data types.<\/td><\/tr>
Why?<\/strong><\/td>To avoid writing the same algorithm repeatedly for different types.<\/td><\/tr>
When?<\/strong><\/td>When the logic stays the same but the type changes.<\/td><\/tr>
How?<\/strong><\/td>Declare a type parameter such as [T any]<\/code> or [T comparable]<\/code>.<\/td><\/tr>
Where?<\/strong><\/td>Utility functions, algorithms, collections and reusable data structures.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
\n\n\n\n
19. Three things to remember<\/h1>\n\n\n\n
If you remember only three things, remember these:<\/p>\n\n\n\n
1. T<\/code> is a placeholder for a type<\/h3>\n\n\n\n
[T ...]\n<\/code><\/pre>\n\n\n\n
Think:<\/p>\n\n\n\n
T = some type\n<\/code><\/pre>\n\n\n\n
2. A constraint controls what T can be<\/h3>\n\n\n\n
[T any]\n<\/code><\/pre>\n\n\n\n
means almost any type.<\/p>\n\n\n\n
[T comparable]\n<\/code><\/pre>\n\n\n\n
means types supporting:<\/p>\n\n\n\n
==\n!=\n<\/code><\/pre>\n\n\n\n
3. Generics are useful when logic stays the same<\/h3>\n\n\n\n
Instead of:<\/p>\n\n\n\n
ContainsInt\nContainsString\nContainsFloat\n<\/code><\/pre>\n\n\n\n
write:<\/p>\n\n\n\n
Contains[T]\n<\/code><\/pre>\n\n\n\n
\n\n\n\n
Final Takeaway<\/h1>\n\n\n\n
The core idea of Go generics is extremely simple:<\/p>\n\n\n\n
Same logic\n+\nDifferent types\n=\nGenerics\n<\/code><\/pre>\n\n\n\n
For this example:<\/p>\n\n\n\n
func Contains[T comparable](items []T, target T) bool\n<\/code><\/pre>\n\n\n\n
T<\/code> changes:<\/p>\n\n\n\n
T = int\nT = string\nT = bool\n...\n<\/code><\/pre>\n\n\n\n
while the Contains<\/code> algorithm stays exactly the same.<\/p>\n\n\n\n
Once this idea feels natural, the more advanced parts of Go generics\u2014generic structs, multiple type parameters, custom constraints, type sets, and ~<\/code> constraints<\/strong>\u2014become much easier to understand.<\/p>\n","protected":false},"excerpt":{"rendered":"
1. What are Generics? Generics let you write one piece of code that works with multiple types while keeping Go’s compile-time type safety. Suppose you want a… <\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[],"class_list":["post-1092","post","type-post","status-publish","format-standard","hentry","category-uncategorized"],"_links":{"self":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1092","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/comments?post=1092"}],"version-history":[{"count":1,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1092\/revisions"}],"predecessor-version":[{"id":1093,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/posts\/1092\/revisions\/1093"}],"wp:attachment":[{"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/media?parent=1092"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/categories?post=1092"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.devopsschool.com\/tutorials\/wp-json\/wp\/v2\/tags?post=1092"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}