ArbitraryType and its existence

// ArbitraryType is here for the purposes of documentation only and is not actually
// part of the unsafe package. It represents the type of an arbitrary Go expression.
type ArbitraryType int

I see there is a type declaration for ArbitraryType in the unsafe package, yet the comment reads as …and is not actually part of the unsafe package…

And we also have a type Pointer which seem to be a type alias of ArbitraryType which itself looks like a type alias of int, so what does ArbitraryType actually represent, its purpose and meaning? Thanks.

It’s a placeholder. unsafe.Pointer's definition is:

type Pointer *ArbitraryType

Because it’s a pointer to an arbitrary type, not an arbitrary type itself. ArbitraryType could have been defined as T and then Pointer as *T, but then people would have asked “what’s ‘T’?”

They wanted to show something there to show that the unsafe.Pointer type is a pointer type and not some opaque type like string, a slice, map, etc…

Thanks, so when someone does a conversion like Pointer(&objectOfSomeType) will it get casted to int* / *int?

As I see…

type Pointer which seem to be a type alias of ArbitraryType which itself looks like a type alias of int

Another question, why not just type Pointer *int?

No. ArbitraryType, like the documentation says, is just there for documentation purposes. In the documentation, they could have said:

type ArbitraryType *byte


type ArbitraryType *bool

etc. unsafe.Pointer is only defined as type unsafe.Pointer *ArbitraryType in the documentation. It’s dereferenced type isn’t actually ArbitraryType.

The thing with every pointer type except for unsafe.Pointer, is that they have an underlying type. If you have a *string, you can dereference it and get a string, same with *int -> int. unsafe.Pointer isn’t like that. It’s “unsafe.” You cannot dereference it because type type system has no idea what’s on the other side. Maybe it’s a pointer to a string, maybe to an int, maybe a [0]byte, etc…

It’s similar to interface{} in that the type system doesn’t “know” what’s in it. The difference is an interface{} includes runtime information so that at runtime, you can deduce what value is contained in the interface{} with a type assertion. unsafe.Pointer is just a pointer to *something* in memory and does not include that runtime type information, so you can’t type assert unsafe.Pointers.

This topic was automatically closed 90 days after the last reply. New replies are no longer allowed.