Variadic Generics

[Douglas_Gregor]

@technicated

I think that variadic generics can be represented as tuples once "instantiated", and there is a similar precedent in the language too with variadics function argument becoming Array s. I say "I think" because I'm not actually sure that this is what the manifesto suggests - given the iterators example in which it talks about "zero or more stored properties" instead of a tuple of iterators instances.

struct Variadic<...T> {
  var (...items): (T...)
}

I sorta regret writing the example in that way. Swift shouldn't need the prefix "...", and that definition of items is probably wrong. If we're using "...", that example should likely be written as:

struct Variadic<T...> {
  var items: (T...)
}

Same thing here:

@technicated

var (...iterators): (Iterators...)

we don't need the prefix "...", and probably don't even want the notion of it in the language. iterators can be described as:

var iterators: (Iterators...)

so we're forming a tuple type from the types in Iterators and storing that.

@technicated

guard let values = (iterators.next()...) else { // call "next" on each of the iterators, put the results into a tuple named "values" reachedEnd = true return nil }

You are correct; my example here was bogus. I'll take a pass through this part of the generics manifesto so at least it's not as misleading and wrong. Thank you!

@technicated

We could use the same ... operator for tuple splatting. Other than the example of the Manifesto, in which a function with variadic generics is called expanding the arguments passed to it, the feature might be useful to allow one to write something like this:

let (...head, tail) = someTuple
// `someTuple` is a tuple containing N elements
// `head` is a tuple containing the first N-1 elements of `someTuple`
// `tail` is a single value (not a tuple) containing the last element of `someTuple`

This may not work so well in a generic context unless you had a way to say "I know that someTuple has at least one element".

When it comes to tuple splatting, I think what we really want is a way to take a tuple and expand it into N separate arguments, e.g.,

let someTuple = (1, 3.14159, "Hello")
f(someTuple...). // equivalent to f(1, 3.14159, "Hello")

It's plausible that we could integrate that with variadic generics if, say, a "function parameter pack" was represented as a tuple and all tuples could be expanded like that.

Doug