Enhance members of literal type like const array type (e.g. string literal types should have literal length property)

The const array type, its principle members are also be the constant. When define a const array [number, string, boolean], its length type be 3. Also, when access to special index, the type also points the exact const type.

function const_array(): void
{
    let elements: [number, string, false] = [3, "something", false];
    let length: 3 = elements.length;

    let first: number = elements[0];
    let second: string = elements[1];
    let third: false = elements[2];
}

However, the literal type is not like the const array. When define a literal type “something”, its length be not 9 but number. Also, when access to a special index, the type is not a special literal type but a string type.

function literal(): void
{
    let word: "something" = "something" as const;
    let length: number = something.length; // not 9 but number

    let first: string = word[0]; // not "s" but string
    let second: string = word[1]; // not "o" but string
    let third: string = word[2]; // not "m" but string
}

What about enhancing the literal type to be like the const array type?

[sno2]

Hello, for those looking for a more efficient solution, I’ve created a logarithmic implementation for anyone who is still facing this issue but can’t use the linear implementation due to the poor performance of it https://gist.github.com/sno2/7dac868ec6d11abb75250ce5e2b36041

Edit: hmm I will consider a logarithmic string indexer as well

[unional]

Another use case: currently some type level arithmetics leverage the fact that array length produces number literal. This creates a performance issue. I am doing that in type-plus and during development I have to limit the digits to 3-4 so that the IDE is still performant.

With template literal type, if 'abc'['length'] gets the same treatment as [1,1,1]['length'], there might be a big performance gain there.

Another example of type level arithmetics: Implementing Arithmetic Within TypeScript’s Type System

But of course, the best solution is adding

type Add<A extends number, B extends number> = intrinsic
type Subtract<A extends number, B extends number> = intrinsic
type Increment<A extends number> = Add<A, 1>
type Decrement<A extends number> = Subtract<A, 1>

🍺