feature: ability to extract union of valid index numbers for tuple

Search Terms

indexof array indexof tuple restrict argument to tuple index

Suggestion

I'd like the ability to restrict a type to a valid index number of a tuple. For example, given the tuple [string], I'd like to extract the type 0. Given the tuple [string, number, object], I'd like to extract the type 0 | 1 | 2.

Use Cases

see related S.O. question

Currently, if a generic class receives a type argument which is a tuple, it isn't possible to create a method on the class which restricts its argument to a valid index of that tuple.

Examples

class FormArray<T extends [any, ...any[]]> {
  constructor(public value: T) {}

  // how to restrict `I` to only valid index numbers of `T` ?
  get<I extends keyof T>(index: I): T[I] {
    return this.value[index];
  }
}

Implementation ideas

I imagine there are several routes to achieving my goal.

Idea 1 (perhaps heavy handed):

Add a new keyword, such as indexof which can only be used on arrays and tuples. If indexof is used on an array, it will always return number. If indexof is used on a tuple, it returns a union of 0 .... tuple length - 1 (e.g. if the tuple was of length 3 indexof would return 0 | 1 | 2).

Idea 2:

Ability to cast a string type to the equivalent number type. For example, the ability to cast type "0" to 0. This would allow using the keyof keyword to get all properties of a tuple, cast property types to numbers (if possible), and then filter out any property types which aren't numbers (i.e. filter out "length", "splice", etc. and leave 0 | 1 | 2).

For example, as pointed out in this comment, it is currently possible to get the indexes of a tuple in string form (i.e. "0" | "1" | "2").

type ArrayKeys = keyof any[];
type Indices<T> = Exclude<keyof T, ArrayKeys>;

Indices<[string, number]>; // "0" | "1"

Idea 3:

As pointed out in a comment, you can get the index numbers of a tuple using the following type:

type Indices<T extends {length: number}> = Exclude<Partial<T>["length"], T['length']>;

Unfortunately, the result of this type is not considered a keyof the input tuple (which results in a type error if you try and use the type as a key for the tuple). If there were some way of using a type assertion to tell the compiler that this is, in fact, a keyof T, that might also work.

note: this type differs from the type presented in idea 2 (above) because, unlike this type, the type in idea 2 is a keyof T

Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

Inizia con gli esempi di indici delle tuple e con la domanda collegata su Stack Overflow e il commento di TypeScript citati nell’issue. Il lavoro è completato quando un tipo tupla può esporre la propria unione di indici numerici validi e tale unione può essere usata per indicizzare la tupla in modo sicuro senza modifiche a runtime.