我尝试在swift中创建一个基本的转换管道。
import Foundation
protocol Transformation {
associatedtype Target
func transform(_ input: Target) -> Target
}
struct LowercaseTransformation: Transformation {
func transform(_ input: String) -> String {
return input.lowercased()
}
}
struct ReverseTransformation: Transformation {
func transform(_ input: String) -> String {
return String(input.reversed())
}
}
struct Pipeline<T> where T: Transformation {
let transformations: [T]
func run(_ input: T.Target) -> T.Target {
var output = input
transformations.forEach { output = $0.transform(output) }
return output
}
}
let pipeline = Pipeline(transformations: [LowercaseTransformation(), ReverseTransformation()]) // Type of expression is ambiguous without more context
let input: String = "Hello World"
let output = pipeline.run(input)
print(output)
我的问题与泛型的使用有关,但我一直不能想出如何在保持转换协议和管道结构可重用的同时绕过它...
刚刚又试了一次。。这适用于阵列中的一个变压器,甚至是同一个变压器的多个示例,但只要阵列包含不同的变压器,它就会中断。。
protocol Transform {
associatedtype Target
func transform(input: Target) -> Target
}
struct Transformer: Transform {
func transform(input: String) -> String {
input+"_Transformed"
}
}
struct AnotherTransformer: Transform {
func transform(input: String) -> String {
input+"_Morphed"
}
}
struct TransformPipeline<Target, Transformer: Transform> where Transformer.Target == Target {
private let transforms: [Transformer]
init(transforms: [Transformer]) {
self.transforms = transforms
}
func run(input: Target) -> Target {
var output = input
for transform in transforms {
output = transform.transform(input: output)
}
return output
}
}
let transformations = [Transformer()]
let pipeline = TransformPipeline(transforms: transformations)
print(pipeline.run(input: "input"))
1条答案
按热度按时间yrwegjxp1#
一个非常简化的版本是只使用
Pipeline
结构,并让它保存一个函数数组然后使用
为了更好地使用Pipeline,我们可以为函数声明一些静态属性