如何使用指针接收器方法和非指针接收器方法定义泛型类型

Question

我已经开始尝试 Go 泛型。有没有办法定义一个泛型例如：一个方法不需要用指针接收器调用，另一个需要用指针接收器调用。

例子：

type MapKey interface {
    comparable
}

type Unmarshaller[T any] interface {
    UnmarshalJSON(b []byte) error
    *T
}

type Marshaller[T any] interface {
    MarshalJSON() ([]byte, error)
}

type MapValue[T any] interface {
    Marshaller[T]
    Unmarshaller[T]
}

type Map[T any, K MapKey, V MapValue[T]] struct {
    _ K
    _ V
}

func (m Map[K, V]) Save(k K, v V) error {
    _, _ = v.MarshalJSON()
    return nil
}

func (m Map[K, V]) Get(k K) (value V, err error) {
    v := new(V)
    err = v.UnmarshalJSON(m.bytesFromKey(k))
    return *v, nil
}


// here I need to make sure V is actually a pointer so that UnmarshalJSON correctly propagates to the caller of GetTo and no copy is made of V
func (m Map[K, V]) GetTo(k K, v V) error {
    bytesValue := m.kv.Get(m.bytesFromKey(k))
    return v.UnmarshalJSON(v)
}

错误：

./map_generic.go:26:16: V has no constraints
./map_generic.go:27:11: v.MarshalJSON undefined (type bound for V has no method MarshalJSON)
./map_generic.go:31:16: V has no constraints
./map_generic.go:33:10: v.UnmarshalJSON undefined (type *V has no field or method UnmarshalJSON)

Answer 1

我还没有找到一种方法来限制一个接口具有指针方法和非指针方法。 但是我找到了一种方法来拥有一个结构类型，它的方法可以接受 T 或 *T。

我不得不拆分接口（Marshaller、Unmarshaller）并约束它们使用相同的类型，然后Map 类型定义同时使用两者。

这是代码（GOVERSION="devel go1.18-c239790 Sat Nov 13 03:33:55 2021 +0000"）

package storage

// Marshaller has T type parameter
type Marshaller[T interface{}] interface {
    MarshalJSON() ([]byte, error)
}

// Unmarshaller has T type parameter and we force it to be a pointer
type Unmarshaller[T interface{}] interface {
    UnmarshalJSON(b []byte) error
    *T
}

// Map so here we need T, and we force Marshaller and Unmarshaller to be using the same type T
type Map[T any, K comparable, MV Marshaller[T], UV Unmarshaller[T]] struct {

}

func NewMap[T any, K comparable, MV Marshaller[T], UV Unmarshaller[T]]() Map[T, K, MV, UV] {
    return Map[T, K, MV, UV]{}
}

// Save accepts the non pointer version of T to use for MarshalJSON
func (m Map[T, K, MV, UV]) Save(k K, v MV) {
    v.MarshalJSON()
}

// GetTo accepts the pointer version of T to use for UnmarshalJSON
func (m Map[T, K, MV, UV]) GetTo(k K, v UV) {
    v.UnmarshalJSON(nil)
}

这是一个测试文件，它断言我们可以强制某些方法接受或不接受相同类型的指针。

package storage

import (
    "testing"
)

type x struct {

}

func (x *x) UnmarshalJSON(b []byte) error {
    return nil
}

func (x x) MarshalJSON() ([]byte, error) {
    return nil, nil
}

// This will compile
func TestMarshalNoPointer(t *testing.T) {
    m := NewMap[x, string, x, *x]()
    m.Save("hi", x{})
}

// This will compile
func TestUnmarshalPointer(t *testing.T) {
    m := NewMap[x, string, x, *x]()
    m.GetTo("hi", &x{})
}

// This won't compile
func TestUnmarshalNoPointer(t *testing.T) {
    m := NewMap[x, string, x, *x]()
    m.GetTo("hi", x{})
}