我如何实例化与泛型Go类型参数的非nil指针?

既然类型参数在golang/go:master上可用，我决定尝试一下。似乎我遇到了一个限制，我无法在类型参数建议中找到。(或者我一定是错过了)。

我想写一个函数，它返回具有接口类型约束的泛型类型的值切片。如果传递的类型是带有指针接收者的实现，我们如何实例化它?

type SetGetter[V any] interface {
Set(V)
Get() V
}
// SetGetterSlice turns a slice of type V into a slice of type T,
// with T.Set() called for each entry in values.
func SetGetterSlice[V any, T SetGetter[V]](values []V) []T {
out := make([]T, len(values))
for i, v := range values {
out[i].Set(v) // panic if T has pointer receiver!
}
return out
}

当调用上述SetGetterSlice()函数时，*Count类型为T，此代码在调用Set(v)时会出现恐慌。(Go2go操场)毫不奇怪，因为基本上代码创建了一个nil指针的切片:


// Count implements SetGetter interface
type Count struct {
x int
}
func (c *Count) Set(x int) { c.x = x }
func (c *Count) Get() int  { return c.x }
func main() {
ints := []int{1, 2, 3, 4, 5}
sgs := SetGetterSlice[int, *Count](ints)

for _, s := range sgs {
fmt.Println(s.Get())
}
}

同一问题的变体

这个想法行不通，我似乎找不到任何简单的方法来实例化指向的值。

out[i] = new(T)将导致编译失败，因为它返回*T，而类型检查器希望看到T。
调用*new(T)，编译，但将导致相同的运行时恐慌，因为new(T)返回**Count在这种情况下，指针指向Count仍然是nil。
将返回类型更改为指向T的指针的切片将导致编译失败:

func SetGetterSlice[V any, T SetGetter[V]](values []V) []*T {
out := make([]*T, len(values))
for i, v := range values {
out[i] = new(T)
out[i].Set(v) // panic if T has pointer receiver
}
return out
}
func main() {
ints := []int{1, 2, 3, 4, 5}
SetGetterSlice[int, Count](ints)
// Count does not satisfy SetGetter[V]: wrong method signature
}

解决方案

到目前为止，我找到的唯一解决方案是要求将构造函数传递给泛型函数。但这感觉不对，而且有点乏味。如果func F(T interface{})() []T是完全有效的语法，为什么需要这样做?

func SetGetterSlice[V any, T SetGetter[V]](values []V, constructor func() T) []T {
out := make([]T, len(values))
for i, v := range values {
out[i] = constructor()
out[i].Set(v)
}
return out
}
// ...
func main() {
ints := []int{1, 2, 3, 4, 5}
SetGetterSlice[int, *Count](ints, func() *Count { return new(Count) })
}

总结我的问题，按优先顺序排列:

我是否忽略了一些明显的东西?
这是Go中泛型的限制，这是最好的吗?
这个限制是已知的还是我应该在Go项目中提出问题?

基本上，您必须向约束添加一个类型参数，以使T可转换为其指针类型。该技术的最基本形式如下(带有匿名约束):

func Foo[T any, PT interface { *T; M() }]() {
p := PT(new(T))
p.M() // calling method on non-nil pointer
}

游乐场:https://go.dev/play/p/L00tePwrDfx

逐级解

约束SetGetter已经声明了一个类型参数V，所以我们稍微修改一下上面的例子:

// V is your original type param
// T is the additional helper param
type SetGetter[V any, T any] interface {
Set(V)
Get() V
*T
}

然后使用类型参数T any定义SetGetterSlice函数，其目的只是实例化约束SetGetter。

您将能够将表达式&out[i]转换为指针类型，并成功调用指针接收器上的方法:

// T is the type with methods with pointer receiver
// PT is the SetGetter constraint with *T
func SetGetterSlice[V any, T any, PT SetGetter[V, T]](values []V) []T {
out := make([]T, len(values))
for i, v := range values {
// out[i] has type T
// &out[i] has type *T
// PT constraint includes *T
p := PT(&out[i]) // valid conversion!
p.Set(v)         // calling with non-nil pointer receiver
}
return out
}

完整的计划:

package main
import (
"fmt"
)
type SetGetter[V any, T any] interface {
Set(V)
Get() V
*T
}
func SetGetterSlice[V any, T any, PT SetGetter[V, T]](values []V) []T {
out := make([]T, len(values))
for i, v := range values {
p := PT(&out[i])
p.Set(v)
}
return out
}
// Count implements SetGetter interface
type Count struct {
x int
}
func (c *Count) Set(x int) { c.x = x }
func (c *Count) Get() int  { return c.x }
func main() {
ints := []int{1, 2, 3, 4, 5}
// instantiate with base type
sgs := SetGetterSlice[int, Count](ints)
for _, s := range sgs {
fmt.Println(s.Get()) // prints 1,2,3,4,5 each in a newline
}
}

这变得更加冗长，因为SetGetterSlice现在需要三个类型参数:原来的V加上T(带有指针接收器的类型)和PT(新的约束)。但是，在调用该函数时，可以省略第三个参数——通过类型推断，实例化PT SetGetter[V,T]所需的类型参数V和T都是已知的:

SetGetterSlice[int, Count](ints)

游乐场:https://go.dev/play/p/gcQZnw07Wp3

花了几个小时才理解。所以我决定加入我的例子。

package main
import (
"fmt"
)
type User struct {
FullName string
Removed  bool
}
type Account struct {
Name    string
Removed bool
}
type Scanner[T User | Account] interface {
Scan()
*T
}
type Model interface {
User | Account
}
func (user *User) Scan() {
user.FullName = `changed in scan method`
user.Removed = true
}
func (account *Account) Scan() {
account.Name = `changed in scan method`
account.Removed = true
}
func setRemovedState[T Model, PT Scanner[T]](state bool) *T {
var obj T
pointer := PT(&obj)
pointer.Scan() // calling method on non-nil pointer
return &obj
}
func main() {
user := setRemovedState[User](true)
account := setRemovedState[Account](true)
fmt.Printf("User: %vn", *user)
fmt.Printf("Account: %vn", *account)
}

您也可以尝试用稍微不同的方法来处理这个问题，以保持它的简单性。

package main
import (
"fmt"
)
func mapp[T any, V any](s []T, h func(T) V) []V {
z := make([]V, len(s))
for i, v := range s {
z[i] = h(v)
}
return z
}
func mappp[T any, V any](s []T, h func(T) V) []V {
z := make([]V, 0, len(s))
for _, v := range s {
z = append(z, h(v))
}
return z
}
// Count implements SetGetter interface
type Count struct {
x int
}
func (c *Count) Set(x int) { c.x = x }
func (c *Count) Get() int  { return c.x }
func FromInt(x int) *Count {
var out Count
out.x = x
return &out
}
func main() {
ints := []int{1, 2, 3, 4, 5}
sgs := mapp(ints, FromInt)
fmt.Printf("%Tn",sgs)
for _, s := range sgs {
fmt.Println(s.Get())
}
fmt.Println()
sgs = mappp(ints, FromInt)
fmt.Printf("%Tn",sgs)
for _, s := range sgs {
fmt.Println(s.Get())
}
}

https://go2goplay.golang.org/p/vzViKwiJJkZ

它就像你的func SetGetterSlice[V any, T SetGetter[V]](values []V, constructor func() T) []T，但没有复杂的冗长。它也没有给我任何麻烦来解决。

编辑:参见blackgreen的答案，我后来在浏览他们链接的相同文档时也发现了这个答案。我本来打算在此基础上编辑这个答案，但现在我不需要了。: -)

可能有一个更好的方法-这个似乎有点笨拙-但我能够解决这个问题与reflect:

if reflect.TypeOf(out[0]).Kind() == reflect.Ptr {
x := reflect.ValueOf(out).Index(i)
x.Set(reflect.New(reflect.TypeOf(out[0]).Elem()))
}

我只是将上面的四行添加到您的示例中。临时变量是一些调试遗留下来的，显然可以删除。操场上链接

同一问题的变体

解决方案

相关内容

最新更新

热门标签：