Currently (version 4.1), Typescript is able to deduce that an array access to a tuple is within bounds if it is indexed by an integer literal union type that fits within the array, e.g.:
type I = 0 | 1 | 2;
function access(i: I, a: [string, string, string]) {
return a[i];
} // type: string, even with noUncheckedIndexedAccess = true
However, as soon as there is an operation on the indexing variable, even trivial, Typescript falls back to inferring number. Therefore, the following code:
type I = 0 | 1;
function access(i: I, a: [string, string, string]) {
return a[i + 1];
} // type: string | undefined, when noUncheckedIndexedAccess = true
In principle, Typescript could reason a bit deeper on the set of possible integer values when going through operations, especially for the trivial ones like in my example. If there is a lot of values in the union, it might be computationally expensive, but in that case a conservative bound analysis would already be enough for most uses cases (see #15480).
📃 Motivating Example
The proposed feature would at minimum allow:
type I = 0 | 1;
function access(i: I, a: [string, string, string]) {
return a[i + 1];
}
and, if possible, use cases such as:
type Vector = [number, number];
type Matrix = [number, number, number, number];
const Range = [0, 1] as const;
function mult(m: Matrix, v: Vector) {
let ret: Vector = [0, 0];
for (const i of Range) {
let acc = 0;
for (const j of Range) {
acc += v[j] * m[i * 2 + j];
}
ret[i] = acc;
}
return ret;
}
and, if Vector and Matrix can be aliases to fixed-size typed arrays (see #18471) in addition to tuple, it would be wonderful.
💻 Use Cases
That feature would be very useful in conjunction with noUncheckedIndexedAccess obviously, but also with a way to statically type the length of TypedArray (see #18471) for use in mathematical and graphics code. But even without typed arrays, it would still be useful in day-to-day code. I'm experimenting in switching our 45 kloc Typescript code base to noUncheckedIndexedAccess = true and that feature would increase type safety in several places.
Suggestion
🔍 Search Terms
tuple bounds, tuple index computing, bound checking removal, noUncheckedIndexedAccess
✅ Viability Checklist
My suggestion meets these guidelines:
⭐ Suggestion
Currently (version 4.1), Typescript is able to deduce that an array access to a tuple is within bounds if it is indexed by an integer literal union type that fits within the array, e.g.:
However, as soon as there is an operation on the indexing variable, even trivial, Typescript falls back to inferring
number
. Therefore, the following code:In principle, Typescript could reason a bit deeper on the set of possible integer values when going through operations, especially for the trivial ones like in my example. If there is a lot of values in the union, it might be computationally expensive, but in that case a conservative bound analysis would already be enough for most uses cases (see #15480).
📃 Motivating Example
The proposed feature would at minimum allow:
and, if possible, use cases such as:
and, if
Vector
andMatrix
can be aliases to fixed-size typed arrays (see #18471) in addition to tuple, it would be wonderful.💻 Use Cases
That feature would be very useful in conjunction with
noUncheckedIndexedAccess
obviously, but also with a way to statically type the length ofTypedArray
(see #18471) for use in mathematical and graphics code. But even without typed arrays, it would still be useful in day-to-day code. I'm experimenting in switching our 45 kloc Typescript code base tonoUncheckedIndexedAccess = true
and that feature would increase type safety in several places.