如何在Swift中正确为链式函数生成器函数添加类型标注？

核心问题根源 #

你遇到的泛型参数推断失败、类型安全缺失问题，本质是Swift对可变参数/数组的泛型约束能力有限：直接用数组接收函数时，编译器无法在编译期链式约束前后函数的输入输出类型；而固定3个函数的示例能工作，是因为可以为每个位置显式绑定泛型参数，形成完整的类型链。

最优实现方案：链式泛型+运算符重载 #

1. 基础二元组合函数 #

先定义最基础的二元组合逻辑，这是所有复杂组合的核心，编译器能完美推断泛型类型：

func compose<A, B, C>(_ f: @escaping (B) -> C, _ g: @escaping (A) -> B) -> (A) -> C {
    return { input in f(g(input)) }
}

• A：第一个函数的输入类型
• B：中间类型（第一个函数输出、第二个函数输入）
• C：最终输出类型

2. 运算符重载简化调用 #

为了让组合更直观，定义右结合的自定义运算符：

// 定义组合运算符的优先级组
precedencegroup CompositionPrecedence {
    associativity: right
    higherThan: AssignmentPrecedence
}

// 右向组合运算符：前一个函数的输出作为后一个的输入
infix operator >>>: CompositionPrecedence

func >>> <A, B, C>(_ lhs: @escaping (A) -> B, _ rhs: @escaping (B) -> C) -> (A) -> C {
    return { rhs(lhs($0)) }
}

使用示例：

// 测试函数
let stringToInt: (String) -> Int = { Int($0)! }
let intToDouble: (Int) -> Double = { Double($0) }
let doubleToDescription: (Double) -> String = { "最终结果：\($0)" }

// 链式组合
let combinedFunction = stringToInt >>> intToDouble >>> doubleToDescription

// 调用测试
print(combinedFunction("123")) // 输出：最终结果：123.0

这个版本完全类型安全，任何输入输出类型不匹配的情况会直接在编译期报错。

3. 支持任意数量函数的重载实现 #

如果需要直接传入多个函数而非链式调用，可以通过重载compose函数扩展到n元组合：

// 空组合：返回输入本身
func compose<I>() -> (I) -> I {
    return { $0 }
}

// 单函数：直接返回原函数
func compose<I, O>(_ f: @escaping (I) -> O) -> (I) -> O {
    return f
}

// 三元组合：基于二元组合扩展
func compose<A, B, C, D>(_ f: @escaping (C) -> D, _ g: @escaping (B) -> C, _ h: @escaping (A) -> B) -> (A) -> D {
    return compose(f, compose(g, h))
}

// 四元组合：以此类推
func compose<A, B, C, D, E>(_ f: @escaping (D) -> E, _ g: @escaping (C) -> D, _ h: @escaping (B) -> C, _ i: @escaping (A) -> B) -> (A) -> E {
    return compose(f, compose(g, h, i))
}

使用示例：

let combined = compose(doubleToDescription, intToDouble, stringToInt)
print(combined("456")) // 输出：最终结果：456.0

数组版本的局限性 #

如果必须用数组作为输入，由于Swift数组要求所有元素类型一致，而链式函数的输入输出类型是递进的，无法统一为单一类型，只能通过类型擦除牺牲部分类型安全：

func compose<I, O>(_ functions: [(Any) -> Any]) -> (I) -> O? {
    return { input in
        var currentValue: Any = input
        for function in functions {
            currentValue = function(currentValue)
        }
        return currentValue as? O
    }
}

这个版本会将类型检查延迟到运行时，不推荐在对类型安全要求高的场景使用。

原有代码问题解析 #

如果你的原有代码是将函数存入[(Any) -> Any]数组后再组合，编译器无法推断O的原因是：数组元素类型被擦除为Any，编译器无法跟踪最后一个函数的输出类型；同时类型安全缺失是因为无法在编译期验证前后函数的输入输出是否匹配。

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