带指针接收器的Go泛型接口编译报错原因咨询

我在后端应用中尝试用Go泛型统一数据库Model与核心DTO的转换逻辑，定义了带泛型T的Model接口，包含ToType() *T和FromType(*T)方法，还实现了批量转换的FromTypeSlice和ToTypeSlice泛型函数。但编写测试时出现编译错误：

sampleModel does not satisfy Model[sampleType] (method FromType has pointer receiver)

去掉方法的指针接收器后能编译，但FromType无法修改值导致测试失败；非泛型场景下该实现却能正常运行，想知道这个约束的原因。

相关代码 #

data/models/model.go #

package models

type Model[T any] interface {
    ToType() *T
    FromType(*T)
}

// FromTypeSlice converts a slice of T to a slice of Model[T]
func FromTypeSlice[Type any, ModelType Model[Type]](t *[]Type) []ModelType {
    modelSlice := make([]ModelType, len(*t))
    for i, typeObject := range *t {
        modelSlice[i].FromType(&typeObject)
    }
    return modelSlice
}

// ToTypeSlice converts a slice of Model[T] to a slice of T
func ToTypeSlice[Type any, ModelType Model[Type]](types *[]ModelType) *[]Type {
    typeSlice := make([]Type, len(*types))
    for i, model := range *types {
        typeSlice[i] = *model.ToType()
    }
    return &typeSlice
}

data/models/model_test.go #

package models

import "testing"

type sampleModel struct {
    ID int
}

type sampleType struct {
    ID int
}

func (model *sampleModel) ToType() *sampleType {
    return &sampleType{
        ID: model.ID,
    }
}

func (model *sampleModel) FromType(t *sampleType) {
    model.ID = t.ID
}

func TestFromTypeSlice(t *testing.T) {
    slice := []sampleType{{ID: 1}, {ID: 2}, {ID: 3}}
    modelSlice := FromTypeSlice[sampleType, sampleModel](&slice)

    if len(modelSlice) != len(slice) {
        t.Errorf("Expected length of modelSlice to be %d, got %d", len(slice), len(modelSlice))
    }

    for i, model := range modelSlice {
        if model.ID != slice[i].ID {
            t.Errorf("Expected modelSlice[%d].ID to be %d, got %d", i, slice[i].ID, model.ID)
        }
    }
}

func TestToTypeSlice(t *testing.T) {
    slice := []sampleModel{{ID: 1}, {ID: 2}, {ID: 3}}
    typeSlice := ToTypeSlice[sampleType, sampleModel](&slice)

    if len(*typeSlice) != len(slice) {
        t.Errorf("Expected length of modelSlice to be %d, got %d", len(slice), len(*typeSlice))
    }

    for i, ty := range *typeSlice {
        if ty.ID != slice[i].ID {
            t.Errorf("Expected modelSlice[%d].ID to be %d, got %d", i, slice[i].ID, ty.ID)
        }
    }
}

非泛型场景测试代码 #

func TestFromType(t *testing.T) {
    var model Model[sampleType] = &sampleModel{}
    model.FromType(&sampleType{ID: 1})

    if model.ToType().ID != 1 {
        t.Errorf("Expected model.ToType().ID to be 1, got %d", model.ToType().ID)
    }
}

问题原因 #

1. Go的方法集规则：指针类型的方法不会被值类型继承。你的sampleModel值类型并没有实现Model[sampleType]接口，只有*sampleModel指针类型才实现了该接口。
2. 非泛型与泛型的差异：非泛型场景中，你直接将&sampleModel{}（指针类型）赋值给Model[sampleType]变量，符合接口要求；但泛型函数调用时，你指定的类型参数是sampleModel（值类型），它不满足接口约束，因此编译报错。
3. 指针接收器的必要性：若去掉指针接收器，FromType方法操作的是值的副本，无法修改原对象的属性，自然导致测试失败。

解决方案 #

方式一：修改泛型函数的类型参数约束 #

调整FromTypeSlice的逻辑，明确处理指针类型的Model实例：

// 修改后的FromTypeSlice
func FromTypeSlice[Type any, ModelType any, ModelPtr interface{ *ModelType; Model[Type] }](t *[]Type) []ModelPtr {
    modelSlice := make([]ModelPtr, len(*t))
    for i, typeObject := range *t {
        model := new(ModelType)
        model.FromType(&typeObject)
        modelSlice[i] = model
    }
    return modelSlice
}

调用时保持类型参数指定为值类型即可：

modelSlice := FromTypeSlice[sampleType, sampleModel](&slice)

方式二：调整接口的指针约束 #

修改Model接口，明确要求实现者必须是指针类型：

type Model[T any] interface {
    // 约束接口实现者为指针类型
    *struct{}
    ToType() *T
    FromType(*T)
}

这种方式需要同步调整泛型函数的类型参数，确保传入的是指针类型。

内容的提问来源于stack exchange，提问作者Menachem Hornbacher