mirror of
https://github.com/golang/go
synced 2024-11-26 15:27:04 -07:00
20050a15fe
A type may now have a type param in it, either because it has been composed from a function type param, or it has been declared as or derived from a reference to a generic type. No objects or types with type params can be exported yet. No generic type has a runtime descriptor (but will likely eventually be associated with a dictionary). types.Type now has an RParam field, which for a Named type can specify the type params (in order) that must be supplied to fully instantiate the type. Also, there is a new flag HasTParam to indicate if there is a type param (TTYPEPARAM) anywhere in the type. An instantiated generic type (whether fully instantiated or re-instantiated to new type params) is a defined type, even though there was no explicit declaration. This allows us to handle recursive instantiated types (and improves printing of types). To avoid the need to transform later in the compiler, an instantiation of a method of a generic type is immediately represented as a function with the method as the first argument. Added 5 tests on generic types to test/typeparams, including list.go, which tests recursive generic types. Change-Id: Ib7ff27abd369a06d1c8ea84edc6ca1fd74bbb7c2 Reviewed-on: https://go-review.googlesource.com/c/go/+/292652 Trust: Dan Scales <danscales@google.com> Trust: Robert Griesemer <gri@golang.org> Run-TryBot: Dan Scales <danscales@google.com> Reviewed-by: Robert Griesemer <gri@golang.org>
76 lines
1.5 KiB
Go
76 lines
1.5 KiB
Go
// run -gcflags=-G=3
|
|
|
|
// Copyright 2021 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import "fmt"
|
|
|
|
type value[T any] struct {
|
|
val T
|
|
}
|
|
|
|
func get[T2 any](v *value[T2]) T2 {
|
|
return v.val
|
|
}
|
|
|
|
func set[T any](v *value[T], val T) {
|
|
v.val = val
|
|
}
|
|
|
|
func (v *value[T2]) set(val T2) {
|
|
v.val = val
|
|
}
|
|
|
|
func (v *value[T2]) get() T2 {
|
|
return v.val
|
|
}
|
|
|
|
func main() {
|
|
var v1 value[int]
|
|
set(&v1, 1)
|
|
if got, want := get(&v1), 1; got != want {
|
|
panic(fmt.Sprintf("get() == %d, want %d", got, want))
|
|
}
|
|
|
|
v1.set(2)
|
|
if got, want := v1.get(), 2; got != want {
|
|
panic(fmt.Sprintf("get() == %d, want %d", got, want))
|
|
}
|
|
|
|
v1p := new(value[int])
|
|
set(v1p, 3)
|
|
if got, want := get(v1p), 3; got != want {
|
|
panic(fmt.Sprintf("get() == %d, want %d", got, want))
|
|
}
|
|
|
|
v1p.set(4)
|
|
if got, want := v1p.get(), 4; got != want {
|
|
panic(fmt.Sprintf("get() == %d, want %d", got, want))
|
|
}
|
|
|
|
var v2 value[string]
|
|
set(&v2, "a")
|
|
if got, want := get(&v2), "a"; got != want {
|
|
panic(fmt.Sprintf("get() == %q, want %q", got, want))
|
|
}
|
|
|
|
v2.set("b")
|
|
if got, want := get(&v2), "b"; got != want {
|
|
panic(fmt.Sprintf("get() == %q, want %q", got, want))
|
|
}
|
|
|
|
v2p := new(value[string])
|
|
set(v2p, "c")
|
|
if got, want := get(v2p), "c"; got != want {
|
|
panic(fmt.Sprintf("get() == %d, want %d", got, want))
|
|
}
|
|
|
|
v2p.set("d")
|
|
if got, want := v2p.get(), "d"; got != want {
|
|
panic(fmt.Sprintf("get() == %d, want %d", got, want))
|
|
}
|
|
}
|