设计一个支持泛型、关联类型和类型擦除的通用数据管道系统

题目

设计一个支持泛型、关联类型和类型擦除的通用数据管道系统

信息

• 类型：问答
• 难度：⭐⭐⭐

考点

协议关联类型, 泛型高级应用, 类型擦除技术, 错误传播机制, 内存管理

快速回答

实现要点：

• 定义带有关联类型的 DataPipeline 协议
• 使用泛型约束实现具体管道类型
• 通过 AnyDataPipeline 类型擦除器隐藏实现细节
• 结合 Result 和 async/await 处理错误
• 使用 weak 引用打破循环依赖

问题场景

在复杂应用中，需要构建可组合的数据处理管道（如：网络请求 → 缓存 → 数据转换），要求：

1. 支持任意数据类型传递
2. 允许管道自由组合
3. 统一错误处理
4. 避免内存泄漏

核心实现方案

1. 协议定义（含关联类型）

protocol DataPipeline {
    associatedtype Input
    associatedtype Output
    associatedtype Failure: Error

    func process(_ input: Input) async -> Result<Output, Failure>
}

关键点：关联类型使协议能处理泛型数据，但导致协议不能直接作为类型使用。

2. 具体管道实现（以网络管道为例）

struct NetworkPipeline<T: Decodable>: DataPipeline {
    typealias Input = URL
    typealias Output = T
    typealias Failure = NetworkError

    func process(_ input: URL) async -> Result<T, NetworkError> {
        do {
            let (data, _) = try await URLSession.shared.data(from: input)
            let decoded = try JSONDecoder().decode(T.self, from: data)
            return .success(decoded)
        } catch {
            return .failure(.requestFailed(error))
        }
    }
}

enum NetworkError: Error {
    case requestFailed(Error)
    case invalidResponse
}

3. 类型擦除器实现

struct AnyDataPipeline<Input, Output, Failure: Error>: DataPipeline {
    private let _process: (Input) async -> Result<Output, Failure>

    init<P: DataPipeline>(_ pipeline: P) where 
        P.Input == Input, 
        P.Output == Output, 
        P.Failure == Failure 
    {
        self._process = pipeline.process
    }

    func process(_ input: Input) async -> Result<Output, Failure> {
        await _process(input)
    }
}

作用：封装具体类型，允许将不同管道存入同一集合。

4. 管道组合器实现

class PipelineComposer {
    private var pipelines: [AnyDataPipeline<Any, Any, Error>] = []

    func append<P: DataPipeline>(_ pipeline: P) {
        let erased = AnyDataPipeline(pipeline)
            .eraseToAny() // 二次擦除处理类型差异
        pipelines.append(erased)
    }

    func processAll(input: Any) async -> [Result<Any, Error>] {
        var results = [Result<Any, Error>]()
        for pipeline in pipelines {
            let result = await pipeline.process(input)
            results.append(result)
        }
        return results
    }
}

// 扩展二次类型擦除
extension DataPipeline {
    func eraseToAny() -> AnyDataPipeline<Any, Any, Error> {
        AnyDataPipeline(
            eraseInput: { $0 },
            eraseOutput: { $0 },
            eraseFailure: { $0 }
        )
    }

    private func eraseToAny<ErasedInput, ErasedOutput, ErasedFailure: Error>(
        eraseInput: @escaping (ErasedInput) -> Input,
        eraseOutput: @escaping (Output) -> ErasedOutput,
        eraseFailure: @escaping (Failure) -> ErasedFailure
    ) -> AnyDataPipeline<ErasedInput, ErasedOutput, ErasedFailure> {
        AnyDataPipeline { (input: ErasedInput) in
            let result = await self.process(eraseInput(input))
            return result.map(eraseOutput).mapError(eraseFailure)
        }
    }
}

最佳实践

• 内存管理：在 PipelineComposer 中使用 weak 引用避免循环依赖
• 错误处理：使用 Result 嵌套组合错误类型，确保错误传播完整性
• 性能优化：对 CPU 密集型操作添加 @Sendable 支持并发安全

常见错误

扩展知识

• 类型擦除模式：Swift 标准库的 AnySequence、AnyPublisher 采用相同设计
• 结合 SwiftUI：可扩展为 PreferenceKey 实现视图间数据管道
• 性能取舍：类型擦除带来约 5-10% 性能损耗，关键路径需权衡