generic rest parameters

[maiermic]

As mentioned in #96 we can describe generics that take an indefinite number of type arguments using rest parameter syntax:

interface Collection[...T] {
  // use rest parameters to describe Collection interface 
}

But how can we access a specific type (argument) of the passed rest arguments?

[maiermic]

Say Collection[Number, String, Boolean] should for example be equal to the interface

{
  0: Number,
  1: String,
  2: Boolean,

  length: Number
}

We can calculate this type using a JavaScript function

function CollectionType(types) {
  var collectionType = {};
  for (var t in types) {
    collectionType[t] = types[t];
  }
  return collectionType;
}

and define

interface Collection[...T] {
  ...(CollectionType(T)),
  length: Number
}

How is Collection[Number, String, Boolean] calculated?

Number, String and Boolean are passed to Collection[...T]. Since T is a rest parameter T is an array [Number, String, Boolean]. Let's substitute

{
  ...(CollectionType([Number, String, Boolean])),
  length: Number
}

apply CollectionType

{
  ...({ 0: Number, 1: String, 2: Boolean }),
  length: Number
}

apply the spread operator and we get the intended interface

{
  0: Number,
  1: String,
  2: Boolean,

  length: Number
}

Note: This introduces dependent types.

How can we describe types with an indefinite number of actual type arguments like Collection[Number, String, ...Boolean]? The equivalent interface has an indefinite number of properties.

[maiermic]

How can we describe types with an indefinite number of actual type arguments like Collection[Number, String, ...Boolean]?

Collection[Number, String, ...Boolean]

is equal to

{
  ...Dictionary[Number, Boolean],
  0: Number,
  1: String,

  length: Number
}

Note: See #99 for definition of Dictionary[Key, Value].

Since ...Boolean is a special type argument that represents 0 or more type arguments Boolean it has to be represented as special value to be distinguishable. I will introduce a new built-in type

interface Spread[T] {
    type: T
}

to describe ...Boolean as Spread[Boolean].

Now we can define Collection interface as

interface Collection[...T] {
  ...(RestElements(T))
  ...(CollectionType(T)),
  length: Number
}

where

function CollectionType(types) {
  var collectionType = {};
  for (var t in types) {
    if (!isSpread(types[t])) { // exclude spread type argument
      collectionType[t] = types[t];
    }
  }
  return collectionType;
}

function RestElements(types) {
  if (types.length > 0) {
    var lastType = types[types.length - 1];
    if (isSpread(lastType)) {
      return Dictionary(Number, lastType.type);
    }
  }
  return {};
}

function isSpread(type) {
  return type instanceof Spread;
}

[ericelliott]

I like Collection[Number, String, ...Boolean] in the context of #120. Does this proposal need revision?