我有一份动物名单:
let animals = ["bear", "dog", "cat"]
以及一些转换该列表的方法:
typealias Transform = (String) -> [String]
let containsA: Transform = { $0.contains("a") ? [$0] : [] }
let plural: Transform = { [$0 + "s"] }
let double: Transform = { [$0, $0] }
稍微说一下,它们分别类似于过滤器(输出0或1个元素),映射(正好是1个元素)和平面图(多于1个元素),但是以统一的方式定义,以便可以一致地处理它们。
我想创建一个惰性迭代器,它将这些变换的数组应用于动物列表:
extension Array where Element == String {
func transform(_ transforms: [Transform]) -> AnySequence<String> {
return AnySequence<String> { () -> AnyIterator<String> in
var iterator = self
.lazy
.flatMap(transforms[0])
.flatMap(transforms[1])
.flatMap(transforms[2])
.makeIterator()
return AnyIterator {
return iterator.next()
}
}
}
}
这意味着我可以懒惰地做:
let transformed = animals.transform([containsA, plural, double])
并检查结果:
print(Array(transformed))
我很高兴这是多么简洁,但很明显:
.flatMap(transforms[0])
.flatMap(transforms[1])
.flatMap(transforms[2])
是一个问题,因为它意味着转换函数只适用于3个转换的数组。
编辑:我试过:
var lazyCollection = self.lazy
for transform in transforms {
lazyCollection = lazyCollection.flatMap(transform) //Error
}
var iterator = lazyCollection.makeIterator()
但在标记的行上我得到错误:
无法分配类型'LazyCollection <FlattenCollection <LazyMapCollection <Array <String>,[String] >>>'的值以键入'LazyCollection <Array <String >>'
我理解,因为每次循环时都会添加另一个平面图,因此类型正在发生变化。
如何使变换函数与任意数量的变换数组一起使用?
一个有限数量的变换的WET解决方案将是(但是YUK!)
switch transforms.count {
case 1:
var iterator = self
.lazy
.flatMap(transforms[0])
.makeIterator()
return AnyIterator {
return iterator.next()
}
case 2:
var iterator = self
.lazy
.flatMap(transforms[0])
.flatMap(transforms[1])
.makeIterator()
return AnyIterator {
return iterator.next()
}
case 3:
var iterator = self
.lazy
.flatMap(transforms[0])
.flatMap(transforms[1])
.flatMap(transforms[2])
.makeIterator()
return AnyIterator {
return iterator.next()
}
default:
fatalError(" Too many transforms!")
}
整码:
let animals = ["bear", "dog", "cat"]
typealias Transform = (String) -> [String]
let containsA: Transform = { $0.contains("a") ? [$0] : [] }
let plural: Transform = { [$0 + "s"] }
let double: Transform = { [$0, $0] }
extension Array where Element == String {
func transform(_ transforms: [Transform]) -> AnySequence<String> {
return AnySequence<String> { () -> AnyIterator<String> in
var iterator = self
.lazy
.flatMap(transforms[0])
.flatMap(transforms[1])
.flatMap(transforms[2])
.makeIterator()
return AnyIterator {
return iterator.next()
}
}
}
}
let transformed = animals.transform([containsA, plural, double])
print(Array(transformed))
另一种实现你想要的方法:
编辑:我试过:
var lazyCollection = self.lazy for transform in transforms { lazyCollection = lazyCollection.flatMap(transform) //Error } var iterator = lazyCollection.makeIterator()
你非常接近你的目标,如果错误行中的两种类型都是可分配的,那么你的代码就可以了。
稍作修改:
var lazySequence = AnySequence(self.lazy)
for transform in transforms {
lazySequence = AnySequence(lazySequence.flatMap(transform))
}
var iterator = lazySequence.makeIterator()
或者你可以在这里使用reduce
:
var transformedSequence = transforms.reduce(AnySequence(self.lazy)) {sequence, transform in
AnySequence(sequence.flatMap(transform))
}
var iterator = transformedSequence.makeIterator()
整个代码是:
(编辑修改以包括Martin R.的建议)
let animals = ["bear", "dog", "cat"]
typealias Transform<Element> = (Element) -> [Element]
let containsA: Transform<String> = { $0.contains("a") ? [$0] : [] }
let plural: Transform<String> = { [$0 + "s"] }
let double: Transform<String> = { [$0, $0] }
extension Sequence {
func transform(_ transforms: [Transform<Element>]) -> AnySequence<Element> {
return transforms.reduce(AnySequence(self)) {sequence, transform in
AnySequence(sequence.lazy.flatMap(transform))
}
}
}
let transformed = animals.transform([containsA, plural, double])
print(Array(transformed))
如果在Sequence
协议(而不是Array
)上定义方法,则可以递归地应用转换。如果转换参数被定义为where Element == String
的数组,则不需要约束(Element) -> [Element]
。
extension Sequence {
func transform(_ transforms: [(Element) -> [Element]]) -> AnySequence<Element> {
if transforms.isEmpty {
return AnySequence(self)
} else {
return lazy.flatMap(transforms[0]).transform(Array(transforms[1...]))
}
}
}
如何将其完全融入功能世界?例如,使用(动态)函数调用链,如filter(containsA) | map(plural) | flatMap(double)
。
通过一些可重用的通用代码,我们可以实现一些不错的东西。
让我们开始推广一些序列和延迟序列操作来释放函数:
func lazy<S: Sequence>(_ arr: S) -> LazySequence<S> {
return arr.lazy
}
func filter<S: Sequence>(_ isIncluded: @escaping (S.Element) throws -> Bool) -> (S) throws -> [S.Element] {
return { try $0.filter(isIncluded) }
}
func filter<L: LazySequenceProtocol>(_ isIncluded: @escaping (L.Elements.Element) -> Bool) -> (L) -> LazyFilterSequence<L.Elements> {
return { $0.filter(isIncluded) }
}
func map<S: Sequence, T>(_ transform: @escaping (S.Element) throws -> T) -> (S) throws -> [T] {
return { try $0.map(transform) }
}
func map<L: LazySequenceProtocol, T>(_ transform: @escaping (L.Elements.Element) -> T) -> (L) -> LazyMapSequence<L.Elements, T> {
return { $0.map(transform) }
}
func flatMap<S: Sequence, T: Sequence>(_ transform: @escaping (S.Element) throws -> T) -> (S) throws -> [T.Element] {
return { try $0.flatMap(transform) }
}
func flatMap<L: LazySequenceProtocol, S: Sequence>(_ transform: @escaping (L.Elements.Element) -> S) -> (L) -> LazySequence<FlattenSequence<LazyMapSequence<L.Elements, S>>> {
return { $0.flatMap(transform) }
}
请注意,懒惰序列对应物比常规Sequence
更冗长,但这是由于LazySequenceProtocol
方法的冗长。
通过上面我们可以创建接收数组和返回数组的泛型函数,这种类型的函数非常适合流水线操作,所以让我们定义一个管道操作符:
func |<T, U>(_ arg: T, _ f: (T) -> U) -> U {
return f(arg)
}
现在我们只需要为这些函数提供一些东西,但要实现这一点,我们需要对Transform
类型进行一些调整:
typealias Transform<T, U> = (T) -> U
let containsA: Transform<String, Bool> = { $0.contains("a") }
let plural: Transform<String, String> = { $0 + "s" }
let double: Transform<String, [String]> = { [$0, $0] }
有了上述所有功能,事情变得简单明了:
let animals = ["bear", "dog", "cat"]
let newAnimals = lazy(animals) | filter(containsA) | map(plural) | flatMap(double)
print(Array(newAnimals)) // ["bears", "bears", "cats", "cats"]