What is the dereference operator of a type in Go generics?

When doing generics, one can create a pointer type from any type, see Pointer Method Example section in Types Parameter Proposal. Example:

type Pointer[T any] interface {
	*T // non-interface type constraint element
    // ... more constraints ...
}

How does one do the opposite, declare a dereference of a type ? Something like:

type Deref[T any] interface {
   ???T  // If T=="*int", this would refer to "int"
   ...
}

Thanks!

There is no such thing as a "dereference of a type".

Pointer types are composite types, i.e. you need a base type to begin with. You can't go the other way around.

What to do instead

If you want to force non-pointer types in a constraint, specify the non-pointer types:

// will disallow *int
type NonPointerInt interface {
    ~int
}

Notes

• the above is not generalizable to any T. Using ~T in a type set where T is a type parameter is explicitly disallowed: "Using ~T is not permitted if T is a type parameter or if T is an interface type".

• you may add more related types to the union, e.g. ~int | ~int32 | ~int64
  etc. With this you're getting closer to constraints.Signed or similar constraints offered by the standard lib

• you may add more (partially) unrelated types, e.g. ~int | ​~string but then you're reducing the operations you can do on values with such constraint.

<hr>

About the letter of your question, a pointer type *T is useful to achieve (arbitrary levels of) indirection from a base type, and it has a precise practical meaning, tied to the concept of a pointer as the address of a memory location. It's unclear what a hypothetical "dereference type" would be in practical terms, without using a circular definition.

You can only dereference pointer vaues, but not types. *T is not dereferencing the T type, *T is a type literal, composing a pointer type whose base type will be T.

The compiler only allows operations on values of type parameters that are allowed on the constrained types.

Using any, all types will be allowed, even non-pointer types, whose values cannot be dereferenced.

To dereference a value, it must be a pointer. One way is to specify a parameter to be of type *T like in this example:

func deref[T any](p *T) T {
    return *p
}

T can be of any type, but *T will surely be a pointer type, whose values can be dereferenced. Testing it:

p := &image.Point{1, 2}
x := deref(p)
log.Printf("%T %v\n", x, x)

p := new(int)
*p = 3
x := deref(p)
log.Printf("%T %v\n", x, x)

Output will be:

2009/11/10 23:00:00 image.Point (1,2)
2009/11/10 23:00:00 int 3

Another option is to use a constraint that allows only pointer types, for example only *int:

func deref2[T interface{ *int }](p T) {
	log.Printf("%T %v\n", *p, *p)
}

Testing it:

p := new(int)
*p = 4
deref2(p)

Output:

2009/11/10 23:00:00 int 4

Although using generics here has no use, you could just substitute T with *int, without type parameters.

Try the examples on the Go Playground.

i have just an answer for you
if you want to dereference pointer with generic and there may be a type which is not a pointer but still you want the zero value of that type then this solution will be best for you

    func Deref[T any](p *T) T {
	  if p != nil {
	  	return *p
	  }
	  var derefed T
	  return derefed
    }

With this function what happens is it checks if the given type is nil or not if it's nil then it will return zero value of the type so no need to worry about underlying type as long as it's a pointer.

if you pass the non pointer variable to function it will be compilation error so no need to worry about panic.

You can try code on Go Playground