如何在Go语言的map中存储泛型结构体并动态引用？

Go 中泛型接口的实例是参数化的不同类型（比如IPrinter[float64]和IPrinter[string]是完全独立的类型），无法直接统一到IPrinter[any]下。我们可以定义一个非泛型的顶层接口作为统一抽象，让所有泛型打印机实现这个接口：

package main

import "fmt"

// 定义非泛型的统一打印机接口
type Printer interface {
    Print(value any) error
}

// 保留原泛型接口和结构体
type IPrinter[T any] interface {
    PPrint(value T)
}

type PrefixPrinter[T any] struct {
    prefix string
}

func (printer PrefixPrinter[T]) PPrint(value T) {
    fmt.Printf("%v%v\n", printer.prefix, value)
}

// 让PrefixPrinter实现非泛型Printer接口
func (printer PrefixPrinter[T]) Print(value any) error {
    val, ok := value.(T)
    if !ok {
        return fmt.Errorf("expected type %T, got %T", *new(T), value)
    }
    printer.PPrint(val)
    return nil
}

type FormatPrinter[T any] struct {
    format string
}

func (printer FormatPrinter[T]) PPrint(value T) {
    fmt.Printf(printer.format, value)
}

// 让FormatPrinter实现非泛型Printer接口
func (printer FormatPrinter[T]) Print(value any) error {
    val, ok := value.(T)
    if !ok {
        return fmt.Errorf("expected type %T, got %T", *new(T), value)
    }
    printer.PPrint(val)
    return nil
}

func main() {
    // 现在可以用非泛型接口作为map的value类型
    printers := make(map[string]Printer)
    printers["floatPrefix"] = PrefixPrinter[float64]{"[float] "}
    printers["stringFormat"] = FormatPrinter[string]{"Hello, %s!\n"}

    // 直接调用统一的Print方法，类型错误会返回error
    printers["floatPrefix"].Print(3.14)
    printers["stringFormat"].Print("Go")
    
    // 测试错误类型输入
    if err := printers["floatPrefix"].Print("not a float"); err != nil {
        fmt.Println(err)
    }
}

这个方案既保留了原泛型方法的类型安全性（内部调用PPrint时参数类型完全匹配），又能统一存储所有打印机实例，调用时只需处理可能的类型错误即可。

如果不想修改原有泛型结构体的代码，可以通过包装结构体将泛型方法适配到非泛型接口：

package main

import "fmt"

type Printer interface {
    Print(value any) error
}

type IPrinter[T any] interface {
    PPrint(value T)
}

type PrefixPrinter[T any] struct {
    prefix string
}

func (printer PrefixPrinter[T]) PPrint(value T) {
    fmt.Printf("%v%v\n", printer.prefix, value)
}

type FormatPrinter[T any] struct {
    format string
}

func (printer FormatPrinter[T]) PPrint(value T) {
    fmt.Printf(printer.format, value)
}

// 包装结构体，适配非泛型接口
type PrinterWrapper struct {
    printFunc func(value any) error
}

func (w PrinterWrapper) Print(value any) error {
    return w.printFunc(value)
}

// 为PrefixPrinter生成包装器
func NewPrefixPrinterWrapper[T any](p PrefixPrinter[T]) PrinterWrapper {
    return PrinterWrapper{
        printFunc: func(value any) error {
            val, ok := value.(T)
            if !ok {
                return fmt.Errorf("invalid type for PrefixPrinter")
            }
            p.PPrint(val)
            return nil
        },
    }
}

// 为FormatPrinter生成包装器
func NewFormatPrinterWrapper[T any](p FormatPrinter[T]) PrinterWrapper {
    return PrinterWrapper{
        printFunc: func(value any) error {
            val, ok := value.(T)
            if !ok {
                return fmt.Errorf("invalid type for FormatPrinter")
            }
            p.PPrint(val)
            return nil
        },
    }
}

func main() {
    printers := make(map[string]Printer)
    printers["floatPrefix"] = NewPrefixPrinterWrapper(PrefixPrinter[float64]{"[float] "})
    printers["stringFormat"] = NewFormatPrinterWrapper(FormatPrinter[string]{"Hello, %s!\n"})

    printers["floatPrefix"].Print(3.14)
    printers["stringFormat"].Print("Go")
}

这个方案适合需要保留原有代码结构的场景，通过包装器隔离泛型与非泛型的适配逻辑。

Go 的泛型接口是参数化类型，IPrinter[float64]和IPrinter[string]是完全独立的类型，它们并不实现IPrinter[any]——Go 目前不支持泛型接口的协变/逆变，因此无法直接将不同参数的泛型接口实例统一存储。

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