--- title: What's New With Golang Generics | daily.dev description: An overview of how Go generics have evolved since their introduction in Go 1.18, covering generic type aliases (Go 1.24), recursive type constraints (Go 1.26),... canonical: https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: What's New With Golang Generics | daily.dev og:description: An overview of how Go generics have evolved since their introduction in Go 1.18, covering generic type aliases (Go 1.24), recursive type constraints (Go 1.26),... og:url: https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz og:image: https://api.daily.dev/og/posts/vXXAdjRrZ.png og:image:alt: What's New With Golang Generics og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # What's New With Golang Generics **[DoltHub Blog](https://daily.dev/sources/dolthub-blog)** · 8 min read · 18 upvotes · 2 comments ## Summary An overview of how Go generics have evolved since their introduction in Go 1.18, covering generic type aliases (Go 1.24), recursive type constraints (Go 1.26), and generic methods (arriving in Go 1.27). The author, who maintains the Dolt database written in Go, examines each feature's mechanics and assesses whether Dolt's codebase has adopted them, concluding that while none have been used yet, recursive type constraints and generic methods are likely candidates for future refactors. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Questions this post answers ### What does Go 1.26 add for recursive type constraints in generics? Go 1.26 allows a type parameter to be used within its own type constraint, enabling definitions like type Lattice[T Lattice[T]] interface. Previously this pattern, similar to the curiously recurring template pattern in other languages, was invalid; developers had to use a looser constraint such as T any instead, which worked but documented intent less clearly and allowed unrelated types to satisfy the interface. _Track how Go generics evolve release by release on daily.dev before refactoring interface constraints._ ### Can Go methods use their own generic type parameters as of Go 1.27? Yes, starting with Go 1.27, types can implement generic methods with their own type parameters, something not allowed in earlier versions. The restriction exists because these generic methods cannot participate in satisfying interface constraints, since Go's structural typing makes it hard for the compiler to reason about which interfaces a type implements when methods are generic. _Developers weighing when to migrate helper functions to generic methods can follow Go 1.27 changes on daily.dev._ ### When were generic type aliases added to Go and what problem do they solve? Generic type aliases were added in Go 1.24, allowing syntax like type Set[T comparable] = map[T]struct{}, which was invalid before. They don't add new expressiveness but reduce repetition when a specific type is repeatedly used for some of a generic's type parameters, letting developers partially specialize a generic type once instead of rewriting it each time. _Anyone deciding whether generic type aliases fit their Go codebase can compare real adoption experiences on daily.dev._ ## Community discussion Top comments from developers on daily.dev. **@pdfopsdev** · 1 upvotes > recursive constraints are neat on paper but 'improves documentation of intent' is doing a lot of work in that sentence. if it's not changing what the compiler can actually check, it's really just an annotation, generic methods not satisfying interfaces is the one that'll trip people up in practice. **@agustinbarrientos** · 0 upvotes > I think generic type aliases should wait for a second real partial specialization. A single use site fails to justify another name reviewers have to trace back to the constraint. ## Similar posts on daily.dev - [Issue \#603: Generic methods are a-go for Go 1.27 — Go Weekly](https://daily.dev/posts/issue-603-generic-methods-are-a-go-for-go-1-27-go-weekly-ehaxmaayq) · Golang Weekly · 9 upvotes · 0 comments - [Generic methods approved for Go, devs miss other features](https://daily.dev/posts/generic-methods-approved-for-go-devs-miss-other-features-qixdankxo) · The Register · 22 upvotes · 0 comments - [Golang proposal: container/: generic collection types](https://daily.dev/posts/golang-proposal-container-generic-collection-types-hmnqb6rbk) · Hacker News · 4 upvotes · 0 comments --- Tags: [#golang](https://daily.dev/tags/golang), [#type-systems](https://daily.dev/tags/type-systems) [View this post on daily.dev](https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"What's New With Golang Generics","url":"https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz"},"datePublished":"2026-08-17T22:14:46.824Z","dateModified":"2026-09-14T08:57:22.634Z","description":"An overview of how Go generics have evolved since their introduction in Go 1.18, covering generic type aliases (Go 1.24), recursive type constraints (Go 1.26),...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/439b6647493b9bc53493e59bd9cca03a?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/439b6647493b9bc53493e59bd9cca03a?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"DoltHub Blog","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"DoltHub Blog","logo":"https://media.daily.dev/image/upload/s--LXDlvjS4--/f_auto,q_auto/v1780213587/logos/dolthub-blog?_a=BAMAMiWQ0","url":"https://daily.dev/sources/dolthub-blog"},"commentCount":2,"discussionUrl":"https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":18},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":2}],"keywords":"golang,type-systems","timeRequired":"PT8M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"DoltHub Blog","item":"https://daily.dev/sources/dolthub-blog"},{"@type":"ListItem","position":3,"name":"What's New With Golang Generics"}]} {"@context":"https://schema.org","@type":"WebPage","@id":"https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz","comment":[{"@type":"Comment","text":"recursive constraints are neat on paper but ‘improves documentation of intent’ is doing a lot of work in that sentence. if it’s not changing what the compiler can actually check, it’s really just an annotation, generic methods not satisfying interfaces is the one that’ll trip people up in practice.","datePublished":"2026-08-20T18:05:35.630Z","url":"https://daily.dev/posts/vXXAdjRrZ#c-kBylwF3V1","author":{"@type":"Person","name":"PDFops","url":"https://daily.dev/pdfopsdev","image":"https://media.daily.dev/image/upload/s---8isRBKc--/f_auto/v1782922291/avatars/avatar_orjMeK8QKaaVZwGq7ScPz?_a=BAMAMicg0"},"interactionStatistic":{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":1}},{"@type":"Comment","text":"I think generic type aliases should wait for a second real partial specialization. A single use site fails to justify another name reviewers have to trace back to the constraint.","datePublished":"2026-08-26T20:39:44.281Z","url":"https://daily.dev/posts/vXXAdjRrZ#c-yytjI51Qx","author":{"@type":"Person","name":"Agustin Barrientos","url":"https://daily.dev/agustinbarrientos","image":"https://media.daily.dev/image/upload/s--5ayxQnqn--/f_auto/v1788281802/avatars/avatar_wQYYVe5Tbj0NJ7C7qPoa8?_a=BAMAMicg0"}}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/what-s-new-with-golang-generics-vxxadjrrz#faq","mainEntity":[{"@type":"Question","name":"What does Go 1.26 add for recursive type constraints in generics?","acceptedAnswer":{"@type":"Answer","text":"Go 1.26 allows a type parameter to be used within its own type constraint, enabling definitions like type Lattice[T Lattice[T]] interface. Previously this pattern, similar to the curiously recurring template pattern in other languages, was invalid; developers had to use a looser constraint such as T any instead, which worked but documented intent less clearly and allowed unrelated types to satisfy the interface. Track how Go generics evolve release by release on daily.dev before refactoring interface constraints."}},{"@type":"Question","name":"Can Go methods use their own generic type parameters as of Go 1.27?","acceptedAnswer":{"@type":"Answer","text":"Yes, starting with Go 1.27, types can implement generic methods with their own type parameters, something not allowed in earlier versions. The restriction exists because these generic methods cannot participate in satisfying interface constraints, since Go's structural typing makes it hard for the compiler to reason about which interfaces a type implements when methods are generic. Developers weighing when to migrate helper functions to generic methods can follow Go 1.27 changes on daily.dev."}},{"@type":"Question","name":"When were generic type aliases added to Go and what problem do they solve?","acceptedAnswer":{"@type":"Answer","text":"Generic type aliases were added in Go 1.24, allowing syntax like type Set[T comparable] = map[T]struct{}, which was invalid before. They don't add new expressiveness but reduce repetition when a specific type is repeatedly used for some of a generic's type parameters, letting developers partially specialize a generic type once instead of rewriting it each time. Anyone deciding whether generic type aliases fit their Go codebase can compare real adoption experiences on daily.dev."}}]} ```