I just encountered a small thing that perhaps could be expressed even better in Swift at some point in the future. Perhaps it has to do with Variadic Generics or extending non-nominal types, but I am not 100% sure:
I have two values of type A that I would like to map using the same function f: (A) -> B.
I could of course do:
let b1 = f(a1)
let b2 = f(a2)
But I would like to be able to express this a bit more concisely (namely in a fashion where it is clear to the reader that the same transform is being applied to both values - and that this is by intent and a2 should never ever be transformed in another fashion than a1).
I could of course do:
let bs = [a1, a2].map(f)
This has the level of conciseness that I would like, but now I have to index into bs in order to retrieve the values - which is alright, but perhaps it could be better:
let (b1, b2) = (a1, a2).map(f)
So in short: being able to map a tuple of values of the same type A into a same sized tuple of transformed values of type B.
From my vague understanding about Variadic Generics and it's application to tuples, it could some day be possible to define a function like map on a tuple of any size with the same generic type for each value.
Am I understanding these concepts correctly - and do people think that something like this will in fact be possible at some point?
