Sounds like a duplicate of #34589.

No, I don't think so - #34589 is about tuple types. This is about using literal types for the .length and elements of a string literal.

Would be nice to understand why this would be useful

https://github.com/samchon/tgrid/blob/467aa3b8b619aab36bb50257feaa8de208de5888/src/components/Driver.ts#L85-L91

type is_edge_underscored<P> = P extends string
    ? P[0] extends "_"
        ? true
        : P[typeof (P.length - 1)] extends "_"
            ? true
            : false
    : false;

@RyanCavanaugh To implement a type detecting the edge-underscored string, I've also published a new issue #34844, hoping (Literal.length - 1) also be the constant value. However, I can't sure that I've requested exact features for the edge-underscored string. If I'm forgetting something important, please inform me.

There is a lot of use cases

One use case is asserting that a method is only called for a single character, mimicking the char type from other languages:

type SingleChar = string & { length: 1 };
const charCodeOf = (char: SingleChar): number => char.charCodeAt(0);

charCodeOf('a'); // Should work
charCodeOf('asdhfkj') // Should fail
charCodeOf('') // Should also fail

Also prevent literal empty strings from being passed as arguments:

type EmptyString = string & { length: 0 };
type SingleChar = string & { length: 1 };

const lastChar = (str: Exclude<string, EmptyString>): SingleChar => str[str.length - 1]!;

lastChar('abc'); // Should work
lastChar(''); // Should fail

// We could also better narrow the return types

const typedLastChar = <S extends string>(
  str: S,
): S extends EmptyString ? undefined : SingleChar => str[str.length - 1];

const ch1: string = typedLastChar('qwe'); // should work
const ch2: string = typedLastChar(''); // should fail
const ch3: undefined = typedLastChar(''); // should work

I'm sure there's others cases to type against fixed length strings (fixed length hashs maybe? or identifications cards?)

In my opninion the proposal is a really good addition, it's amazing for typing DSLs and builders

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 of [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>

🍺