Today, I was kicking around in a playground because (1) writing about playgrounds is kind of a thing right now and (2) because my kids were away and I had some time. I started trying to mess with tuples, and more specifically to zip them because tuples and structs tend to have related data in similar positions.

In any case, I ended up creating a small set of what I call  EVIL UNIVERSE SPOCK UTILITIES using mirroring and goatees. I thought I’d throw these out there to see whether they’re generally useful or interesting:

```// MARK: Mirror-based Utilities
// These work across arrays, structures, tuples
// Goatees are mandatory

// This function maps a closure across anything
func mirrorDo<S>(structure:S, closure:(Int, String, Any)->()) {
let mirror = reflect(structure)
for index in 0 ..< mirror.count {
closure(index, mirror[index].0, mirror[index].1.value)
}
}

// This function collects the results of the mapped closure
func mirrorMap<S>(structure:S, closure:(Int, String, Any)->Any)->[Any]{
let mirror = reflect(structure)
var results = [Any]()
for index in 0 ..< mirror.count {
let result = closure(index, mirror[index].0, mirror[index].1.value)
results += [result]
}
return results
}

// This converts nearly anything into an array
func mirrorToArray<S>(structure:S) -> [Any] {
return mirrorMap(structure){return \$2}
}

// This function zips things into array pairs
func mirrorZipToArray<S, T>(s:S, t:T)->[[Any]] {
var array = [[Any]]()
for each in zip(mirrorToArray(s), mirrorToArray(t)) {
array += [mirrorToArray(each)]
}
return array
}```

For example, you might look at all the elements or fields in a tuple or structure:

```for test : Any in [tuple1, rect, point, transform] {
println("\(test.dynamicType): ")
mirrorDo(test){ (index: Int, field : String, value : Any) -> () in
println("type:\(value.dynamicType), index: \(index), field: \(field), value: \(value)")
}
}```

Or you might convert items to an array:

```for test : Any in [tuple1, rect, array2, point, transform] {
println("Converting \(test) to array")
println(mirrorToArray(test))
}```

Or you might just zip stuff together into arrays:

```mirrorZipToArray(array3, array2)
mirrorZipToArray(tuple1, tuple2)```

You’ll find the code and a bunch of examples that showcase their use in this gist.

Two other things that simply pleased my aesthetics today. First: I really like that you can apply maps to zips.

`var results = map(zip(["a", "b", "c"], ["d", "b", "e"])){\$0==\$1}`

And also you can pass tuples to functions and closures as parameter sets:

```func plus(a: Int, b: Int) -> Int {return a + b}
let xx = (2, 3); let yy = (5, 9)
plus(xx)
plus(yy)```

Best of all, you can combine these approaches to zip and then use the tuples in a function call like this:

```map(zip([1, 2, 3, 4], [5, 6, 7, 8])){plus(\$0)}
```

Isn’t that cool for a boring Sunday?