skip to content

What can you write with a parameterized type alias like type Set[T comparable] = map[T]struct{} that older Go rejected?

level: middleimportance: nice to knowfreq 20%

answer

  1. an alias that takes brackets
  2. only possible in recent Go
  3. identical, so nothing to convert
  4. still no place to hang a method

basics

~10 s

Go 1.24 lets a type alias declare its own type parameters, so type Set[T comparable] = map[T]struct{} finally compiles. Set[string] is identical to map[string]struct{}: no conversion, and still no method set of its own.

solid answer

~50 s

Before Go 1.24 a type alias could not take type parameters at all — `type Set[T comparable] = map[T]struct{}` was a compile error. You had to spell the full type out everywhere, or declare a *defined* generic type, `type Set[T comparable] map[T]struct{}`, which is a new distinct type with its own method set and its own conversions. Go 1.24 supports generic aliases fully, and they keep alias semantics: `Set[string]` is *identical* to `map[string]struct{}`, so values pass in both directions with no conversion, a function taking one accepts the other, and you still cannot declare methods on `Set`, because the type it names is not declared in your package. The uses are the same as for any alias, now available for parameterized types: a short readable name for a long instantiated type in signatures, and a compatibility shim while a generic type moves between packages, written `type Handler[T any] = newpkg.Handler[T]`.

code

go · 9 lines
go
type Set[T comparable] = map[T]struct{} // Go 1.24 and later

func add[T comparable](s Set[T], v T) { s[v] = struct{}{} }

func demo() {
	m := map[string]struct{}{}
	add(m, "a") // no conversion: m is exactly Set[string]
	_ = len(m)
}

go deeper

for a junior

Know that an alias gives an existing type another name, and that recent Go lets that name take type parameters. You are unlikely to be pushed past that.

for a middle

Explain that instantiating the alias substitutes into the right-hand side and yields an identical type, and contrast that with a defined generic type that has its own method set.

for a senior

Show where it pays off in practice: shortening long instantiated types and, above all, leaving a compatible shim when a generic type moves package, which was impossible before.

for a principal

Weigh the toolchain floor the feature imposes on every consumer of a shared package against the migration flexibility it buys, and decide when the team adopts it.

## What changed A type alias binds a second name to an existing type. Until Go 1.24, that name had to be a plain identifier: the alias itself could not declare type parameters. You could write an alias to an *instantiated* generic type — ```go type StringSet = map[string]struct{} ``` — but not one that stayed parameterized: ```go type Set[T comparable] = map[T]struct{} // rejected before Go 1.24 ``` Go 1.24 added full support for generic type aliases, and the semantics are exactly what an alias should mean, extended to parameters: instantiating the alias yields the type on the right-hand side with the arguments substituted. `Set[string]` *is* `map[string]struct{}` — the same type, not a similar one. ## Alias versus defined generic type This is the same distinction as in the non-generic case, and it decides everything you can do with the result. ```go type AliasSet[T comparable] = map[T]struct{} // alias: identical to the map type type DefSet[T comparable] map[T]struct{} // definition: a new named type ``` - **Identity.** `AliasSet[string]` and `map[string]struct{}` are the same type; a function taking either accepts the other with no conversion. `DefSet[string]` is a distinct type and callers must convert at the boundary. - **Methods.** You cannot declare a method on `AliasSet`; there is no new type to attach it to. You *can* declare `func (s DefSet[T]) Add(v T)`, and that is normally the reason to define the type. - **Interfaces.** Because it is a distinct type with its own method set, only the defined type can be given behaviour that satisfies an interface. - **Documentation and reflection.** An alias is transparent: `%T` and `reflect` report the underlying map type; go-to-definition jumps to the real declaration. So the rule of thumb carries over unchanged. Reach for the alias when you want *the same type, shorter or elsewhere*; declare a type when you want *a new type with behaviour*. ## Where a generic alias actually earns its keep **Readability in signatures.** A long instantiated type repeated across a package — something like `map[string][]Record[time.Time]` — is easier to read behind a parameterized alias, and because the alias is transparent no caller has to know it exists or convert anything. **Package moves.** This is the strongest case. When a generic type moves to a new package, leaving `type Cache[K comparable, V any] = newpkg.Cache[K, V]` behind means the old and new spellings denote one type, so a package that has migrated and one that has not can still hand values to each other. Before generic aliases existed there was no way to leave a compatible shim for a parameterized type, which made those refactors flag days. **Partial instantiation.** The alias's parameters are its own, and the right-hand side may use them anywhere and may also fill some in: `type IntCache[V any] = Cache[int, V]` pins one parameter and leaves the other open. That is a genuinely new expressive step, not just shorthand. ## Rules and gotchas - The constraints on the alias's parameters are the alias's own; you must satisfy them at the point of instantiation. `Set[func()]` fails because a function type is not `comparable`. - The alias adds no method set, so an alias can never be the thing that makes a type satisfy an interface. - Toolchain skew is real: a module whose `go` directive allows it and a developer on an older toolchain will see the declaration rejected outright rather than degrade gracefully, so agree on a minimum toolchain before scattering generic aliases through a shared package. - The transparency cuts both ways in review. A reader seeing `Set[string]` may not realise the parameter is only a spelling, so a doc comment naming the target type earns its place.

  • How does type Set[T comparable] = map[T]struct{} differ from type Set[T comparable] map[T]struct{}?
    The first is an alias: `Set[string]` is the same type as `map[string]struct{}`, values are interchangeable, and no method may be declared on it. The second defines a new generic type — you can give it `Add` and `Has` methods, but every value crossing a boundary that expects the raw map needs a conversion.
  • Can a generic alias pin some of the type parameters of the type it names?
    Yes. The parameters belong to the alias, and the right-hand side may use them anywhere or fill some in, so `type IntCache[V any] = Cache[int, V]` is legal: one parameter fixed, one still open. It is the most genuinely new thing generic aliases allow, beyond simple shorthand.
  • What happens if a teammate builds the package with an older toolchain?
    The declaration is rejected outright — it is a language change, not a library addition, so there is no graceful degradation. Using a generic alias in a shared package raises the minimum toolchain for everyone who builds it, which is worth stating in the module's go directive and in the team's build requirements.

  • Thinks a generic alias creates a new type that can have methods
  • Assumes aliases could always declare type parameters
  • Expects a conversion between Set[string] and the map type
  • Confuses a generic alias with a defined generic type in review

Generic type aliases - a type alias that declares its own type parameters - are supported from Go 1.24 (February 2025). Earlier toolchains reject the declaration outright, so a package using one raises the module's minimum toolchain.