如何分配或 return 受联合约束的泛型 T？

Question

换句话说，如何为联合类型集中的不同类型实现特定于类型的解决方案？

给定以下代码...

type FieldType interface {
    string | int
}

type Field[T FieldType] struct {
    name         string
    defaultValue T
}

func NewField[T FieldType](name string, defaultValue T) *Field[T] {
    return &Field[T]{
        name:         name,
        defaultValue: defaultValue,
    }
}

func (f *Field[T]) Name() string {
    return f.name
}

func (f *Field[T]) Get() (T, error) {
    value, ok := os.LookupEnv(f.name)
    if !ok {
        return f.defaultValue, nil
    }
    return value, nil
}

编译器显示错误：

field.go:37:9: cannot use value (variable of type string) as type T in return statement

有没有办法为所有可能的 FieldType 提供实现？

喜欢...

func (f *Field[string]) Get() (string, error) {
    value, ok := os.LookupEnv(f.name)
    if !ok {
        return f.defaultValue, nil
    }
    return value, nil
}

func (f *Field[int]) Get() (int, error) {
    raw, ok := os.LookupEnv(f.name)
    if !ok {
        return f.defaultValue, nil
    }
    value, err := strconv.ParseInt(raw, 10, 64)
    if err != nil {
        return *new(T), err
    }
    return int(value), nil
}

欢迎任何提示。

Answer 1

好的，如果使用反射，类型开关会起作用。

func (f *Field[T]) Get() (T, error) {
    raw, ok := os.LookupEnv(f.name)
    if !ok {
        return f.defaultValue, nil
    }

    v := reflect.ValueOf(new(T))

    switch v.Type().Elem().Kind() {
    case reflect.String:
        v.Elem().Set(reflect.ValueOf(raw))

    case reflect.Int:
        value, err := strconv.ParseInt(raw, 10, 64)
        if err != nil {
            return f.defaultValue, err
        }
        v.Elem().Set(reflect.ValueOf(int(value)))
    }

    return v.Elem().Interface().(T), nil
}

但是非常欢迎更好的解决方案;-)

Answer 2

错误发生是因为涉及类型参数的操作（包括赋值和 returns）必须对其类型集中的所有类型有效。在 string | int 的情况下，没有常用的操作来从字符串初始化它们的值。

但是您还有几个选择：

Type-switch 在 `T`

您在 type-switch 中使用泛型类型 T 的字段，并将具有具体类型的值临时设置为 interface{}/any。然后type-assert界面回到T为了return吧。请注意，此断言未经检查，因此如果由于某种原因 ret 持有不在 T 类型集中的内容，它可能会出现恐慌。当然你可以用 comma-ok 检查它，但它仍然是一个 run-time 断言：

func (f *Field[T]) Get() (T, error) {
    value, ok := os.LookupEnv(f.name)
    if !ok {
        return f.defaultValue, nil
    }
    var ret any
    switch any(f.defaultValue).(type) {
    case string:
        ret = value

    case int:
        // don't actually ignore errors
        i, _ := strconv.ParseInt(value, 10, 64)
        ret = int(i)
    }
    return ret.(T), nil
}

Type-switch 在 `*T`

您可以进一步简化上面的代码，去掉空界面。在这种情况下，您获取 T 类型变量的地址并打开指针类型。 编译时完全type-checked:

func (f *Field[T]) Get() (T, error) {
    value, ok := env[f.name]
    if !ok {
        return f.defaultValue, nil
    }

    var ret T
    switch p := any(&ret).(type) {
    case *string:
        *p = value

    case *int:
        i, _ := strconv.ParseInt(value, 10, 64)
        *p = int(i)
    }
    // ret has the zero value if no case matches
    return ret, nil
}

请注意，在这两种情况下，您都必须将 T 值转换为 interface{}/any 才能在类型转换中使用它。你不能 type-switch 直接在 T.

带模拟地图的游乐场os.LookupEnv：https://go.dev/play/p/LHqizyNL9lP

如何分配或 return 受联合约束的泛型 T？

How to assign or return generic T that is constrained by union?

generics

go

type-switch

Type-switch 在 `T`

Type-switch 在 `*T`

如何分配或 return 受联合约束的泛型 T？

How to assign or return generic T that is constrained by union?

generics

go

type-switch

Type-switch 在 T

Type-switch 在 *T

Type-switch 在 `T`

Type-switch 在 `*T`