Swift数组循环一次，写很多

Question

考虑以下愚蠢的简单示例：

let arr = ["hey", "ho"]
let doubled = arr.map {$0 + $0}
let capitalized = arr.map {$0.capitalizedString}

如您所见，我正在以多种方式处理相同的初始数组，以便最终得到多个处理过的数组。

现在想象arr 很长，并且我有许多这样的进程生成许多最终数组。我不喜欢上面的代码，因为我们循环了多次，每个map 调用一次。我宁愿只循环一次。

现在，显然我们可以通过蛮力来处理这个问题，即从多个可变数组开始并在每次迭代中写入所有数组：

let arr = ["hey", "ho"]
var doubled = [String]()
var capitalized = [String]()
for s in arr {
    doubled.append(s + s)
    capitalized.append(s.capitalizedString)
}

很好。但是现在我们没有得到使用map 的乐趣。所以我的问题是：有没有更好、更快捷的方式？我以一种模糊的方式想象自己使用map 或map 之类的东西来生成类似元组的东西，并在我们迭代时神奇地将元组拆分成所有结果数组，就好像我可以说这样的话（伪代码，不要在家里尝试这个）：

let arr = ["hey", "ho"]
let (doubled, capitalized) = arr.map { /* ???? */ }

如果我正在设计自己的语言，我什至可能允许通过赋值到左值伪数组中进行某种喷溅：

let arr = ["hey", "ho"]
let [doubled, capitalized] = arr.map { /* ???? */ }

做不到也没什么大不了，但能这样说话会很有趣。

Answer 1

一个函数multimap怎么样，它接受一组转换，并应用每个转换，将它们作为数组数组返回：

// yay protocol extensions
extension SequenceType {
    // looks like T->U works OK as a constraint
    func multimap
      <U, C: CollectionType 
       where C.Generator.Element == Generator.Element->U>
    (transformations: C) -> [[U]] {
        return transformations.map {
            self.map($0)
        }
    }
}

然后像这样使用它：

let arr = ["hey", "ho"]

let double: String->String = { $0 + $0 }
let uppercase: String->String = { $0.uppercaseString }

arr.multimap([double, uppercase])
// returns [["heyhey", "hoho"], ["HEY", "HO"]]

或者它可能以可变参数形式非常好：

extension SequenceType {
    func multimap<U>(transformations: (Generator.Element->U)...) -> [[U]] {
        return self.multimap(transformations)
    }
}

arr.multimap({ $0 + $0 }, { $0.uppercaseString })

编辑：如果你想要单独的变量，我认为你能做的最好的就是destructure 函数（不幸的是，你必须为每个 n 元组声明 n 次）：

// I don't think this can't be expressed as a protocol extension quite yet
func destructure<C: CollectionType>(source: C) -> (C.Generator.Element,C.Generator.Element) {
    precondition(source.count == 2)
    return (source[source.startIndex],source[source.startIndex.successor()])
}

// and, since it's a function, let's declare pipe forward
// to make it easier to call
infix operator |> { }
func |> <T,U>(lhs: T, rhs: T->U) -> U {
    return rhs(lhs)
}

然后你可以像这样声明变量：

let (doubled,uppercased)
    = arr.multimap({ $0 + $0 }, { $0.uppercaseString }) |> destructure

是的，这有点低效，因为您必须先构建数组，然后再将其拆开——但这实际上并不重要，因为数组是写时复制的，而且我们谈论的是少数它们在外部数组中。

编辑：使用新的guard 声明的借口：

func destructure<C: Sliceable where C.SubSlice.Generator.Element == C.Generator.Element>(source: C) -> (C.Generator.Element,C.Generator.Element) {
    guard let one = source.first else { fatalError("empty source") }
    guard let two = dropFirst(source).first else { fatalError("insufficient elements") }

    return (one,two)
}

Answer 2

你对元组的建议有什么问题？

let arr = ["hey", "ho"]

let  mapped = arr.map {e in
  return (e + e, e.capitalizedString)
}

Answer 3

这样怎么样，我们在映射“doubled”数组的同时处理“capitalized”数组：

let arr = ["hey", "ho"]

var capitalized = [String]()
let doubled = arr.map {(var myString) -> String in
    capitalized.append(myString.capitalizedString)
    return myString + myString
} 

//doubled ["heyhey", "hoho"]
//capitalized: ["Hey", "Ho"]