feature: ability to extract union of valid index numbers for tuple
See original GitHub issueSearch 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
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.
Issue Analytics
- State:
- Created 4 years ago
- Comments:10 (5 by maintainers)
@AlCalzone Do you need
Drop1
? Can you not just exclude the length of the original tuple?Damn! Never thought of this… 👀 But that includes one union item too much.
Partial<Drop1<T>>["length"]
works with