如何定义Go泛型可变参数高阶函数以组合Transformer类型函数

首先，你的Transformer泛型类型定义如下：

type Transformer[A, B any] func(A) (B, error)

由于Go目前不支持可变长度的类型参数列表（无法直接写出C....N这类动态类型参数），要实现类型安全的可变参数组合函数，有两种可行方案：

方案1：编译时类型安全的固定参数组合 #

通过预定义不同参数数量的Compose函数，保证编译时类型检查，避免运行时错误。核心是基于二元组合函数递归扩展：

// 组合两个Transformer：A→B 和 B→C，返回A→C
func ComposeTwo[A, B, C any](f Transformer[A, B], g Transformer[B, C]) Transformer[A, C] {
    return func(a A) (C, error) {
        b, err := f(a)
        if err != nil {
            return *new(C), err // 返回零值和错误
        }
        return g(b)
    }
}

// 组合三个Transformer：A→B、B→C、C→D，返回A→D
func Compose3[A, B, C, D any](f Transformer[A, B], g Transformer[B, C], h Transformer[C, D]) Transformer[A, D] {
    return ComposeTwo(ComposeTwo(f, g), h)
}

// 组合四个Transformer，以此类推
func Compose4[A, B, C, D, E any](f Transformer[A, B], g Transformer[B, C], h Transformer[C, D], i Transformer[D, E]) Transformer[A, E] {
    return ComposeTwo(Compose3(f, g, h), i)
}

优点：完全编译时类型校验，性能无额外开销；缺点：需要预定义支持的最大Transformer数量，灵活性受限。

方案2：运行时类型检查的可变参数组合 #

如果需要支持任意数量的Transformer，可以通过可变参数+类型断言实现，但会失去编译时类型安全，需在运行时处理类型不匹配的错误：

import "fmt"

func Compose[A, N any](transformers ...any) (Transformer[A, N], error) {
    if len(transformers) == 0 {
        return nil, fmt.Errorf("必须传入至少一个Transformer")
    }

    // 断言第一个Transformer的输入为A类型
    current, ok := transformers[0].(Transformer[A, any])
    if !ok {
        return nil, fmt.Errorf("第一个Transformer类型不匹配，应为Transformer[%T, any]", *new(A))
    }

    // 依次组合后续Transformer
    for _, t := range transformers[1:] {
        next, ok := t.(Transformer[any, any])
        if !ok {
            return nil, fmt.Errorf("无效的Transformer类型")
        }

        // 组合当前Transformer和下一个Transformer
        composed := func(a A) (any, error) {
            intermediate, err := current(a)
            if err != nil {
                return nil, err
            }
            return next(intermediate)
        }
        current = composed
    }

    // 断言最终输出为N类型
    finalTransformer, ok := current.(Transformer[A, N])
    if !ok {
        return nil, fmt.Errorf("Transformer链的输出类型不匹配，应为%T", *new(N))
    }

    return finalTransformer, nil
}

优点：支持任意数量的Transformer，灵活性高；缺点：编译时无法校验类型匹配，需运行时错误处理，有一定性能开销。

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