Why isn't unsafe.Sizeof constant for generic types?
99 views
Skip to first unread message
monadix
Aug 20, 2025, 2:55:34 PMAug 20
to golang-nuts
As far as I know all the implementations of go do monomorphization of generic parameters at least by the memory layout of used types. This means that while not everything is known about the type at compile-time, at least it's size surely is. And we easily can create new types containing generic fields like that:
```go
type Foo[T any] struct {
foo T
}
```
which means Foo size in bytes depends on the size of generic parameter T.
Also since some builtin functions are usable in constant context, we can actually create static arrays of size of some particular type resolved in compile-time like that:
```go
type Bar struct {
bar [unsafe.Sizeof(uint64(0))]bytes
}
```
But we cannot define types, which memory layout depends on the generic type parameter in more complex ways (but still using only constant functions) like that:
```go
type Baz[T any] struct {
baz [unsafe.Sizeof(*new(T))]byte
}
```
because:
```
array length unsafe.Sizeof(*new(T)) (value of type uintptr) must be constant
```
But isn't it already? Sure it depends on the particular T passed to the type, but it will be monomorphized by size anyway and (if compiled) would have exactly the same memory layout as Foo[T].
Why exactly isn't it possible in the current (I use go 1.24.5) compiler? Is it simply unimplemented, impossible for some unknown to me reason (would like to read the actual explaination) or undesirable and forbidden (also, why?)?
```go
type Foo[T any] struct {
foo T
}
```
which means Foo size in bytes depends on the size of generic parameter T.
Also since some builtin functions are usable in constant context, we can actually create static arrays of size of some particular type resolved in compile-time like that:
```go
type Bar struct {
bar [unsafe.Sizeof(uint64(0))]bytes
}
```
But we cannot define types, which memory layout depends on the generic type parameter in more complex ways (but still using only constant functions) like that:
```go
type Baz[T any] struct {
baz [unsafe.Sizeof(*new(T))]byte
}
```
because:
```
array length unsafe.Sizeof(*new(T)) (value of type uintptr) must be constant
```
But isn't it already? Sure it depends on the particular T passed to the type, but it will be monomorphized by size anyway and (if compiled) would have exactly the same memory layout as Foo[T].
Why exactly isn't it possible in the current (I use go 1.24.5) compiler? Is it simply unimplemented, impossible for some unknown to me reason (would like to read the actual explaination) or undesirable and forbidden (also, why?)?
Axel Wagner
Aug 20, 2025, 3:03:09 PMAug 20
to monadix, golang-nuts
On Wed, 20 Aug 2025 at 20:55, monadix <arseni...@gmail.com> wrote:
Why exactly isn't it possible in the current (I use go 1.24.5) compiler? Is it simply unimplemented, impossible for some unknown to me reason (would like to read the actual explaination) or undesirable and forbidden (also, why?)?
It isn't exactly impossible, but it would likely require a SAT solver to make type-checking precise:
The comment links to a few other discussions which explain the problem in more detail, but that's the issue where we decided on the current semantics.
--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.
To view this discussion visit https://groups.google.com/d/msgid/golang-nuts/01b8ebdb-c386-460c-ac09-596605bf4f18n%40googlegroups.com.
Reply all
Reply to author
Forward
0 new messages